grml2usb

   1 #!/usr/bin/env python
   2 # -*- coding: utf-8 -*-
   3 """
   4 grml2usb
   5 ~~~~~~~~
   6
   7 This script installs a grml system (either a running system or ISO[s]) to a USB device
   8
   9 :copyright: (c) 2009 by Michael Prokop <mika@grml.org>
  10 :license: GPL v2 or any later version
  11 :bugreports: http://grml.org/bugs/
  12
  13 """
  14
  15 # from __future__ import with_statement
  16 from optparse import OptionParser
  17 from inspect import isroutine, isclass
  18 import datetime, logging, os, re, subprocess, sys, tempfile, time, os.path
  19
  20 # global variables
  21 PROG_VERSION = "0.9.10"
  22 MOUNTED = set()  # register mountpoints
  23 TMPFILES = set() # register tmpfiles
  24 DATESTAMP = time.mktime(datetime.datetime.now().timetuple()) # unique identifier for syslinux.cfg
  25 GRML_FLAVOURS = set() # which flavours are being installed?
  26 global GRML_DEFAULT
  27
  28 # cmdline parsing
  29 USAGE = "Usage: %prog [options] <[ISO[s] | /live/image]> </dev/sdX#>\n\
  30 \n\
  31 %prog installs grml ISO[s] to an USB device to be able to boot from it.\n\
  32 Make sure you have at least one grml ISO or a running grml system (/live/image),\n\
  33 grub or syslinux and root access.\n\
  34 \n\
  35 Run %prog --help for usage hints, further information via: man grml2usb"
  36
  37 # pylint: disable-msg=C0103
  38 parser = OptionParser(usage=USAGE)
  39 parser.add_option("--bootoptions", dest="bootoptions",
  40                   action="store", type="string",
  41                   help="use specified bootoptions as default")
  42 parser.add_option("--bootloader-only", dest="bootloaderonly", action="store_true",
  43                   help="do not copy files but just install a bootloader")
  44 parser.add_option("--copy-only", dest="copyonly", action="store_true",
  45                   help="copy files only but do not install bootloader")
  46 parser.add_option("--dry-run", dest="dryrun", action="store_true",
  47                   help="avoid executing commands")
  48 parser.add_option("--fat16", dest="fat16", action="store_true",
  49                   help="format specified partition with FAT16")
  50 parser.add_option("--force", dest="force", action="store_true",
  51                   help="force any actions requiring manual interaction")
  52 #parser.add_option("--initrd", dest="initrd", action="store", type="string",
  53 #                  help="install specified initrd instead of the default [TODO - not implemented yet]")
  54 #parser.add_option("--kernel", dest="kernel", action="store", type="string",
  55 #                  help="install specified kernel instead of the default [TODO - not implemented yet]")
  56 parser.add_option("--lilo-binary", dest="lilobin",  action="store", type="string",
  57                   help="lilo executable to be used for installing MBR")
  58 parser.add_option("--mbr-menu", dest="mbrmenu", action="store_true",
  59                   help="enable interactive boot menu in MBR")
  60 parser.add_option("--quiet", dest="quiet", action="store_true",
  61                   help="do not output anything but just errors on console")
  62 parser.add_option("--skip-addons", dest="skipaddons", action="store_true",
  63                   help="do not install /boot/addons/ files")
  64 parser.add_option("--skip-grub-config", dest="skipgrubconfig", action="store_true",
  65                   help="skip generation of grub configuration files")
  66 parser.add_option("--skip-mbr", dest="skipmbr", action="store_true",
  67                   help="do not install a master boot record (MBR) on the device")
  68 parser.add_option("--skip-syslinux-config", dest="skipsyslinuxconfig", action="store_true",
  69                   help="skip generation of syslinux configuration files")
  70 parser.add_option("--syslinux", dest="syslinux", action="store_true",
  71                   help="install syslinux bootloader instead of grub")
  72 parser.add_option("--syslinux-mbr", dest="syslinuxmbr", action="store_true",
  73                   help="install syslinux master boot record (MBR) instead of default")
  74 #parser.add_option("--squashfs", dest="squashfs", action="store", type="string",
  75 #                  help="install specified squashfs file instead of the default [TODO - not implemented yet]")
  76 #parser.add_option("--uninstall", dest="uninstall", action="store_true",
  77 #                  help="remove grml ISO files from specified device [TODO - not implemented yet]")
  78 parser.add_option("--verbose", dest="verbose", action="store_true",
  79                   help="enable verbose mode")
  80 parser.add_option("-v", "--version", dest="version", action="store_true",
  81                   help="display version and exit")
  82 (options, args) = parser.parse_args()
  83
  84 GRML2USB_BASE = '/usr/share/grml2usb'
  85 if not os.path.isdir(GRML2USB_BASE):
  86     GRML2USB_BASE = os.path.dirname(os.path.realpath(__file__))
  87
  88
  89 class CriticalException(Exception):
  90     """Throw critical exception if the exact error is not known but fatal."
  91
  92     @Exception: message"""
  93     pass
  94
  95
  96 def cleanup():
  97     """Cleanup function to make sure there aren't any mounted devices left behind.
  98     """
  99
 100     logging.info("Cleaning up before exiting...")
 101     proc = subprocess.Popen(["sync"])
 102     proc.wait()
 103
 104     try:
 105         for device in MOUNTED:
 106             unmount(device, "")
 107     # ignore: RuntimeError: Set changed size during iteration
 108     except RuntimeError:
 109         logging.debug('caught expection RuntimeError, ignoring')
 110
 111
 112 def register_tmpfile(path):
 113     """
 114     TODO - not implemented yet
 115     """
 116
 117     TMPFILES.add(path)
 118
 119
 120 def unregister_tmpfile(path):
 121     """
 122     TODO - not implemented yet
 123     """
 124
 125     if path in TMPFILES:
 126         TMPFILES.remove(path)
 127
 128
 129 def register_mountpoint(target):
 130     """register specified target in a set() for handling clean exiting
 131
 132     @target: destination target of mountpoint
 133     """
 134
 135     MOUNTED.add(target)
 136
 137
 138 def unregister_mountpoint(target):
 139     """unregister specified target in a set() for handling clean exiting
 140
 141     @target: destination target of mountpoint
 142     """
 143
 144     if target in MOUNTED:
 145         MOUNTED.remove(target)
 146
 147
 148 def get_function_name(obj):
 149     """Helper function for use in execute() to retrive name of a function
 150
 151     @obj: the function object
 152     """
 153     if not (isroutine(obj) or isclass(obj)):
 154         obj = type(obj)
 155     return obj.__module__ + '.' + obj.__name__
 156
 157
 158 def execute(f, *exec_arguments):
 159     """Wrapper for executing a command. Either really executes
 160     the command (default) or when using --dry-run commandline option
 161     just displays what would be executed."""
 162     # usage: execute(subprocess.Popen, (["ls", "-la"]))
 163     # TODO: doesn't work for proc = execute(subprocess.Popen...() -> any ideas?
 164     if options.dryrun:
 165         # pylint: disable-msg=W0141
 166         logging.debug('dry-run only: %s(%s)' % (get_function_name(f), ', '.join(map(repr, exec_arguments))))
 167     else:
 168         # pylint: disable-msg=W0142
 169         return f(*exec_arguments)
 170
 171
 172 def is_exe(fpath):
 173     """Check whether a given file can be executed
 174
 175     @fpath: full path to file
 176     @return:"""
 177     return os.path.exists(fpath) and os.access(fpath, os.X_OK)
 178
 179
 180 def which(program):
 181     """Check whether a given program is available in PATH
 182
 183     @program: name of executable"""
 184     fpath = os.path.split(program)[0]
 185     if fpath:
 186         if is_exe(program):
 187             return program
 188     else:
 189         for path in os.environ["PATH"].split(os.pathsep):
 190             exe_file = os.path.join(path, program)
 191             if is_exe(exe_file):
 192                 return exe_file
 193
 194     return None
 195
 196
 197 def search_file(filename, search_path='/bin' + os.pathsep + '/usr/bin'):
 198     """Given a search path, find file
 199
 200     @filename: name of file to search for
 201     @search_path: path where searching for the specified filename"""
 202     file_found = 0
 203     paths = search_path.split(os.pathsep)
 204     current_dir = '' # make pylint happy :)
 205     for path in paths:
 206         # pylint: disable-msg=W0612
 207         for current_dir, directories, files in os.walk(path):
 208             if os.path.exists(os.path.join(current_dir, filename)):
 209                 file_found = 1
 210                 break
 211     if file_found:
 212         return os.path.abspath(os.path.join(current_dir, filename))
 213     else:
 214         return None
 215
 216
 217 def check_uid_root():
 218     """Check for root permissions"""
 219     if not os.geteuid()==0:
 220         sys.exit("Error: please run this script with uid 0 (root).")
 221
 222
 223 def mkfs_fat16(device):
 224     """Format specified device with VFAT/FAT16 filesystem.
 225
 226     @device: partition that should be formated"""
 227
 228     # syslinux -d boot/isolinux /dev/sdb1
 229     if options.dryrun:
 230         logging.info("Would execute mkfs.vfat -F 16 %s now.", device)
 231         return 0
 232
 233     logging.info("Formating partition with fat16 filesystem")
 234     logging.debug("mkfs.vfat -F 16 %s" % device)
 235     proc = subprocess.Popen(["mkfs.vfat", "-F", "16", device])
 236     proc.wait()
 237     if proc.returncode != 0:
 238         raise CriticalException("error executing mkfs.vfat")
 239
 240
 241 def generate_main_grub2_config(grml_flavour, bootoptions):
 242     """Generate grub2 configuration for use via grub.cfg
 243
 244     @grml_flavour: name of grml flavour the configuration should be generated for
 245     @bootoptions: additional bootoptions that should be used by default"""
 246
 247     local_datestamp = DATESTAMP
 248
 249     return("""\
 250 ## main grub2 configuration - generated by grml2usb [main config generated at: %(local_datestamp)s]
 251 set default=0
 252 set timeout=10
 253
 254 insmod fat
 255
 256 if loadfont /boot/grub/ascii.pf2 ; then
 257    insmod png
 258    set gfxmode=640x480
 259    insmod gfxterm
 260    insmod vbe
 261    if terminal_output.gfxterm ; then true ; else
 262     # For backward compatibility with versions of terminal.mod that don't
 263     # understand terminal_output
 264     terminal gfxterm
 265    fi
 266 fi
 267
 268 if background_image /boot/grub/grml.png ; then
 269   set color_normal=black/black
 270   set color_highlight=red/black
 271 else
 272   set menu_color_normal=white/black
 273   set menu_color_highlight=black/yellow
 274 fi
 275
 276 menuentry "%(grml_flavour)s (default)" {
 277     set gfxpayload=1024x768x16,1024x768
 278     linux   /boot/release/%(grml_flavour)s/linux26 apm=power-off quiet boot=live nomce live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 279     initrd  /boot/release/%(grml_flavour)s/initrd.gz
 280 }
 281
 282 menuentry "Memory test (memtest86+)" {
 283     linux16   /boot/addons/memtest
 284 }
 285
 286 menuentry "Boot Grub (all in one image)" {
 287     linux   /boot/addons/memdisk
 288     initrd  /boot/addons/allinone.img
 289 }
 290
 291 menuentry "Boot FreeDOS" {
 292     linux   /boot/addons/memdisk
 293     initrd  /boot/addons/balder10.imz
 294 }
 295
 296 menuentry "Boot MirOS bsd4grml" {
 297     multiboot /boot/addons/bsd4grml/ldbsd.com
 298     module    /boot/addons/bsd4grml/bsd.rd
 299     module    /boot/addons/bsd4grml/boot.1
 300     module    /boot/addons/bsd4grml/boot.2
 301     module    /boot/addons/bsd4grml/boot.3
 302     module    /boot/addons/bsd4grml/boot.4
 303     module    /boot/addons/bsd4grml/boot.5
 304     module    /boot/addons/bsd4grml/boot.6
 305     module    /boot/addons/bsd4grml/boot.cfg
 306 }
 307
 308 menuentry "Boot OS of first partition on first disk" {
 309     set root=(hd0,1)
 310     chainloader +1
 311 }
 312
 313 """ % {'grml_flavour': grml_flavour, 'local_datestamp': local_datestamp,
 314         'bootoptions': bootoptions } )
 315
 316
 317 def generate_flavour_specific_grub2_config(grml_flavour, bootoptions):
 318     """Generate grub2 configuration for use via grub.cfg
 319
 320     @grml_flavour: name of grml flavour the configuration should be generated for
 321     @bootoptions: additional bootoptions that should be used by default"""
 322
 323     local_datestamp = DATESTAMP
 324
 325     return("""\
 326 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 327 menuentry "%(grml_flavour)s            - boot in default mode" {
 328     set gfxpayload=1024x768x16,1024x768
 329     linux  /boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 330     initrd /boot/release/%(grml_flavour)s/initrd.gz
 331 }
 332
 333 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 334 menuentry "%(grml_flavour)s-persistent - enable persistency feature" {
 335     set gfxpayload=1024x768x16,1024x768
 336     linux  /boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet persistent live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 337     initrd /boot/release/%(grml_flavour)s/initrd.gz
 338 }
 339
 340 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 341 menuentry "%(grml_flavour)s2ram        - copy compressed grml file to RAM" {
 342     set gfxpayload=1024x768x16,1024x768
 343     linux  /boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ toram=%(grml_flavour)s.squashfs %(bootoptions)s
 344     initrd /boot/release/%(grml_flavour)s/initrd.gz
 345 }
 346
 347 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 348 menuentry "%(grml_flavour)s-debug      - enable debugging options" {
 349     set gfxpayload=1024x768x16,1024x768
 350     linux /boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ debug boot=live initcall_debug%(bootoptions)s
 351     initrd /boot/release/%(grml_flavour)s/initrd.gz
 352 }
 353
 354 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 355 menuentry "%(grml_flavour)s-x          - start X Window System" {
 356     set gfxpayload=1024x768x16,1024x768
 357     linux  /boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ startx=wm-ng %(bootoptions)s
 358     initrd /boot/release/%(grml_flavour)s/initrd.gz
 359 }
 360
 361 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 362 menuentry "%(grml_flavour)s-nofb       - disable framebuffer" {
 363     linux  /boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ vga=normal video=ofonly %(bootoptions)s
 364     initrd /boot/release/%(grml_flavour)s/initrd.gz
 365 }
 366
 367 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 368 menuentry "%(grml_flavour)s-failsafe   - disable hardware detection" {
 369     linux /boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ vga=normal boot=live noautoconfig atapicd noapic noacpi acpi=off nomodules nofirewire noudev nousb nohotplug noapm nopcmcia nosmp maxcpus=0 noscsi noagp nodma ide=nodma noswap nofstab nosound nogpm nosyslog nodhcp nocpu nodisc nomodem xmodule=vesa noraid nolvm noresume selinux=0 edd=off %(bootoptions)s
 370     initrd /boot/release/%(grml_flavour)s/initrd.gz
 371 }
 372
 373 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 374 menuentry "%(grml_flavour)s-forensic   - do not touch harddisks during hw recognition" {
 375     set gfxpayload=1024x768x16,1024x768
 376     linux /boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ nofstab noraid nolvm noautoconfig noswap raid=noautodetect forensic readonly %(bootoptions)s
 377     initrd /boot/release/%(grml_flavour)s/initrd.gz
 378 }
 379
 380 """ % {'grml_flavour': grml_flavour, 'local_datestamp': local_datestamp,
 381        'bootoptions': bootoptions } )
 382
 383
 384 def generate_flavour_specific_grub1_config(grml_flavour, install_partition, bootoptions):
 385     """Generate grub1 configuration for use via menu.lst
 386
 387     @grml_flavour: name of grml flavour the configuration should be generated for
 388     @install_partition: partition number for use in (hd0,X)
 389     @bootoptions: additional bootoptions that should be used by default"""
 390
 391     local_datestamp = DATESTAMP
 392
 393     return("""\
 394 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 395 title %(grml_flavour)s
 396 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 397 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 398
 399 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 400 title %(grml_flavour)s-persistent
 401 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce vga=791 quiet persistent live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 402 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 403
 404 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 405 title %(grml_flavour)s2ram
 406 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ toram=%(grml_flavour)s.squashfs %(bootoptions)s
 407 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 408
 409 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 410 title %(grml_flavour)s-debug
 411 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ debug boot=live initcall_debug%(bootoptions)s
 412 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 413
 414 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 415 title %(grml_flavour)s-x
 416 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ startx=wm-ng %(bootoptions)s
 417 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 418
 419 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 420 title %(grml_flavour)s-nofb
 421 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ vga=normal video=ofonly %(bootoptions)s
 422 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 423
 424 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 425 title %(grml_flavour)s-failsafe
 426 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ vga=normal boot=live noautoconfig atapicd noapic noacpi acpi=off nomodules nofirewire noudev nousb nohotplug noapm nopcmcia nosmp maxcpus=0 noscsi noagp nodma ide=nodma noswap nofstab nosound nogpm nosyslog nodhcp nocpu nodisc nomodem xmodule=vesa noraid nolvm noresume selinux=0 edd=off %(bootoptions)s
 427 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 428
 429 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 430 title %(grml_flavour)s-forensic
 431 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ nofstab noraid nolvm noautoconfig noswap raid=noautodetect forensic readonly %(bootoptions)s
 432 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 433
 434 ## flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 435 title %(grml_flavour)s-serial
 436 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ vga=normal video=vesafb:off console=tty1 console=ttyS0,9600n8 %(bootoptions)s
 437 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 438
 439 """ % {'grml_flavour': grml_flavour, 'local_datestamp': local_datestamp,
 440        'bootoptions': bootoptions, 'install_partition': install_partition } )
 441
 442
 443 def generate_main_grub1_config(grml_flavour, install_partition, bootoptions):
 444     """Generate grub1 configuration for use via menu.lst
 445
 446     @grml_flavour: name of grml flavour the configuration should be generated for"""
 447
 448     local_datestamp = DATESTAMP
 449
 450     return("""\
 451 ## main grub1 configuration - generated by grml2usb [main config generated at: %(local_datestamp)s]
 452 # misc options:
 453 timeout 30
 454 # color red/blue green/black
 455 splashimage=(hd0,%(install_partition)s)/boot/grub/splash.xpm.gz
 456 foreground  = 000000
 457 background  = FFCC33
 458
 459 # define entries:
 460 title %(grml_flavour)s  - Default boot (using 1024x768 framebuffer)
 461 kernel (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/linux26 apm=power-off vga=791 quiet boot=live nomce live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 462 initrd (hd0,%(install_partition)s)/boot/release/%(grml_flavour)s/initrd.gz
 463
 464 title Memory test (memtest86+)
 465 kernel (hd0,%(install_partition)s)/boot/addons/memtest
 466
 467 title Grub - all in one image
 468 kernel (hd0,%(install_partition)s)/boot/addons/memdisk
 469 initrd (hd0,%(install_partition)s)/boot/addons/allinone.img
 470
 471 title FreeDOS
 472 kernel (hd0,%(install_partition)s)/boot/addons/memdisk
 473 initrd (hd0,%(install_partition)s)/boot/addons/balder10.imz
 474
 475 title MirOS BSD
 476 kernel (hd0,%(install_partition)s)/boot/addons/bsd4grml/ldbsd.com
 477
 478 """ % {'grml_flavour': grml_flavour, 'local_datestamp': local_datestamp,
 479        'bootoptions': bootoptions, 'install_partition': install_partition } )
 480
 481
 482 def generate_isolinux_splash(grml_flavour):
 483     """Generate bootsplash for isolinux/syslinux
 484
 485     @grml_flavour: name of grml flavour the configuration should be generated for"""
 486
 487     # TODO: adjust last bootsplash line (the one following the "Some information and boot ...")
 488
 489     grml_name = grml_flavour
 490
 491     return("""\
 492 \ f17\f\18/boot/syslinux/logo.16
 493
 494 Some information and boot options available via keys F2 - F10. http://grml.org/
 495 %(grml_name)s
 496 """ % {'grml_name': grml_name} )
 497
 498
 499 def generate_main_syslinux_config(grml_flavour, bootoptions):
 500     """Generate main configuration for use in syslinux.cfg
 501
 502     @grml_flavour: name of grml flavour the configuration should be generated for
 503     @bootoptions: additional bootoptions that should be used by default"""
 504
 505     local_datestamp = DATESTAMP
 506
 507     return("""\
 508 ## main syslinux configuration - generated by grml2usb [main config generated at: %(local_datestamp)s]
 509 # use this to control the bootup via a serial port
 510 # SERIAL 0 9600
 511 DEFAULT grml
 512 TIMEOUT 300
 513 PROMPT 1
 514 DISPLAY /boot/syslinux/boot.msg
 515 F1 /boot/syslinux/boot.msg
 516 F2 /boot/syslinux/f2
 517 F3 /boot/syslinux/f3
 518 F4 /boot/syslinux/f4
 519 F5 /boot/syslinux/f5
 520 F6 /boot/syslinux/f6
 521 F7 /boot/syslinux/f7
 522 F8 /boot/syslinux/f8
 523 F9 /boot/syslinux/f9
 524 F10 /boot/syslinux/f10
 525 ## end of main configuration
 526
 527 ## global configuration
 528 # the default option (using %(grml_flavour)s)
 529 LABEL  grml
 530 KERNEL /boot/release/%(grml_flavour)s/linux26
 531 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 532
 533 # memtest
 534 LABEL  memtest
 535 KERNEL /boot/addons/memtest
 536
 537 # grub
 538 LABEL grub
 539 MENU LABEL grub
 540 KERNEL /boot/addons/memdisk
 541 APPEND initrd=/boot/addons/allinone.img
 542
 543 # dos
 544 LABEL dos
 545 MENU LABEL dos
 546 KERNEL /boot/addons/memdisk
 547 APPEND initrd=/boot/addons/balder10.imz
 548
 549 # bsd
 550 LABEL bsd
 551 MENU LABEL bsd
 552 KERNEL /boot/addons/bsd4grml/ldbsd.com
 553
 554 # hardware detection tool
 555 MENU LABEL hdt
 556 KERNEL /boot/addons/hdt.c32
 557 APPEND pciids=/boot/addons/pci.ids
 558
 559 ## end of global configuration
 560 """ % {'grml_flavour': grml_flavour, 'local_datestamp': local_datestamp, 'bootoptions': bootoptions} )
 561
 562
 563 def generate_flavour_specific_syslinux_config(grml_flavour, bootoptions):
 564     """Generate flavour specific configuration for use in syslinux.cfg
 565
 566     @grml_flavour: name of grml flavour the configuration should be generated for
 567     @bootoptions: bootoptions that should be used as a default"""
 568
 569     local_datestamp = DATESTAMP
 570
 571     return("""\
 572
 573 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 574 LABEL  %(grml_flavour)s
 575 KERNEL /boot/release/%(grml_flavour)s/linux26
 576 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 577
 578 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 579 LABEL  %(grml_flavour)s-persistent
 580 KERNEL /boot/release/%(grml_flavour)s/linux26
 581 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce vga=791 quiet persistent live-media-path=/live/%(grml_flavour)s/ %(bootoptions)s
 582
 583 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 584 LABEL  %(grml_flavour)s2ram
 585 KERNEL /boot/release/%(grml_flavour)s/linux26
 586 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ toram=%(grml_flavour)s.squashfs %(bootoptions)s
 587
 588 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 589 LABEL  %(grml_flavour)s-debug
 590 KERNEL /boot/release/%(grml_flavour)s/linux26
 591 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ debug boot=live initcall_debug%(bootoptions)s
 592
 593 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 594 LABEL  %(grml_flavour)s-x
 595 KERNEL /boot/release/%(grml_flavour)s/linux26
 596 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ startx=wm-ng %(bootoptions)s
 597
 598 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 599 LABEL  %(grml_flavour)s-nofb
 600 KERNEL /boot/release/%(grml_flavour)s/linux26
 601 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ vga=normal video=ofonly %(bootoptions)s
 602
 603 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 604 LABEL  %(grml_flavour)s-failsafe
 605 KERNEL /boot/release/%(grml_flavour)s/linux26
 606 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ vga=normal boot=live noautoconfig atapicd noapic noacpi acpi=off nomodules nofirewire noudev nousb nohotplug noapm nopcmcia nosmp maxcpus=0 noscsi noagp nodma ide=nodma noswap nofstab nosound nogpm nosyslog nodhcp nocpu nodisc nomodem xmodule=vesa noraid nolvm noresume selinux=0 edd=off %(bootoptions)s
 607
 608 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 609 LABEL  %(grml_flavour)s-forensic
 610 KERNEL /boot/release/%(grml_flavour)s/linux26
 611 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce vga=791 quiet live-media-path=/live/%(grml_flavour)s/ nofstab noraid nolvm noautoconfig noswap raid=noautodetect forensic readonly %(bootoptions)s
 612
 613 # flavour specific configuration for %(grml_flavour)s [grml2usb for %(grml_flavour)s: %(local_datestamp)s]
 614 LABEL  %(grml_flavour)s-serial
 615 KERNEL /boot/release/%(grml_flavour)s/linux26
 616 APPEND initrd=/boot/release/%(grml_flavour)s/initrd.gz apm=power-off boot=live nomce quiet live-media-path=/live/%(grml_flavour)s/ vga=normal video=vesafb:off console=tty1 console=ttyS0,9600n8 %(bootoptions)s
 617 """ % {'grml_flavour': grml_flavour, 'local_datestamp': local_datestamp, 'bootoptions': bootoptions} )
 618
 619
 620 def install_grub(device):
 621     """Install grub on specified device.
 622
 623     @mntpoint: mountpoint of device where grub should install its files to
 624     @device: partition where grub should be installed to"""
 625
 626     if options.dryrun:
 627         logging.info("Would execute grub-install [--root-directory=mount_point] %s now.", device)
 628     else:
 629         device_mountpoint = tempfile.mkdtemp(prefix="grml2usb")
 630         register_tmpfile(device_mountpoint)
 631         try:
 632             try:
 633                 mount(device, device_mountpoint, "")
 634                 logging.debug("grub-install --recheck --no-floppy --root-directory=%s %s", device_mountpoint, device)
 635                 proc = subprocess.Popen(["grub-install", "--recheck", "--no-floppy",
 636                     "--root-directory=%s" % device_mountpoint, device], stdout=file(os.devnull, "r+"))
 637                 proc.wait()
 638                 if proc.returncode != 0:
 639                     # raise Exception("error executing grub-install")
 640                     logging.critical("Fatal: error executing grub-install (please check the grml2usb FAQ)")
 641                     cleanup()
 642                     sys.exit(1)
 643             except CriticalException, error:
 644                 logging.critical("Fatal: %s" % error)
 645                 cleanup()
 646                 sys.exit(1)
 647
 648         finally:
 649             unmount(device_mountpoint, "")
 650             os.rmdir(device_mountpoint)
 651             unregister_tmpfile(device_mountpoint)
 652
 653
 654 def install_syslinux(device):
 655     """Install syslinux on specified device.
 656
 657     @device: partition where syslinux should be installed to"""
 658
 659     if options.dryrun:
 660         logging.info("Would install syslinux as bootloader on %s", device)
 661         return 0
 662
 663     # syslinux -d boot/isolinux /dev/sdb1
 664     logging.info("Installing syslinux as bootloader")
 665     logging.debug("syslinux -d boot/syslinux %s" % device)
 666     proc = subprocess.Popen(["syslinux", "-d", "boot/syslinux", device])
 667     proc.wait()
 668     if proc.returncode != 0:
 669         raise CriticalException("Error executing syslinux (either try --fat16 or --grub?)")
 670
 671
 672 def install_bootloader(device):
 673     """Install bootloader on specified device.
 674
 675     @device: partition where bootloader should be installed to"""
 676
 677     # by default we use grub, so install syslinux only on request
 678     if options.syslinux:
 679         try:
 680             install_syslinux(device)
 681         except CriticalException, error:
 682             logging.critical("Fatal: %s" % error)
 683             cleanup()
 684             sys.exit(1)
 685     else:
 686         if not which("grub-install"):
 687             logging.critical("Fatal: grub-install not available (please install the grub package or use the --syslinux option)")
 688             cleanup()
 689             sys.exit(1)
 690         else:
 691             try:
 692                 install_grub(device)
 693             except CriticalException, error:
 694                 logging.critical("Fatal: %s" % error)
 695                 cleanup()
 696                 sys.exit(1)
 697
 698
 699 def execute_lilo(lilo, device):
 700     """execute lilo for activating the partitions in the MBR
 701
 702     @lilo: path of lilo executable
 703     @device: device where lilo should be executed on"""
 704
 705     # to support -A for extended partitions:
 706     logging.info("Activating partitions in MBR via lilo")
 707     logging.debug("%s -S /dev/null -M %s ext" % (lilo, device))
 708     proc = subprocess.Popen([lilo, "-S", "/dev/null", "-M", device, "ext"])
 709     proc.wait()
 710     if proc.returncode != 0:
 711         raise Exception("error executing lilo")
 712
 713     # activate partition:
 714     logging.debug("%s -S /dev/null -A %s 1" % (lilo, device))
 715     proc = subprocess.Popen([lilo, "-S", "/dev/null", "-A", device, "1"])
 716     proc.wait()
 717     if proc.returncode != 0:
 718         raise Exception("error executing lilo")
 719
 720
 721 def install_syslinux_mbr(device):
 722     """install syslinux's master boot record (MBR) on the specified device
 723
 724     @device: device where MBR of syslinux should be installed to"""
 725
 726     # make sure we have syslinux available
 727     if not which("syslinux") and not options.copyonly:
 728         raise Exception("syslinux not available (either install it or consider dropping the --syslinux option)")
 729
 730     # lilo's mbr is broken, use the one from syslinux instead:
 731     if not os.path.isfile("/usr/lib/syslinux/mbr.bin"):
 732         raise Exception("/usr/lib/syslinux/mbr.bin can not be read")
 733
 734     logging.info("Installing syslinux MBR")
 735     logging.debug("cat /usr/lib/syslinux/mbr.bin > %s" % device)
 736     try:
 737         # TODO -> use Popen instead?
 738         retcode = subprocess.call("cat /usr/lib/syslinux/mbr.bin > "+ device, shell=True)
 739         if retcode < 0:
 740             logging.critical("Error copying MBR to device (%s)" % retcode)
 741     except OSError, error:
 742         logging.critical("Execution failed:", error)
 743
 744
 745 def install_mir_mbr(mbrtemplate, device, partition, ismirbsdmbr=True):
 746     """install 'mbr' master boot record (MBR) on a device
 747
 748     Retrieve the partition table from "device", install an MBR from the
 749     "mbrtemplate" file, set the "partition" (0..3) active, and install the
 750     result back to "device".
 751
 752     @mbrtemplate: default MBR file
 753
 754     @device: name of a file assumed to be a hard disc (or USB stick) image, or
 755     something like "/dev/sdb"
 756
 757     @partition: must be a number between 0 and 3, inclusive
 758
 759     @mbrtemplate: must be a valid MBR file of at least 440 (or 439 if
 760     ismirbsdmbr) bytes.
 761
 762     @ismirbsdmbr: if true then ignore the active flag, set the mirbsdmbr
 763     specific flag to 0/1/2/3 and set the MBR's default value accordingly. If
 764     false then leave the mirbsdmbr specific flag set to FFh, set all
 765     active flags to 0 and set the active flag of the partition to 80h.  Note:
 766     behaviour of mirbsdmbr: if flag = 0/1/2/3 then use it, otherwise search for
 767     the active flag."""
 768
 769     logging.info("Installing default MBR")
 770
 771     if not os.path.isfile(mbrtemplate):
 772         logging.critical("Error: %s can not be read." % mbrtemplate)
 773         raise CriticalException("Error installing MBR (either try --syslinux-mbr or install missing file?)")
 774
 775     if (partition < 0) or (partition > 3):
 776         raise ValueError("partition must be between 0 and 3")
 777
 778     if ismirbsdmbr:
 779         nmbrbytes = 439
 780     else:
 781         nmbrbytes = 440
 782
 783     tmpf = tempfile.NamedTemporaryFile()
 784
 785     logging.debug("executing: dd if='%s' of='%s' bs=512 count=1" % (device, tmpf.name))
 786     proc = subprocess.Popen(["dd", "if=%s" % device, "of=%s" % tmpf.name, "bs=512", "count=1"], stderr=file(os.devnull, "r+"))
 787     proc.wait()
 788     if proc.returncode != 0:
 789         raise Exception("error executing dd (first run)")
 790
 791     logging.debug("executing: dd if=%s of=%s bs=%s count=1 conv=notrunc" % (mbrtemplate,
 792         tmpf.name, nmbrbytes))
 793     proc = subprocess.Popen(["dd", "if=%s" % mbrtemplate, "of=%s" % tmpf.name, "bs=%s" % nmbrbytes,
 794         "count=1", "conv=notrunc"], stderr=file(os.devnull, "r+"))
 795     proc.wait()
 796     if proc.returncode != 0:
 797         raise Exception("error executing dd (second run)")
 798
 799     mbrcode = tmpf.file.read(512)
 800     if len(mbrcode) < 512:
 801         raise EOFError("MBR size (%d) < 512" % len(mbrcode))
 802
 803     if ismirbsdmbr:
 804         mbrcode = mbrcode[0:439] + chr(partition) + \
 805           mbrcode[440:510] + "\x55\xAA"
 806     else:
 807         actives = ["\x00", "\x00", "\x00", "\x00"]
 808         actives[partition] = "\x80"
 809         mbrcode = mbrcode[0:446] + actives[0] + \
 810           mbrcode[447:462] + actives[1] + \
 811           mbrcode[463:478] + actives[2] + \
 812           mbrcode[479:494] + actives[3] + \
 813           mbrcode[495:510] + "\x55\xAA"
 814
 815     tmpf.file.seek(0)
 816     tmpf.file.truncate()
 817     tmpf.file.write(mbrcode)
 818     tmpf.file.close()
 819
 820     logging.debug("executing: dd if='%s' of='%s' bs=512 count=1 conv=notrunc" % (tmpf.name, device))
 821     proc = subprocess.Popen(["dd", "if=%s" % tmpf.name, "of=%s" % device, "bs=512", "count=1",
 822                             "conv=notrunc"], stderr=file(os.devnull, "r+"))
 823     proc.wait()
 824     if proc.returncode != 0:
 825         raise Exception("error executing dd (third run)")
 826     del tmpf
 827
 828
 829 def handle_syslinux_mbr(device):
 830     """Install syslinux master boot record on given device
 831
 832     @device: device where MBR should be installed to"""
 833
 834     if not is_writeable(device):
 835         raise IOError("device not writeable for user")
 836
 837     # try to use system's lilo
 838     if which("lilo"):
 839         lilo = which("lilo")
 840     else:
 841         # otherwise fall back to our static version
 842         from platform import architecture
 843         if architecture()[0] == '64bit':
 844             lilo = GRML2USB_BASE + '/lilo/lilo.static.amd64'
 845         else:
 846             lilo = GRML2USB_BASE + '/lilo/lilo.static.i386'
 847     # finally prefer a specified lilo executable
 848     if options.lilobin:
 849         lilo = options.lilobin
 850
 851     if not is_exe(lilo):
 852         raise Exception("lilo executable can not be execute")
 853
 854     if options.dryrun:
 855         logging.info("Would install MBR running lilo and using syslinux.")
 856         return 0
 857
 858     execute_lilo(lilo, device)
 859     install_syslinux_mbr(device)
 860
 861
 862 def is_writeable(device):
 863     """Check if the device is writeable for the current user
 864
 865     @device: partition where bootloader should be installed to"""
 866
 867     if not device:
 868         return False
 869         #raise Exception("no device for checking write permissions")
 870
 871     if not os.path.exists(device):
 872         return False
 873
 874     return os.access(device, os.W_OK) and os.access(device, os.R_OK)
 875
 876
 877 def mount(source, target, mount_options):
 878     """Mount specified source on given target
 879
 880     @source: name of device/ISO that should be mounted
 881     @target: directory where the ISO should be mounted to
 882     @options: mount specific options"""
 883
 884     # note: options.dryrun does not work here, as we have to
 885     # locate files and identify the grml flavour
 886
 887     for x in file('/proc/mounts').readlines():
 888         if x.startswith(source):
 889             raise CriticalException("Error executing mount: %s already mounted - please unmount before invoking grml2usb" % source)
 890
 891     if os.path.isdir(source):
 892         logging.debug("Source %s is not a device, therefore not mounting." % source)
 893         return 0
 894
 895     logging.debug("mount %s %s %s" % (mount_options, source, target))
 896     proc = subprocess.Popen(["mount"] + list(mount_options) + [source, target])
 897     proc.wait()
 898     if proc.returncode != 0:
 899         raise CriticalException("Error executing mount (no filesystem on the partition?)")
 900     else:
 901         logging.debug("register_mountpoint(%s)" % target)
 902         register_mountpoint(target)
 903
 904
 905 def unmount(target, unmount_options):
 906     """Unmount specified target
 907
 908     @target: target where something is mounted on and which should be unmounted
 909     @options: options for umount command"""
 910
 911     # make sure we unmount only already mounted targets
 912     target_unmount = False
 913     mounts = open('/proc/mounts').readlines()
 914     mountstring = re.compile(".*%s.*" % re.escape(os.path.realpath(target)))
 915     for line in mounts:
 916         if re.match(mountstring, line):
 917             target_unmount = True
 918
 919     if not target_unmount:
 920         logging.debug("%s not mounted anymore" % target)
 921     else:
 922         logging.debug("umount %s %s" % (list(unmount_options), target))
 923         proc = subprocess.Popen(["umount"] + list(unmount_options) + [target])
 924         proc.wait()
 925         if proc.returncode != 0:
 926             raise Exception("Error executing umount")
 927         else:
 928             logging.debug("unregister_mountpoint(%s)" % target)
 929             unregister_mountpoint(target)
 930
 931
 932 def check_for_usbdevice(device):
 933     """Check whether the specified device is a removable USB device
 934
 935     @device: device name, like /dev/sda1 or /dev/sda
 936     """
 937
 938     usbdevice = re.match(r'/dev/(.*?)\d*$', device).group(1)
 939     # newer systems:
 940     usbdev = os.path.realpath('/sys/class/block/' + usbdevice + '/removable')
 941     if not os.path.isfile(usbdev):
 942         # Ubuntu with kernel 2.6.24 for example:
 943         usbdev = os.path.realpath('/sys/block/' + usbdevice + '/removable')
 944
 945     if os.path.isfile(usbdev):
 946         is_usb = open(usbdev).readline()
 947         if is_usb.find("1"):
 948             return 0
 949
 950     return 1
 951
 952
 953 def check_for_fat(partition):
 954     """Check whether specified partition is a valid VFAT/FAT16 filesystem
 955
 956     @partition: device name of partition"""
 957
 958     try:
 959         udev_info = subprocess.Popen(["/sbin/blkid", "-s", "TYPE", "-o", "value", partition],
 960                     stdout=subprocess.PIPE, stderr=subprocess.PIPE)
 961         filesystem = udev_info.communicate()[0].rstrip()
 962
 963         if udev_info.returncode == 2:
 964             raise CriticalException("Failed to read device %s"
 965                                     " (wrong UID/permissions or device/directory not present?)" % partition)
 966
 967         if options.syslinux and filesystem != "vfat":
 968             raise CriticalException("Partition %s does not contain a FAT16 filesystem. (Use --fat16 or run mkfs.vfat %s)" % (partition, partition))
 969
 970     except OSError:
 971         raise CriticalException("Sorry, /sbin/blkid not available (install e2fsprogs?)")
 972
 973
 974 def mkdir(directory):
 975     """Simple wrapper around os.makedirs to get shell mkdir -p behaviour"""
 976
 977     # just silently pass as it's just fine it the directory exists
 978     if not os.path.isdir(directory):
 979         try:
 980             os.makedirs(directory)
 981         # pylint: disable-msg=W0704
 982         except OSError:
 983             pass
 984
 985
 986 def copy_system_files(grml_flavour, iso_mount, target):
 987     """copy grml's main files (like squashfs, kernel and initrd) to a given target
 988
 989     @grml_flavour: name of grml flavour the configuration should be generated for
 990     @iso_mount: path where a grml ISO is mounted on
 991     @target: path where grml's main files should be copied to"""
 992
 993     squashfs = search_file(grml_flavour + '.squashfs', iso_mount)
 994     if squashfs is None:
 995         logging.critical("Fatal: squashfs file not found")
 996         raise CriticalException("error locating squashfs file")
 997     else:
 998         squashfs_target = target + '/live/' + grml_flavour + '/'
 999         execute(mkdir, squashfs_target)
1000         logging.debug("rsync -rlptDH --inplace %s %s" % (squashfs, squashfs_target + grml_flavour + '.squashfs'))
1001         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", squashfs, squashfs_target + grml_flavour + ".squashfs"])
1002         proc.wait()
1003
1004     filesystem_module = search_file('filesystem.module', iso_mount)
1005     if filesystem_module is None:
1006         logging.critical("Fatal: filesystem.module not found")
1007     else:
1008         logging.debug("rsync -rlptDH --inplace %s %s" % (filesystem_module, squashfs_target + 'filesystem.module'))
1009         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", filesystem_module, squashfs_target + 'filesystem.module'])
1010         proc.wait()
1011
1012     release_target = target + '/boot/release/' + grml_flavour
1013     execute(mkdir, release_target)
1014
1015     kernel = search_file('linux26', iso_mount)
1016     if kernel is None:
1017         logging.critical("Fatal kernel not found")
1018     else:
1019         logging.debug("rsync -rlptDH --inplace %s %s" % (kernel, release_target + '/linux26'))
1020         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", kernel, release_target + '/linux26'])
1021         proc.wait()
1022
1023     initrd = search_file('initrd.gz', iso_mount)
1024     if initrd is None:
1025         logging.critical("Fatal: initrd not found")
1026     else:
1027         logging.debug("rsync -rlptDH --inplace %s %s" % (initrd, release_target + '/initrd.gz'))
1028         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", initrd, release_target + '/initrd.gz'])
1029         proc.wait()
1030
1031
1032 def copy_grml_files(iso_mount, target):
1033     """copy some minor grml files to a given target
1034
1035     @iso_mount: path where a grml ISO is mounted on
1036     @target: path where grml's main files should be copied to"""
1037
1038     grml_target = target + '/grml/'
1039     execute(mkdir, grml_target)
1040
1041     for myfile in 'grml-cheatcodes.txt', 'grml-version', 'LICENSE.txt', 'md5sums', 'README.txt':
1042         grml_file = search_file(myfile, iso_mount)
1043         if grml_file is None:
1044             logging.warn("Warning: myfile %s could not be found - can not install it", myfile)
1045         else:
1046             logging.debug("rsync -rlptDH --inplace %s %s" % (grml_file, grml_target + grml_file))
1047             proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", grml_file, grml_target + myfile])
1048             proc.wait()
1049
1050     grml_web_target = grml_target + '/web/'
1051     execute(mkdir, grml_web_target)
1052
1053     for myfile in 'index.html', 'style.css':
1054         grml_file = search_file(myfile, iso_mount)
1055         if grml_file is None:
1056             logging.warn("Warning: myfile %s could not be found - can not install it")
1057         else:
1058             logging.debug("rsync -rlptDH --inplace %s %s" % (grml_file, grml_web_target + grml_file))
1059             proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", grml_file, grml_web_target + myfile])
1060             proc.wait()
1061
1062     grml_webimg_target = grml_web_target + '/images/'
1063     execute(mkdir, grml_webimg_target)
1064
1065     for myfile in 'button.png', 'favicon.png', 'linux.jpg', 'logo.png':
1066         grml_file = search_file(myfile, iso_mount)
1067         if grml_file is None:
1068             logging.warn("Warning: myfile %s could not be found - can not install it")
1069         else:
1070             logging.debug("rsync -rlptDH --inplace %s %s" % (grml_file, grml_webimg_target + grml_file))
1071             proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", grml_file, grml_webimg_target + myfile])
1072             proc.wait()
1073
1074
1075 def copy_addons(iso_mount, target):
1076     """copy grml's addons files (like allinoneimg, bsd4grml,..) to a given target
1077
1078     @iso_mount: path where a grml ISO is mounted on
1079     @target: path where grml's main files should be copied to"""
1080
1081     addons = target + '/boot/addons/'
1082     execute(mkdir, addons)
1083
1084     # grub all-in-one image
1085     allinoneimg = search_file('allinone.img', iso_mount)
1086     if allinoneimg is None:
1087         logging.warn("Warning: allinone.img not found (that's fine if you don't need it)")
1088     else:
1089         logging.debug("rsync -rlptDH --inplace %s %s" % (allinoneimg, addons + '/allinone.img'))
1090         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", allinoneimg, addons + 'allinone.img'])
1091         proc.wait()
1092
1093     # bsd imag
1094     bsdimg = search_file('bsd4grml', iso_mount)
1095     if bsdimg is None:
1096         logging.warn("Warning: bsd4grml not found (that's fine if you don't need it)")
1097     else:
1098         logging.debug("rsync -rlptDH --inplace %s %s" % (bsdimg, addons + '/'))
1099         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", bsdimg, addons + '/'])
1100         proc.wait()
1101
1102     # freedos image
1103     balderimg = search_file('balder10.imz', iso_mount)
1104     if balderimg is None:
1105         logging.warn("Warning: balder10.imz not found (that's fine if you don't need it)")
1106     else:
1107         logging.debug("rsync -rlptDH --inplace %s %s" % (balderimg, addons + '/balder10.imz'))
1108         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", balderimg, addons + 'balder10.imz'])
1109         proc.wait()
1110
1111     # install hdt and pci.ids only when using syslinux (grub doesn't support it)
1112     if options.syslinux:
1113         # hdt (hardware detection tool) image
1114         hdtimg = search_file('hdt.c32', iso_mount)
1115         if hdtimg:
1116             logging.debug("rsync -rlptDH --inplace %s %s" % (hdtimg, addons + '/hdt.c32'))
1117             proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", hdtimg, addons + '/hdt.c32'])
1118             proc.wait()
1119
1120         # pci.ids file
1121         picids = search_file('pci.ids', iso_mount)
1122         if picids:
1123             logging.debug("rsync -rlptDH --inplace %s %s" % (picids, addons + '/pci.ids'))
1124             proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", picids, addons + '/pci.ids'])
1125             proc.wait()
1126
1127     # memdisk image
1128     memdiskimg = search_file('memdisk', iso_mount)
1129     if memdiskimg is None:
1130         logging.warn("Warning: memdisk not found (that's fine if you don't need it)")
1131     else:
1132         logging.debug("rsync -rlptDH --inplace %s %s" % (memdiskimg, addons + '/memdisk'))
1133         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", memdiskimg, addons + 'memdisk'])
1134         proc.wait()
1135
1136     # memtest86+ image
1137     memtestimg = search_file('memtest', iso_mount)
1138     if memtestimg is None:
1139         logging.warn("Warning: memtest not found (that's fine if you don't need it)")
1140     else:
1141         logging.debug("rsync -rlptDH --inplace %s %s" % (memtestimg, addons + '/memtest'))
1142         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", memtestimg, addons + 'memtest'])
1143         proc.wait()
1144
1145
1146 def copy_bootloader_files(iso_mount, target):
1147     """copy grml's bootloader files to a given target
1148
1149     @iso_mount: path where a grml ISO is mounted on
1150     @target: path where grml's main files should be copied to"""
1151
1152     syslinux_target = target + '/boot/syslinux/'
1153     execute(mkdir, syslinux_target)
1154
1155     logo = search_file('logo.16', iso_mount)
1156     logging.debug("rsync -rlptDH --inplace %s %s" % (logo, syslinux_target + 'logo.16'))
1157     proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", logo, syslinux_target + 'logo.16'])
1158     proc.wait()
1159
1160     for ffile in 'f2', 'f3', 'f4', 'f5', 'f6', 'f7', 'f8', 'f9', 'f10':
1161         bootsplash = search_file(ffile, iso_mount)
1162         logging.debug("rsync -rlptDH --inplace %s %s" % (bootsplash, syslinux_target + ffile))
1163         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", bootsplash, syslinux_target + ffile])
1164         proc.wait()
1165
1166     grub_target = target + '/boot/grub/'
1167     execute(mkdir, grub_target)
1168
1169     if not os.path.isfile(GRML2USB_BASE + "/grub/splash.xpm.gz"):
1170         logging.critical("Error: %s/grub/splash.xpm.gz can not be read." % (GRML2USB_BASE, ))
1171         logging.critical("Please make sure you've the grml2usb Debian package installed!")
1172         raise
1173     else:
1174         logging.debug("rsync -rlptDH --inplace %s/grub/splash.xpm.gz %s%s" % (GRML2USB_BASE, grub_target, 'splash.xpm.gz'))
1175         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", GRML2USB_BASE + '/grub/splash.xpm.gz',
1176                                 grub_target + 'splash.xpm.gz'])
1177         proc.wait()
1178
1179     # grml splash in grub
1180     if os.path.isfile(GRML2USB_BASE + "/grub/grml.png"):
1181         logging.debug("rsync -rlptDH --inplace %s/grub/grml.png to %s%s" % (GRML2USB_BASE, grub_target, 'grml.png'))
1182         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", GRML2USB_BASE + '/grub/grml.png',
1183                                 grub_target + 'grml.png'])
1184         proc.wait()
1185
1186     # font file for graphical bootsplash in grub
1187     if os.path.isfile("/usr/share/grub/ascii.pf2"):
1188         logging.debug("rsync -rlptDH --inplace /usr/share/grub/ascii.pf2 to %s" % grub_target + 'ascii.pf2')
1189         proc = subprocess.Popen(["rsync", "-rlptDH", "--inplace", '/usr/share/grub/ascii.pf2',
1190                                 grub_target + 'ascii.pf2'])
1191         proc.wait()
1192
1193
1194 def install_iso_files(grml_flavour, iso_mount, device, target):
1195     """Copy files from ISO to given target
1196
1197     @grml_flavour: name of grml flavour the configuration should be generated for
1198     @iso_mount: path where a grml ISO is mounted on
1199     @device: device/partition where bootloader should be installed to
1200     @target: path where grml's main files should be copied to"""
1201
1202     # TODO => several improvements:
1203     # * make sure grml_flavour, iso_mount, target are set when the function is called, otherwise raise exception
1204     # * provide alternative search_file() if file information is stored in a config.ini file?
1205     # * catch "install: .. No space left on device" & CO
1206
1207     if options.dryrun:
1208         return 0
1209     elif not options.bootloaderonly:
1210         logging.info("Copying files. This might take a while....")
1211         try:
1212             copy_system_files(grml_flavour, iso_mount, target)
1213             copy_grml_files(iso_mount, target)
1214         except CriticalException, error:
1215             logging.critical("Execution failed: %s", error)
1216             sys.exit(1)
1217
1218     if not options.skipaddons:
1219         if grml_flavour.endswith('-small'):
1220             logging.info("Note: grml-small doesn't provide any addons, not installing them therefore.")
1221         else:
1222             copy_addons(iso_mount, target)
1223
1224     if not options.copyonly:
1225         copy_bootloader_files(iso_mount, target)
1226
1227         if not options.dryrun:
1228             handle_bootloader_config(grml_flavour, device, target)
1229
1230     # make sure we sync filesystems before returning
1231     proc = subprocess.Popen(["sync"])
1232     proc.wait()
1233
1234
1235 def uninstall_files(device):
1236     """Get rid of all grml files on specified device
1237
1238     @device: partition where grml2usb files should be removed from"""
1239
1240     # TODO - not implemented yet
1241     logging.critical("TODO: uninstalling files from %s not yet implement, sorry." % device)
1242
1243
1244 def identify_grml_flavour(mountpath):
1245     """Get name of grml flavour
1246
1247     @mountpath: path where the grml ISO is mounted to
1248     @return: name of grml-flavour"""
1249
1250     version_file = search_file('grml-version', mountpath)
1251
1252     if version_file == "":
1253         logging.critical("Error: could not find grml-version file.")
1254         raise
1255
1256     try:
1257         tmpfile = open(version_file, 'r')
1258         grml_info = tmpfile.readline()
1259         grml_flavour = re.match(r'[\w-]*', grml_info).group()
1260     except TypeError:
1261         raise
1262     except:
1263         logging.critical("Unexpected error:", sys.exc_info()[0])
1264         raise
1265
1266     return grml_flavour
1267
1268
1269 def handle_grub1_config(grml_flavour, install_partition, grub_target, bootopt):
1270     """Main handler for generating grub1 configuration
1271
1272     @grml_flavour: name of grml flavour the configuration should be generated for
1273     @install_partition: partition number for use in (hd0,X)
1274     @grub_target: path of grub's configuration files
1275     @bootoptions: additional bootoptions that should be used by default"""
1276
1277     # grub1 config
1278     grub1_cfg = grub_target + 'menu.lst'
1279     logging.debug("Creating grub1 configuration file (menu.lst)")
1280
1281     # install main configuration only *once*, no matter how many ISOs we have:
1282     if os.path.isfile(grub1_cfg):
1283         string = open(grub1_cfg).readline()
1284         main_identifier = re.compile(".*main config generated at: %s.*" % re.escape(str(DATESTAMP)))
1285         if not re.match(main_identifier, string):
1286             grub1_config_file = open(grub1_cfg, 'w')
1287             grub1_config_file.write(generate_main_grub1_config(grml_flavour, install_partition, bootopt))
1288             grub1_config_file.close()
1289     else:
1290         grub1_config_file = open(grub1_cfg, 'w')
1291         grub1_config_file.write(generate_main_grub1_config(grml_flavour, install_partition, bootopt))
1292         grub1_config_file.close()
1293
1294     grub_flavour_config = True
1295     if os.path.isfile(grub1_cfg):
1296         string = open(grub1_cfg).readlines()
1297         flavour = re.compile("grml2usb for %s: %s" % (re.escape(grml_flavour), re.escape(str(DATESTAMP))))
1298         for line in string:
1299             if flavour.match(line):
1300                 grub_flavour_config = False
1301
1302     if grub_flavour_config:
1303         grub1_config_file = open(grub1_cfg, 'a')
1304         grub1_config_file.write(generate_flavour_specific_grub1_config(grml_flavour, install_partition, bootopt))
1305         grub1_config_file.close()
1306
1307
1308 def handle_grub2_config(grml_flavour, grub_target, bootopt):
1309     """Main handler for generating grub2 configuration
1310
1311     @grml_flavour: name of grml flavour the configuration should be generated for
1312     @grub_target: path of grub's configuration files
1313     @bootoptions: additional bootoptions that should be used by default"""
1314
1315     # grub2 config
1316     grub2_cfg = grub_target + 'grub.cfg'
1317     logging.debug("Creating grub2 configuration file (grub.lst)")
1318
1319     global GRML_DEFAULT
1320
1321     # install main configuration only *once*, no matter how many ISOs we have:
1322     grub_flavour_is_default = False
1323     if os.path.isfile(grub2_cfg):
1324         string = open(grub2_cfg).readline()
1325         main_identifier = re.compile(".*main config generated at: %s.*" % re.escape(str(DATESTAMP)))
1326         if not re.match(main_identifier, string):
1327             grub2_config_file = open(grub2_cfg, 'w')
1328             GRML_DEFAULT = grml_flavour
1329             grub_flavour_is_default = True
1330             grub2_config_file.write(generate_main_grub2_config(grml_flavour, bootopt))
1331             grub2_config_file.close()
1332     else:
1333         grub2_config_file = open(grub2_cfg, 'w')
1334         GRML_DEFAULT = grml_flavour
1335         grub_flavour_is_default = True
1336         grub2_config_file.write(generate_main_grub2_config(grml_flavour, bootopt))
1337         grub2_config_file.close()
1338
1339     # install flavour specific configuration only *once* as well
1340     grub_flavour_config = True
1341     if os.path.isfile(grub2_cfg):
1342         string = open(grub2_cfg).readlines()
1343         flavour = re.compile("grml2usb for %s: %s" % (re.escape(grml_flavour), re.escape(str(DATESTAMP))))
1344         for line in string:
1345             if flavour.match(line):
1346                 grub_flavour_config = False
1347
1348     if grub_flavour_config:
1349         grub2_config_file = open(grub2_cfg, 'a')
1350         # display only if the grml flavour isn't the default
1351         if not grub_flavour_is_default:
1352             GRML_FLAVOURS.add(grml_flavour)
1353         grub2_config_file.write(generate_flavour_specific_grub2_config(grml_flavour, bootopt))
1354         grub2_config_file.close()
1355
1356
1357 def handle_grub_config(grml_flavour, device, target):
1358     """Main handler for generating grub (v1 and v2) configuration
1359
1360     @grml_flavour: name of grml flavour the configuration should be generated for
1361     @device: device/partition where grub should be installed to
1362     @target: path of grub's configuration files"""
1363
1364     logging.debug("Generating grub configuration")
1365
1366     grub_target = target + '/boot/grub/'
1367     execute(mkdir, grub_target)
1368
1369     if os.path.isdir(device):
1370         install_grub1_partition = None
1371     else:
1372         if device[-1:].isdigit():
1373             install_grub1_partition = int(device[-1:]) - 1
1374         else:
1375             raise CriticalException("error validating partition schema (raw device?)")
1376
1377     # do NOT write "None" in kernel cmdline
1378     if options.bootoptions is None:
1379         bootopt = ""
1380     else:
1381         bootopt = options.bootoptions
1382
1383     # write menu.lst
1384     handle_grub1_config(grml_flavour, install_grub1_partition, grub_target, bootopt)
1385     # write grub.cfg
1386     handle_grub2_config(grml_flavour, grub_target, bootopt)
1387
1388
1389 def handle_syslinux_config(grml_flavour, target):
1390     """Main handler for generating syslinux configuration
1391
1392     @grml_flavour: name of grml flavour the configuration should be generated for
1393     @target: path of syslinux's configuration files"""
1394
1395     # do NOT write "None" in kernel cmdline
1396     if options.bootoptions is None:
1397         bootopt = ""
1398     else:
1399         bootopt = options.bootoptions
1400
1401     logging.debug("Generating syslinux configuration")
1402     syslinux_target = target + '/boot/syslinux/'
1403     # should be present via  copy_bootloader_files(), but make sure it exits:
1404     execute(mkdir, syslinux_target)
1405     syslinux_cfg = syslinux_target + 'syslinux.cfg'
1406
1407     global GRML_DEFAULT
1408
1409     # install main configuration only *once*, no matter how many ISOs we have:
1410     syslinux_flavour_is_default = False
1411     if os.path.isfile(syslinux_cfg):
1412         string = open(syslinux_cfg).readline()
1413         main_identifier = re.compile(".*main config generated at: %s.*" % re.escape(str(DATESTAMP)))
1414         if not re.match(main_identifier, string):
1415             syslinux_config_file = open(syslinux_cfg, 'w')
1416             GRML_DEFAULT = grml_flavour
1417             syslinux_flavour_is_default = True
1418             syslinux_config_file.write(generate_main_syslinux_config(grml_flavour, bootopt))
1419             syslinux_config_file.close()
1420     else:
1421         syslinux_config_file = open(syslinux_cfg, 'w')
1422         GRML_DEFAULT = grml_flavour
1423         syslinux_flavour_is_default = True
1424         syslinux_config_file.write(generate_main_syslinux_config(grml_flavour, bootopt))
1425         syslinux_config_file.close()
1426
1427     # install flavour specific configuration only *once* as well
1428     syslinux_flavour_config = True
1429     if os.path.isfile(syslinux_cfg):
1430         string = open(syslinux_cfg).readlines()
1431         flavour = re.compile("grml2usb for %s: %s" % (re.escape(grml_flavour), re.escape(str(DATESTAMP))))
1432         for line in string:
1433             if flavour.match(line):
1434                 syslinux_flavour_config = False
1435
1436     if syslinux_flavour_config:
1437         syslinux_config_file = open(syslinux_cfg, 'a')
1438         # display only if the grml flavour isn't the default
1439         if not syslinux_flavour_is_default:
1440             GRML_FLAVOURS.add(grml_flavour)
1441         syslinux_config_file.write(generate_flavour_specific_syslinux_config(grml_flavour, bootopt))
1442         syslinux_config_file.close()
1443
1444     logging.debug("Generating isolinux/syslinux splash %s" % syslinux_target + 'boot.msg')
1445     isolinux_splash = open(syslinux_target + 'boot.msg', 'w')
1446     isolinux_splash.write(generate_isolinux_splash(grml_flavour))
1447     isolinux_splash.close()
1448
1449
1450 def handle_bootloader_config(grml_flavour, device, target):
1451     """Main handler for generating bootloader's configuration
1452
1453     @grml_flavour: name of grml flavour the configuration should be generated for
1454     @device: device/partition where bootloader should be installed to
1455     @target: path of bootloader's configuration files"""
1456
1457     if options.skipsyslinuxconfig:
1458         logging.info("Skipping generation of syslinux configuration as requested.")
1459     else:
1460         try:
1461             handle_syslinux_config(grml_flavour, target)
1462         except CriticalException, error:
1463             logging.critical("Fatal: %s" % error)
1464             sys.exit(1)
1465
1466     if options.skipgrubconfig:
1467         logging.info("Skipping generation of grub configuration as requested.")
1468     else:
1469         try:
1470             handle_grub_config(grml_flavour, device, target)
1471         except CriticalException, error:
1472             logging.critical("Fatal: %s" % error)
1473             sys.exit(1)
1474
1475 def handle_dir(live_image, device):
1476     """Main logic for copying files of the currently running grml system.
1477
1478     @live_image: directory where currently running live system resides (usually /live/image)
1479     @device: partition where the specified ISO should be installed to"""
1480
1481     logging.info("Using %s as install base" % live_image)
1482
1483     if os.path.isdir(device):
1484         logging.info("Specified target is a directory, therefore not mounting.")
1485         device_mountpoint = device
1486         remove_device_mountpoint = False
1487     else:
1488         device_mountpoint = tempfile.mkdtemp(prefix="grml2usb")
1489         register_tmpfile(device_mountpoint)
1490         remove_device_mountpoint = True
1491         try:
1492             mount(device, device_mountpoint, "")
1493         except CriticalException, error:
1494             logging.critical("Fatal: %s" % error)
1495             cleanup()
1496             sys.exit(1)
1497
1498     try:
1499         try:
1500             grml_flavour = identify_grml_flavour(live_image)
1501             logging.info("Identified grml flavour \"%s\"." % grml_flavour)
1502             install_iso_files(grml_flavour, live_image, device, device_mountpoint)
1503         except TypeError:
1504             logging.critical("Fatal: a critical error happend during execution (not a grml ISO?), giving up")
1505             sys.exit(1)
1506     finally:
1507         if remove_device_mountpoint:
1508             try:
1509                 unmount(device_mountpoint, "")
1510                 if os.path.isdir(device_mountpoint):
1511                     os.rmdir(device_mountpoint)
1512                     unregister_tmpfile(device_mountpoint)
1513             except CriticalException, error:
1514                 logging.critical("Fatal: %s" % error)
1515                 cleanup()
1516
1517
1518 def handle_iso(iso, device):
1519     """Main logic for mounting ISOs and copying files.
1520
1521     @iso: full path to the ISO that should be installed to the specified device
1522     @device: partition where the specified ISO should be installed to"""
1523
1524     logging.info("Using ISO %s" % iso)
1525
1526     iso_mountpoint = tempfile.mkdtemp(prefix="grml2usb")
1527     register_tmpfile(iso_mountpoint)
1528     remove_iso_mountpoint = True
1529
1530     if not os.path.isfile(iso):
1531         logging.critical("Fatal: specified ISO %s could not be read" % iso)
1532         cleanup()
1533         sys.exit(1)
1534
1535     try:
1536         mount(iso, iso_mountpoint, ["-o", "loop", "-t", "iso9660"])
1537     except CriticalException, error:
1538         logging.critical("Fatal: %s" % error)
1539         sys.exit(1)
1540
1541     if os.path.isdir(device):
1542         logging.info("Specified target is a directory, therefore not mounting.")
1543         device_mountpoint = device
1544         remove_device_mountpoint = False
1545         # skip_mbr = True
1546     else:
1547         device_mountpoint = tempfile.mkdtemp(prefix="grml2usb")
1548         register_tmpfile(device_mountpoint)
1549         remove_device_mountpoint = True
1550         try:
1551             mount(device, device_mountpoint, "")
1552         except CriticalException, error:
1553             logging.critical("Fatal: %s" % error)
1554             cleanup()
1555             sys.exit(1)
1556
1557     try:
1558         try:
1559             grml_flavour = identify_grml_flavour(iso_mountpoint)
1560             logging.info("Identified grml flavour \"%s\"." % grml_flavour)
1561             install_iso_files(grml_flavour, iso_mountpoint, device, device_mountpoint)
1562         except TypeError:
1563             logging.critical("Fatal: a critical error happend during execution (not a grml ISO?), giving up")
1564             sys.exit(1)
1565     finally:
1566         if os.path.isdir(iso_mountpoint) and remove_iso_mountpoint:
1567             unmount(iso_mountpoint, "")
1568             os.rmdir(iso_mountpoint)
1569             unregister_tmpfile(iso_mountpoint)
1570         if remove_device_mountpoint:
1571             try:
1572                 unmount(device_mountpoint, "")
1573                 if os.path.isdir(device_mountpoint):
1574                     os.rmdir(device_mountpoint)
1575                     unregister_tmpfile(device_mountpoint)
1576             except CriticalException, error:
1577                 logging.critical("Fatal: %s" % error)
1578                 cleanup()
1579
1580
1581 def handle_mbr(device):
1582     """Main handler for installing master boot record (MBR)
1583
1584     @device: device where the MBR should be installed to"""
1585
1586     if options.dryrun:
1587         logging.info("Would install MBR")
1588         return 0
1589
1590     if device[-1:].isdigit():
1591         mbr_device = re.match(r'(.*?)\d*$', device).group(1)
1592         partition_number = int(device[-1:]) - 1
1593         skip_install_mir_mbr = False
1594
1595     # if we get e.g. /dev/loop1 as device we don't want to put the MBR
1596     # into /dev/loop of course, therefore use /dev/loop1 as mbr_device
1597     if mbr_device == "/dev/loop":
1598         mbr_device = device
1599         logging.info("Detected loop device - using %s as MBR device therefore" % mbr_device)
1600         skip_install_mir_mbr = True
1601
1602     try:
1603         if options.syslinuxmbr:
1604             handle_syslinux_mbr(mbr_device)
1605         elif not skip_install_mir_mbr:
1606             if options.mbrmenu:
1607                 install_mir_mbr(GRML2USB_BASE + '/mbr/mbrmgr', mbr_device, partition_number, True)
1608             else:
1609                 install_mir_mbr(GRML2USB_BASE + '/mbr/mbrldr', mbr_device, partition_number, False)
1610     except IOError, error:
1611         logging.critical("Execution failed: %s", error)
1612         sys.exit(1)
1613     except Exception, error:
1614         logging.critical("Execution failed: %s", error)
1615         sys.exit(1)
1616
1617
1618 def handle_vfat(device):
1619     """Check for FAT specific settings and options
1620
1621     @device: device that should checked / formated"""
1622
1623     # make sure we have mkfs.vfat available
1624     if options.fat16 and not options.force:
1625         if not which("mkfs.vfat") and not options.copyonly and not options.dryrun:
1626             logging.critical('Sorry, mkfs.vfat not available. Exiting.')
1627             logging.critical('Please make sure to install dosfstools.')
1628             sys.exit(1)
1629
1630         # make sure the user is aware of what he is doing
1631         f = raw_input("Are you sure you want to format the specified partition with fat16? y/N ")
1632         if f == "y" or f == "Y":
1633             logging.info("Note: you can skip this question using the option --force")
1634             try:
1635                 mkfs_fat16(device)
1636             except CriticalException, error:
1637                 logging.critical("Execution failed: %s", error)
1638                 sys.exit(1)
1639         else:
1640             sys.exit(1)
1641
1642     # check for vfat filesystem
1643     if device is not None and not os.path.isdir(device):
1644         try:
1645             check_for_fat(device)
1646         except CriticalException, error:
1647             logging.critical("Execution failed: %s", error)
1648             sys.exit(1)
1649
1650     if not os.path.isdir(device) and not check_for_usbdevice(device):
1651         print "Warning: the specified device %s does not look like a removable usb device." % device
1652         f = raw_input("Do you really want to continue? y/N ")
1653         if f == "y" or f == "Y":
1654             pass
1655         else:
1656             sys.exit(1)
1657
1658
1659 def handle_compat_warning(device):
1660     """Backwards compatible checks
1661
1662     @device: device that should be checked"""
1663
1664     # make sure we can replace old grml2usb script and warn user when using old way of life:
1665     if device.startswith("/mnt/external") or device.startswith("/mnt/usb") and not options.force:
1666         print "Warning: the semantics of grml2usb has changed."
1667         print "Instead of using grml2usb /path/to/iso %s you might" % device
1668         print "want to use grml2usb /path/to/iso /dev/... instead."
1669         print "Please check out the grml2usb manpage for details."
1670         f = raw_input("Do you really want to continue? y/N ")
1671         if f == "y" or f == "Y":
1672             pass
1673         else:
1674             sys.exit(1)
1675
1676
1677 def handle_logging():
1678     """Log handling and configuration"""
1679
1680     if options.verbose and options.quiet:
1681         parser.error("please use either verbose (--verbose) or quiet (--quiet) option")
1682
1683     if options.verbose:
1684         FORMAT = "Debug: %(asctime)-15s %(message)s"
1685         logging.basicConfig(level=logging.DEBUG, format=FORMAT)
1686     elif options.quiet:
1687         FORMAT = "Critical: %(message)s"
1688         logging.basicConfig(level=logging.CRITICAL, format=FORMAT)
1689     else:
1690         FORMAT = "%(message)s"
1691         logging.basicConfig(level=logging.INFO, format=FORMAT)
1692
1693
1694 def handle_bootloader(device):
1695     """wrapper for installing bootloader
1696
1697     @device: device where bootloader should be installed to"""
1698
1699     # Install bootloader only if not using the --copy-only option
1700     if options.copyonly:
1701         logging.info("Not installing bootloader and its files as requested via option copyonly.")
1702     elif os.path.isdir(device):
1703         logging.info("Not installing bootloader as %s is a directory." % device)
1704     else:
1705         install_bootloader(device)
1706
1707
1708 def main():
1709     """Main function [make pylint happy :)]"""
1710
1711     if options.version:
1712         print os.path.basename(sys.argv[0]) + " " + PROG_VERSION
1713         sys.exit(0)
1714
1715     if len(args) < 2:
1716         parser.error("invalid usage")
1717
1718     # log handling
1719     handle_logging()
1720
1721     # make sure we have the appropriate permissions
1722     check_uid_root()
1723
1724     logging.info("Executing grml2usb version %s", PROG_VERSION)
1725
1726     if options.dryrun:
1727         logging.info("Running in simulation mode as requested via option dry-run.")
1728
1729     # specified arguments
1730     device = args[len(args) - 1]
1731     isos = args[0:len(args) - 1]
1732
1733     if not os.path.isdir(device):
1734         if device[-1:].isdigit():
1735             if int(device[-1:]) > 4 or device[-2:].isdigit():
1736                 logging.critical("Fatal: installation on partition number >4 not supported. (BIOS won't support it.)")
1737                 sys.exit(1)
1738         else:
1739             if os.path.exists(device):
1740                 logging.critical("Fatal: installation on raw device not supported. (BIOS won't support it.)")
1741                 sys.exit(1)
1742
1743     if not which("rsync"):
1744         logging.critical("Fatal: rsync not available, can not continue - sorry.")
1745         sys.exit(1)
1746
1747     # provide upgrade path
1748     handle_compat_warning(device)
1749
1750     # check for vfat partition
1751     handle_vfat(device)
1752
1753     # main operation (like installing files)
1754     for iso in isos:
1755         if os.path.isdir(iso):
1756             handle_dir(iso, device)
1757         else:
1758             handle_iso(iso, device)
1759
1760     # install mbr
1761     if not os.path.isdir(device):
1762         if not options.skipmbr:
1763             handle_mbr(device)
1764
1765     handle_bootloader(device)
1766
1767     logging.info("Note: grml flavour %s was installed as the default booting system." % GRML_DEFAULT)
1768
1769     for flavour in GRML_FLAVOURS:
1770         logging.info("Note: you can boot flavour %s using '%s' on the commandline." % (flavour, flavour))
1771
1772     # finally be politely :)
1773     logging.info("Finished execution of grml2usb (%s). Have fun with your grml system." % PROG_VERSION)
1774
1775
1776 if __name__ == "__main__":
1777     try:
1778         main()
1779     except KeyboardInterrupt:
1780         logging.info("Received KeyboardInterrupt")
1781         cleanup()
1782
1783 ## END OF FILE #################################################################
1784 # vim:foldmethod=indent expandtab ai ft=python tw=120 fileencoding=utf-8