Promoted branch to tag

Had to add xorriso-tcltk to EXTRA_DIST although it is in bin_SCRIPTS
Documented changes and release timestamp
2013-03-19 10:21:49 +00:00 · 2013-03-18 10:39:24 +00:00 · 2013-03-18 10:03:57 +00:00 · 2013-03-18 10:02:07 +00:00 · 2013-03-18 09:51:29 +00:00 · 2013-03-18 09:02:10 +00:00
121 changed files with 89751 additions and 38819 deletions
--- a/8
+++ b/8
@ -1,12 +1,8 @@
 Mario Danic <mario.danic@gmail.com>,
 Vreixo Formoso <metalpain2002@yahoo.es> 
 Thomas Schmitt <scdbackup@gmx.net>
-libisoburn is Copyright (C) 2007-2010 Vreixo Formoso, Thomas Schmitt
-xorriso is Copyright (C) 2007-2010 Thomas Schmitt
-libisofs (if included) is Copyright (C) 2007-2010 Vreixo Formoso, Mario Danic
-libburn (if included) is Copyright (C) 2002-2006 Derek Foreman, Ben Jansens
-                     and Copyright (C) 2006-2010 Mario Danic, Thomas Schmitt
-
+libisoburn is Copyright (C) 2007-2011 Vreixo Formoso, Thomas Schmitt
+xorriso is Copyright (C) 2007-2011 Thomas Schmitt

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 2
--- a/594
+++ b/594
@ -0,0 +1,594 @@
+SVN trunk (to become libisoburn-1.2.8.tar.gz or higher)
+===============================================================================
+* Bug fix: -tell_media_space altered the pointers to MD5 of data files
+           which stem from a previous session. This produced false
+           mismatches with -check_md5_r.
+* Bug fix: CD tracks were reported with the sizes of the tracks in the 
+           first session.
+* Bug fix: -check_media use=outdev sector_map= stored TOC of input drive
+* Bug fix: -hide hfsplus and -as mkisofs -hide-hfsplus had no effect.
+           Thanks to Davy Ho.
+* Bug fix: ./configure did not abort if libburn.h or libisofs.h were missing
+* New command -move
+* New -as mkisofs options -eltorito-id , -eltorito-selcrit
+
+
+libisoburn-1.2.6.tar.gz  Tue Jan 08 2013
+===============================================================================
+* Bug fix: SIGSEGV by uninitialized local variable with
+           -check_media patch_lba0="on". Regression by version 1.0.6
+* Bug fix: -partition_offset 16 kept -isohybrid-gpt-basdat from writing
+           MBR partition table entries of type 0xef
+* Bug fix: -rollback did not work if indev and outdev were empty
+* New API calls Xorriso_parse_line() and Xorriso__dispose_words()
+* New API calls Xorriso_fetch_outlists() and Xorriso_peek_outlists()
+* New API call Xorriso_start_msg_watcher()
+* New API calls Xorriso__severity_cmp() and Xorriso__severity_list()
+* New API calls Xorriso_sieve_add_filter, Xorriso_sieve_get_result,
+  Xorriso_sieve_clear_results, Xorriso_sieve_dispose, Xorriso_sieve_big
+* New -boot_image partition_cyl_align mode "all"
+* New -blank mode prefix "force:"
+* New -osirrox settings "blocked" and "unblock"
+* New command -lns for creating symbolic links
+* New command -toc_of
+* New command -msg_op
+* New command -launch_frontend
+* Proof-of-concept of a GUI frontend program: xorriso-tcltk written in Tcl/Tk.
+
+libisoburn-1.2.4.tar.gz  Fri Jul 20 2012
+===============================================================================
+* New API call isoburn_igopt_set_hfsp_serial_number()
+* New API calls isoburn_igopt_set_prep_partition, isoburn_igopt_set_efi_bootp
+* New API calls isoburn_igopt_set_hfsp_block_size() and isoburn_igopt_get_hfsp_block_size()
+* New -check_media option async_chunks=
+* New xorriso command -write_type
+* New xorriso command -rockridge
+* New xorriso command -hfsplus
+* New -find tests -has_hfs_crtp, has_hfs_bless
+* New -find actions set/get_hfs_crtp,  set/get_hfs_bless
+* New -find test -disk_path
+* New -boot_image bootspec hfsplus_serial=
+* New -boot_image bootspecs hfsplus_block_size= and apm_block_size=
+* New -boot_image bootspecs efi_boot_part, prep_boot_part, chrp_boot_part
+* Command -hide allows hiding in HFS+ filesystem
+* New -as cdrecord options -tao -sao -dao
+* New -as mkisofs option -log-file
+* New -as mkisofs option --norock
+* New -as mkisofs option -hfsplus
+* New -as mkisofs option -hfsplus-file-creator-type
+* New -as mkisofs options -hfs-bless and -hfs-bless-by
+* New -as mkisofs option -hfsplus-serial-no
+* New -as mkisofs options -hfsplus-block-size and -apm-block-size
+* New -as mkisofs option -hide-hfsplus, -hide-hfsplus-list
+* New -as mkisofs options -prep-boot-part, -efi-boot-part, -chrp-boot-part
+* New -as mkisofs options -isohybrid-gpt-basdat, -isohybrid-gpt-hfsplus, -isohybrid-apm-hfsplus
+* Bug fix: Memory corruption when reading bootable image that was truncated
+* Bug fix: -update deleted MD5 of files of which only attributes had changed
+
+libisoburn-1.2.2.tar.gz  Mon Apr 02 2012
+===============================================================================
+* New API calls isoburn_get_attached_start_lba(), isoburn_attach_start_lba()
+* New API calls isoburn_igopt_set_rr_reloc(), isoburn_igopt_get_rr_reloc()
+* New API calls isoburn_ropt_set_data_cache(), isoburn_ropt_get_data_cache()
+* New commands -x, -list_arg_sorting
+* New command -rr_reloc_dir
+* New command -data_cache_size
+* New -as mkisofs option -rr_reloc, implemented option -hide-rr-moved
+* Now ignoring -as mkisofs -no-split-symlink-components -no-split-symlink-fields
+* Bug fix: -osirrox on:sort_lba_on -extract from / restored nearly nothing
+* Bug fix: -as mkisofs without -graft-points could not handle names with "="
+* Bug fix: Relaxation options joliet_rec_mtime and iso1999_rec_mtime had wrong values
+
+
+libisoburn-1.2.0.tar.gz  Sat Jan 28 2012
+===============================================================================
+* Bug fix: mkisofs emulation did not record mtime in ECMA-119 directories
+* Bug fix: Program abort while drive tray is loading led to endless loop
+* Bug fix: Solaris adapter mishandled write commands which failed on first try
+* Bug fix: libisoburn.ver had a duplicate function entry
+* New relaxations isoburn_igopt_joliet_rec_mtime,
+  isoburn_igopt_iso1999_rec_mtime
+* Made -compliance "rec_mtime" default for xorriso
+
+libisoburn-1.1.8.tar.gz  Mon Nov 21 2011
+===============================================================================
+* Info document and man page for xorrecord
+* New option -sleep
+* Enabled recognition of QEMU DVD-ROM 0.12
+* Enabled out-of the box use of xorriso on Linux guest on qemu virtio-blk-pci
+
+libisoburn-1.1.6.tar.gz  Tue Sep 27 2011
+===============================================================================
+* Bug fix: -extract_single extracted directory content
+* Bug fix: -extract was not immediately aborted if -abort_on was triggered
+* Bug fix: xorriso did not write to files in filesystems with >= 4 TB free space
+* Bug fix: libisofs: ACL entries of groups and of user id 0 were not properly
+           recorded and cannot be restored
+* Bug fix: libisofs: No ACLs were recorded on FreeBSD
+* Enabled recording and restoring of extattr on FreeBSD.
+* New option -list_extras
+* New -osirrox option strict_acl
+* New -find and -findx action list_extattr
+* Workaround for collision with Linux udev which lets device links vanish
+
+libisoburn-1.1.4.tar.gz  Mon Aug 8 2011
+===============================================================================
+* Bug fix: xorriso native mode on some drives wrote unreadble ISO images to CD
+* Bug fix: -assert_volid did not work. Regression since version 1.1.0.
+* Bug fix: -acl or -xattr worked with -extract only on Linux and FreeBSD
+* New option -device_links
+
+libisoburn-1.1.2.tar.gz  Fri Jul 8 2011
+===============================================================================
+* Bug fix: Since 1.0.6: Unreadable image produced by: xorrisofs ... >image.iso
+* Bug fix: -update_r scheduled non-existing files for hardlink update
+* Enabled extraction of the boot catalog file to disk filesystem
+* New option -list_speeds
+
+GNU xorriso-1.1.0.pl01.tar.gz  Mon Jun 20 2011
+===============================================================================
+* Bug fix: Due to a bug in libburn-1.1.0, GNU xorriso-1.1.0 compiled only
+           on GNU/Linux, FreeBSD, and Solaris, but not on other systems.
+
+libisoburn-1.1.0.tar.gz  Sat Jun 18 2011
+===============================================================================
+* Bug fix: -mount_opts shared worked only with -osirrox o_excl_off
+* Bug fix: xorriso command -add_plainly "any" did not add all files to the image
+* Bug fix: The attempt to blank already blank DVD-RW was not gracefully blocked
+* Bug fix: -as mkisofs -isohybrid-mbr without -no-pad was not cylinder aligned
+* New option -signal_handling
+* New option -close_damaged
+* Dropped suffix .plXY from tarball name
+
+libisoburn-1.0.8.pl00.tar.gz  Thu Apr 14 2011
+===============================================================================
+* Bug fix: mkisofs emulation could ignore options (regression in 0.1.6)
+
+libisoburn-1.0.6.pl00.tar.gz  Sat Apr 9 2011
+===============================================================================
+* Bug fix: -as mkisofs padding did not work (regression in 1.0.4)
+* Bug fix: Options -gid and -uid had no effect
+* New API call isoburn_set_truncate()
+* New relax option isoburn_igopt_joliet_long_names
+* New option -early_stdio_test
+* New options -print_info and -print_mark
+* New -compliance option joliet_long_names
+* -as mkisofs option -joliet-long is now fully functional
+* Burning DVD-R DAO with 2 kB size granularity rather than 32 kB
+
+libisoburn-1.0.4.pl00.tar.gz  Thu Mar 10 2011
+===============================================================================
+libisoburn novelties:
+* New isoburn_ropt_set_extensions() option isoburn_ropt_nomd5tag
+xorriso novelties:
+* Bug fix: xorrisofs did not work under growisofs -M (version 1.0.0 was ok)
+* Bug fix: -as mkisofs -C attempted to read volume header of blank media
+* Bug fix: -as mkisofs -old-root did not work with -graft-points
+* Bug fix: -as mkisofs -partition_hd_cyl had no effect
+* Bug fix: -as mkisofs did not properly unescape target part of pathspecs
+* Bug fix: isohybrid image size was not aligned to cylinder boundary
+* Bug fix: Compilation without zlib failed
+* New -padding modes "included" and "appended"
+* New bootspec partition_cyl_align=, new -as mkisofs option -partition_cyl_align
+* New -as mkisofs and -as cdrecord option --no_rc
+* Own man page and info document for xorrisofs
+
+libisoburn-1.0.2.pl00.tar.gz  Mon Feb 23 2011
+===============================================================================
+libisoburn novelties:
+* Removed compiler obstacles of GNU xorriso on Solaris 9
+* New isoburn_igopt_set_extensions() option isoburn_igopt_old_empty
+xorriso novelties:
+* Bug fix: Images produced with -for_backup might be unreadable and
+           also fail -check_md5 verification.
+* Bug fix: mkisofs emulation options -l , -full-iso9660-filenames did not work.
+* Bug fix: Option -mkdir yielded SIGSEGV due to a NULL pointer
+* Bug fix: ECMA-119 standards violation with Volume Descriptor Set Terminator
+* New options -clone and -cp_clone
+* New -find actions update_merge, rm_merge, clear_merge
+* New -as mkisofs option -max-iso9660-filenames
+* New -as mkisofs option --old-empty
+* New -as mkisofs options -root , -old-root
+* New -as mkisofs options --old-root-no-md5, --old-root-no-ino, --old-root-dev
+
+libisoburn-1.0.0.pl00.tar.gz  Mon Jan 17 2011
+===============================================================================
+libisoburn novelties:
+* New API call isoburn_igopt_set_untranslated_name_len()
+xorriso novelties:
+* Bug fix: -as mkisofs -print-size did not account for -partition_offset
+* Default -abort_on value is now "FAILURE" with batch and "NEVER" with dialog
+* New -compliance options untranslated_names , untranslated_name_len=
+* New -as mkisofs option -untranslated_name_len
+* New -compliance option iso_9660_1999, -as mkisofs option -iso-level 4
+* New -compliance option iso_9660_level=number
+* New -compliance option allow_dir_id_ext, -as mkisofs -disallow_dir_id_ext
+* Disabled TOC emulation with -as mkisofs. May be re-enabled by --emul-toc.
+
+libisoburn-0.6.6.pl00.tar.gz  Sun Dec 12 2010
+===============================================================================
+libisoburn novelties:
+* New API calls isoburn_igopt_set_disc_label(), isoburn_igopt_get_disc_label()
+* New API calls isoburn_ropt_set_displacement(), isoburn_ropt_get_displacement()
+xorriso novelties:
+* Bug fix: -as mkisofs -print-size printed the size but also produced ISO image
+* Build problem fix on Linux 2.4 in GNU xorriso libjte/checksum.c
+* New -as mkisofs option -joliet-long
+* New bootspec sparc_label=, new -as mkisofs options -sparc-boot , -sparc-label
+* New option -displacement
+
+libisoburn-0.6.4.pl00.tar.gz Tue Oct 26 2010
+===============================================================================
+libisoburn novelties:
+* New API call isoburn_libjte_req()
+* New API calls isoburn_igopt_attach_jte() and isoburn_igopt_detach_jte()
+* New API call isoburn_igopt_set_tail_blocks()
+* New API call isoburn_libjte_req()
+xorriso novelties:
+* New option -jigdo
+* New -as mkisofs options -jigdo-* and -md5-list as of genisoimage
+* New -as mkisofs options -checksum_algorithm_iso, -checksum_algorithm_template
+* New bootspecs mips_path= and mipsel_path= for Debian MIPS releases
+* New -as mkisofs options -mips-boot and -mipsel-boot
+* New option -append_partition, -as mkisofs -append_partition
+
+libisoburn-0.6.2.pl00.tar.gz Sat Sep 18 2010
+===============================================================================
+libisoburn novelties:
+* New API function isoburn_igopt_set_part_offset()
+* Hiding all non-API symbols from the linker by use of --version-script
+* Now with history of release notes in ./ChangeLog file.
+xorriso novelties:
+* Bug fix: Regression with -hardlinks and -compliance old_rr, 0.4.2, Aug 2009
+* New option -preparer_id, -as mkisofs options -p and -preparer
+* New -boot_image specifier emul_type=none|hard_disk|floppy
+* New boot_image boot specs partition_offset,partition_hd_cyl,partition_sec_hd
+* Made behavior of -as mkisofs with unknown options more similar to original
+* New -as mkisofs option -hard-disk-boot, enabled -b without -no-emul-boot
+* New -as mkisofs option -e from Fedora genisoimage
+* New -as mkisofs options -partition_offset,-partition_hd_cyl,-partition_sec_hd
+
+libisoburn-0.6.0.pl00.tar.gz Fri Jul 02 2010
+===============================================================================
+libisoburn novelties:
+xorriso novelties:
+* New option -read_mkisofsrc interprets .mkisofsrc To be performed before -as 
+  mkisofs. Performed automatically with program alias name "xorrisofs".
+* Implemented -as mkisofs options -dir-mode, -file-mode, -abstract, -biblio, 
+  -copyright
+* Implemented -as mkisofs options -hide, -hide-joliet, -hide-list,
+  -hide-joliet-list
+* New -as mkisofs option --boot-catalog-hide
+* New option -hide, -find action -hide, -find test -hidden
+* New -boot_image bootspec cat_hidden=on
+* New options -copyright_file , -biblio_file , -abstract_file
+* New find test -disk_name
+* Enabled use of libreadline on Solaris
+* Bug fix: -check_media patch_lba0= could install wrong image size
+* Bug fix: -as mkisofs option -volset was wrongly interpreted like -volid
+
+libisoburn-0.5.8.pl00.tar.gz Mon Jun 14 2010
+===============================================================================
+libisoburn novelties:
+* xorriso source split into more modules, object code moved into libisoburn
+xorriso novelties:
+* New write extension option isoburn_igopt_no_emul_toc
+* New -compliance rule no_emul_toc, new -as mkisofs --no-emul-toc
+* Implemented -as cdrecord -V
+* Implemented -as mkisofs options -U, -N, -l, -d, -allow-lowercase
+
+libisoburn-0.5.6.pl00.tar.gz Tue May 04 2010
+===============================================================================
+libisoburn novelties:
+xorriso novelties:
+* Allowing up to 32 boot images
+* New -boot_image bootspecs
+  efi_path=, platform_id=, sel_crit=, id_string=, next
+* New -as mkisofs options --efi-boot, -eltorito-alt-boot
+
+libisoburn-0.5.4.pl00.tar.gz Mon Apr 19 2010
+===============================================================================
+libisoburn novelties:
+* New API call isoburn_igopt_set_system_area()
+* New API call isoburn_igopt_set_pvd_times()
+* New isoburn_igopt_set_relaxed() options: only_iso_versions, no_j_force_dots
+  xorriso novelties:
+* New -boot_image any system_area=, -as mkisofs option -G
+* New -boot_image grub partition_table=on, -as mkisofs --protective-msdos-label
+* New -boot_image isolinux partition_table=on, -as mkisofs -isohybrid-mbr
+* New option -volume_date, -as mkisofs --modification-date=
+* New -find action mkisofs_r,-as mkisofs -r
+* New -find action sort_weight, -as mkisofs --sort-weight
+* New -compliance options only_iso_version, no_j_force_dots avoid 
+  a bug in GRUB 1.96. They are default now.
+
+libisoburn-0.5.2.pl00.tar.gz Tue Mar 30 2010
+===============================================================================
+xorriso novelties:
+* xorriso documentation is now based on a hybrid format of Texinfo and man-
+  page. Copies included: .texi, .info, .1 (man page)
+
+libisoburn-0.5.0.pl00.tar.gz Tue Feb 22 2010
+===============================================================================
+xorriso novelties:
+* The former xorriso-standalone project is now GNU xorriso under GPLv3+. This
+  affects some documentation and the generator script, but not the license of
+  libisoburn or its program xorriso.
+* Bug fix: xorriso -update_r could lead to SIGSEGV if applied to a data file
+  rather than a directory.
+* Bug fix on FreeBSD: xorriso could leave the drive tray locked.
+* New option -scsi_log
+
+libisoburn-0.4.8.pl00.tar.gz Tue Jan 26 2010
+===============================================================================
+xorriso novelties:
+* Bug fix: xorriso did not blank CD-RW with images that were prepared 
+  on hard disk.
+* New configure option --enable-libcdio for system adapter to libcdio-0.83git
+
+libisoburn-0.4.6.pl00.tar.gz Wed Dec 09 2009
+===============================================================================
+xorriso novelties:
+* New options -dvd_obs and -stdio_sync
+* New configure option --enable-dvd-obs-64k
+
+libisoburn-0.4.4.pl00.tar.gz Wed Oct 28 2009
+===============================================================================
+xorriso novelties:
+* Bug fix: With -as cdrecord : -xa1 and -xamix were ignored although they do
+  matter.
+* Option -toc now reports the individual media type. E.g. with a DVD+RW:
+     "Media product: RICOHJPN/W11/49 , Ricoh Company Limited"
+* New option -pvd_info displays image id strings. New options -system_id , -
+  volset_id allow to set such image id strings.
+* New option -mount_opts tries to circumvent an eventual ban to mount the same
+  device twice. Some Linux systems allow to mount two sessions of the same
+  media only if they get fooled via the loop device.
+* New option -scdbackup_tag performs the task of the scdbackup MD5 checksum
+  filter inside xorriso.
+Already fixed by patch releases of xorriso-0.4.2:
+* Bug fix: -cut_out deleted previously cut-out pieces of the same file
+* Bug fix libisofs: Filenames could lose blanks during a multi-session cycle
+* Bug fix: -for_backup did not enable -xattr and -md5 if no drive was chosen
+  yet
+* Bug fix: xorrisofs -help, xorrecord -help displayed original xorriso -help
+
+libisoburn-0.4.2.pl02.tar.gz Thu Oct 08 2009
+===============================================================================
+* Bug fix: -for_backup did not enable -xattr and -md5 if no drive was chosen
+  yet
+* Bug fix: xorrisofs -help, xorrecord -help displayed original xorriso -help
+
+Libisoburn 0.4.2.pl01
+===============================================================================
+* Bug fix: xorriso option -cut_out deleted previously cut-out pieces of the
+  same file. The bug was introduced with release 0.1.4 in March 2008.
+
+Libisoburn 0.4.2
+===============================================================================
+* New write options isoburn_igopt_session_md5, isoburn_igopt_file_md5,
+  isoburn_igopt_file_stability allow to record MD5 checksums of session and
+  single data files.
+* New read option isoburn_ropt_nomd5 allows to read those MD5 sums when
+  importing an ISO image.
+xorriso novelties:
+* New option -md5, new -as mkisofs option --md5 allow to record in the image
+  MD5 checksums for the whole session and for each single data file.
+* New options -check_md5, -check_md5_r allow to verify the whole session or
+  single files by comparing their image data with their MD5 sums.
+* Options -compare, -compare_r, -update, update_r now can use recorded MD5.
+* New -find actions check_md5, get_md5, make_md5 allow to check, to display or
+  to recompute MD5 checksums of data files. New find test -has_md5 
+  distinguishes data files which have recorded MD5 from files which have none.
+* New -find test -has_any_xattr and action get_any_xattr allow to inspect the
+  libisofs specific attributes of namespace "isofs".
+* Options -lsl and lsdl now display correct link counts if -hardlinks is on.
+* New option -calm_drive allows to reduce drive noise if no data reading is
+  intended for a while.
+* New option -list_profiles allows to inquire and process the list of supported
+  media types.
+* Bug fix: xorriso -as mkisofs did not understand the -C option of growisofs
+  any more. (Already fixed by release 0.4.0.pl01, 20 Jul 2009)
+
+libisoburn-0.4.0.pl01.tar.gz Mon Jul 20 2009
+===============================================================================
+xorriso novelties:
+* New option -hardlinks enables recording and restoring of hard link relations.
+* Improved reading performance with -update_r and -extract.
+* New option -for_backup as shortcut for -acl -xattr -hardlinks
+* Operators with option -find : -not, -or, -and, (, ), -if, -then, -else
+* New -find tests -wholename, -prune
+* Bug fix: SIGSEGV with option -status and no search string
+* Bug fix: -load volid did not perform pattern search
+* Bug fix: Copies of overwriteable media on sequential were mistaken in ROM
+  drives
+Libisoburn 0.4.0.pl01 release notes:
+* Bug fix: xorriso -as mkisofs did not understand the -C option of growisofs
+  any more
+
+libisoburn-0.3.8.pl00.tar.gz Sun Apr 19 2009
+===============================================================================
+libisoburn novelties:
+* New API calls isoburn_ropt_set_auto_incharset() and
+  isoburn_ropt_get_auto_incharset()
+xorriso novelties:
+* New options -set_filter, -set_filter_r, -find -exec set_filter allow to
+  manipulate the content of data files on the fly.
+* New option -zisofs, built-in filters --zisofs , --gzip , --gunzip enable
+  compression and decompression of data file content.
+* New options -external_filter , -unregister_filter, -close_filter_list allow
+  arbitrary external processes to do content filtering.
+* New options -show_stream, -show_stream_r allow to inspect the origin and the
+  filters of data files in an emerging image.
+* New option -auto_charset based on xattr "isofs.cs" allows to tag an ISO
+  filesystem image with the character set name that is in use on the current
+  terminal.
+
+libisoburn-0.3.6.pl00.tar.gz Mon Mar 16 2009
+===============================================================================
+xorriso novelties:
+* Dummy MMC adapter of libburn allows compilation on systems other than Linux,
+  FreeBSD
+* Default of -compliance has been changed to "old_rr", new rule "new_rr"
+* New -stream_recording modes with start address or "data". "on" is now 32s.
+
+libisoburn-0.3.4.pl00.tar.gz Sun Mar 01 2009
+===============================================================================
+* New isoburn_read_opts values: isoburn_ropt_noaaip, isoburn_ropt_noacl,
+  isoburn_ropt_noea
+xorriso novelties:
+* New option -acl enables ACL import and export
+* New options -getfacl, -getfacl_r, -setfacl, -setfacl_r, -setfacl_list
+* New find tests -has_acl, -has_no_acl , new find actions getfacl, setfacl
+* New option -xattr enables import and export of Extended Attributes
+* New options -getfattr, -getfattr_r, -setfattr, -setfattr_r, -setfattr_list
+* New find tests -has_xattr, -has_aaip, new find actions getfattr, setfattr
+* New -as mkisofs options --acl and --xattr
+* New option -disk_dev_ino accelerates incremental backups
+
+libisoburn-0.3.2.pl00.tar.gz Tue Jan 06 2009
+===============================================================================
+* New API function isoburn_get_mount_params()
+* Now depending on libburn-0.6.0 which supports BD-R media
+xorriso novelties:
+* Bug fix: Options -extract and -extract_single were enabled with -osirrox off
+* New options -mount , -mount_cmd , -session_string
+* New -format modes by_size_ and fast_by_size_
+* New option -assert_volid
+* New option -drive_class for safety management of pseudo-drive access
+
+libisoburn-0.3.0.pl00.tar.gz Tue Dec 2 2008
+===============================================================================
+* Now depending on libisofs-0.6.12 and libburn-0.5.6 to ensure use of their
+  recent bug fixes
+xorriso novelties:
+* New options -quoted_path_list, -quoted_not_list
+* New option -backslash_codes for weird file names and terminal safety
+* New options -charset, -in_charset, -out_charset
+* New option -local_charset allows to override locale
+* New option -application_id
+* New option -compliance allows certain deviations from standards
+* Suitable ISOLINUX boot images are made alternatively bootable via an MBR
+* Bug fix: Forgot exit value registration to -return_with. 
+  Thanks to Steve Dodd.
+* Bug fix: -format as_needed did not recognize unformatted BD-RE
+* Bug fix: disk patterns with relative addresses were not properly resolved
+
+libisoburn-0.2.8.pl00.tar.gz Wed Oct 15 2008
+===============================================================================
+* Now depending on libisofs-0.6.10 and libburn-0.5.4 to ensure use of their
+  recent bug fixes
+xorriso novelties:
+* Ability to write and maintain bootable ISO images based on ISOLINUX
+* New ./configure option --disable-libreadline to make binary more portable
+* Bug fix: -as mkisofs -iso-level was accused to be an unknown option
+* Bug fix: -follow link attributed random target filenames to looping links
+
+libisoburn-0.2.6.pl00.tar.gz Sat Sep 20 2008
+===============================================================================
+xorriso novelties:
+* Capability to insert and extract files far larger than 4 GB
+* New option -file_size_limit, -as mkisofs now supports -iso-level 1 to 3
+* New option -extract_cut
+* New -error_behavior "file_extraction" behavior "best_effort"
+* New option -check_media_defaults
+* New option -list_delimiter
+* Bug fix: -format full did not re-format already formatted DVD+RW
+
+libisoburn-0.2.4.pl00.tar.gz Mo Aug 25 2008
+===============================================================================
+xorriso novelties:
+* New option -check_media
+* New -find test -damaged, new -find actions "report_damage", "report_lba"
+* New -error_behavior occasion "file_extraction"
+
+libisoburn-0.2.2.pl01.tar.gz Fr Jul 25 2008
+===============================================================================
+Libisoburn 0.2.2 release notes (Jul 19 2008)
+* New API function isoburn_prepare_blind_grow()
+* New flag bits with isoburn_set_msc1(), isoburn_read_iso_head()
+xorriso novelties:
+* New option -grow_blindly
+* Options -C and -M for -as mkisofs emulation
+* Options for -as cdrecord emulation: -multi, -msinfo, -isosize, tsize, --
+  grow_overwriteable_iso, write_start_address,
+* New option -pacifier, more compatible pacifier with -as mkisofs
+* make install creates aliases as symbolic links: osirrox, xorrisofs, xorrecord
+* Can serve growisofs if started as xorrisofs, genisofs, mkisofs, genisoimage
+pl01 changes (Jul 25 2008):
+* Bug fix: Variable DESTDIR was not properly respected during make install
+
+libisoburn-0.2.0.pl00.tar.gz Mon Jun 23 2008
+===============================================================================
+Libisoburn 0.2.0 release notes:
+* New API functions isoburn_set_msgs_submit(), isoburn_drive_set_msgs_submit()
+xorriso novelties:
+* Bug fix: -chmod unintentionally performed o-x as first operation
+* New options -cpax, -cp_rx, -cp_rax, -extract to restore files and trees from
+  ISO image to disk filesystem.
+* New option -paste_in to copy ISO files into parts of disk files
+* New options -map_l, -compare_l, -update_l, -extract_l
+
+libisoburn-0.1.8.pl00.tar.gz Tue Jun 3 2008
+===============================================================================
+* Bug fix: Major,minor numbers of device files appeared as 0,1 in next session
+* Bug fix: modifying to overwriteable target yielded unmountable results
+xorriso novelties:
+* New option -stream_recording for full speed with DVD-RAM and BD-RE
+* New options -osirrox and -cpx allow to extract single files from ISO image
+
+libisoburn-0.1.6.pl00.tar.gz Mon May 19 2008
+===============================================================================
+* Support for BD-RE (by depending on libburn-0.4.8)
+* New API wrapper calls isoburn_toc_*() around libburn TOC inquiry calls
+* New API call isoburn_read_iso_head() identifies ISO 9660 filesystems
+* New API call isoburn_set_msc1() (like mount -o sbsector=)
+xorriso novelties:
+* Bug fix: -update_r and others did not work properly with relative paths
+* New options -map and -map_single
+* New options -not_paths, -not_leaf, -not_list, -not_mgt, -as mkisofs -m
+* Emulated -toc on overwriteable media, new -toc layout with volume id
+* New option -load makes alternative sessions accessible
+* New -blank and -format modes 'as_needed'
+* New option -list_formats and -format mode 'by_index_'
+
+libisoburn-0.1.4.pl00.tar.gz Wed Apr 30 2008
+===============================================================================
+* Improved performance with reading directory trees
+* xorriso: Improved attribute transfer from disk for target
+* xorriso: Incremental backup functionality by new option -update_r
+* xorriso: Options -cut_out and split_size map byte intervals of oversized
+  files into ISO files
+* xorriso: Emulation of some basic mkisofs and cdrecord options
+* Dynamically linkable with release version 0.6.4 of libisofs
+
+Version 0.1.2 was not released as libisoburn 
+but only as xorriso standalone version. Wed Mar 12 2008
+===============================================================================
+* Bug fix: -report_about HINT or higher did not report at all
+* Bug fix: speed=number without unit or media type letter was always CD speed
+* Bug fix: it was possible to write to appendable media which was not -indev
+* Bug fix: -follow param did not work for adding non-directory symbolic links
+* Bug fix: It was not possible to -add /THIS=a /b=THIS
+* Improved attribute transfer from disk for implicit target directories
+* New option -as "cdrecord" emulates a narrow set of cdrecord gestures
+* New option -as "mkisofs" emulates a narrow set of mkisofs gestures
+* New option -publisher
+* New option -errfile_log
+* Support for DVD+R/DL media
+* New options -compare, -compare_r and according -find -exec action
+* New options -update, -update_r and according -find -exec action
+* New -find actions "rm", "rm_r", new -findx -type "m" -exec "empty_iso_dir"
+* New option -cut_out
+
+libisoburn-0.1.0.pl01.tar.gz Fri Feb 15 2008
+===============================================================================
+* Initial release of libisoburn/xorriso
+* libisoburn connects libisofs and libburn
+* libisoburn emulates multi-session on media without session history
+* xorriso is an integrated multi-session tool for ISO 9660 Rock Ridge images
+* due to a subtle mistake in ABI usage with libisofs this release had to be
+  restricted to dynamic linking with exactly libisofs-0.6.2 where the mistake
+  does no harm. A version of libisoburn which is open to all future libisofs
+  versions will be released shortly after libisofs.0.6.4.
+
--- a/Makefile.am
+++ b/Makefile.am
@ -6,6 +6,7 @@ pkgconfigdir=$(LIBBURNIA_PKGCONFDIR)
 libincludedir=$(includedir)/libisoburn

 lib_LTLIBRARIES = libisoburn/libisoburn.la 
+ACLOCAL_AMFLAGS = -I ./

 ## ========================================================================= ##

@ -13,20 +14,77 @@ lib_LTLIBRARIES = libisoburn/libisoburn.la
 libisoburn_libisoburn_la_LDFLAGS = \
 	-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
 libisoburn_libisoburn_la_SOURCES = \
+	libisoburn/isoburn.h \
+	libisoburn/libisoburn.h \
 	libisoburn/burn_wrap.c \
 	libisoburn/data_source.c \
 	libisoburn/isoburn.c \
-	libisoburn/isoburn.h \
 	libisoburn/isofs_wrap.c \
-	libisoburn/libisoburn.h \
-	version.h
+\
+	xorriso/xorriso.h \
+	xorriso/xorriso_private.h \
+	xorriso/sfile.h \
+	xorriso/sfile.c \
+	xorriso/aux_objects.h \
+	xorriso/aux_objects.c \
+	xorriso/findjob.h \
+	xorriso/findjob.c \
+	xorriso/check_media.h \
+	xorriso/check_media.c \
+	xorriso/misc_funct.h \
+	xorriso/misc_funct.c \
+	xorriso/text_io.h \
+	xorriso/text_io.c \
+	xorriso/match.h \
+	xorriso/match.c \
+	xorriso/emulators.h \
+	xorriso/emulators.c \
+	xorriso/disk_ops.h \
+	xorriso/disk_ops.c \
+	xorriso/cmp_update.h \
+	xorriso/cmp_update.c \
+	xorriso/parse_exec.h \
+	xorriso/parse_exec.c \
+	xorriso/opts_a_c.c \
+	xorriso/opts_d_h.c \
+	xorriso/opts_i_o.c \
+	xorriso/opts_p_z.c \
+\
+	xorriso/xorrisoburn.h \
+	xorriso/base_obj.h \
+	xorriso/base_obj.c \
+	xorriso/lib_mgt.h \
+	xorriso/lib_mgt.c \
+	xorriso/sort_cmp.h \
+	xorriso/sort_cmp.c \
+	xorriso/drive_mgt.h \
+	xorriso/drive_mgt.c \
+	xorriso/iso_img.h \
+	xorriso/iso_img.c \
+	xorriso/iso_tree.h \
+	xorriso/iso_tree.c \
+	xorriso/iso_manip.h \
+	xorriso/iso_manip.c \
+	xorriso/write_run.h \
+	xorriso/write_run.c \
+	xorriso/read_run.h \
+	xorriso/read_run.c \
+	xorriso/filters.h \
+	xorriso/filters.c \
+	xorriso/xorriso_timestamp.h \
+	xorriso/xorriso_buildstamp.h

 libisoburn_libisoburn_la_LIBADD = \
 	-lisofs \
 	-lburn

 libinclude_HEADERS = \
-	libisoburn/libisoburn.h 
+	libisoburn/libisoburn.h \
+	xorriso/xorriso.h
+
+# libisoburn_libisoburn_la_CFLAGS = $(READLINE_DEF) $(LIBACL_DEF) $(XATTR_DEF) \
+#                         $(EXTF_DEF) $(EXTF_SUID_DEF) $(ZLIB_DEF) \
+#                         $(XORRISO_DVD_OBS_64K)

 ## ========================================================================= ##

@ -50,22 +108,16 @@ bin_PROGRAMS = \
 # 	cat xorriso/xorriso_buildstamp.h

 xorriso_xorriso_CPPFLAGS = -Ilibisoburn
-xorriso_xorriso_CFLAGS = -DXorriso_with_maiN \
-                         $(READLINE_DEF) $(LIBACL_DEF) $(XATTR_DEF) \
-                         $(EXTF_DEF) $(EXTF_SUID_DEF) $(ZLIB_DEF) \
-                         $(XORRISO_DVD_OBS_64K)
+# xorriso_xorriso_CFLAGS = $(READLINE_DEF) $(LIBACL_DEF) $(XATTR_DEF) \
+#                          $(EXTF_DEF) $(EXTF_SUID_DEF) $(ZLIB_DEF) \
+#                          $(XORRISO_DVD_OBS_64K)

 xorriso_xorriso_LDADD = libisoburn/libisoburn.la -lisofs -lburn \
 		$(THREAD_LIBS) $(LIBBURN_ARCH_LIBS)

 xorriso_xorriso_SOURCES = \
 	xorriso/xorriso.h \
-	xorriso/xorriso_private.h \
-	xorriso/xorriso.c \
-	xorriso/xorrisoburn.h \
-	xorriso/xorrisoburn.c \
-	xorriso/xorriso_timestamp.h \
-	xorriso/xorriso_buildstamp.h
+	xorriso/xorriso_main.c


 # Install symbolic links to the xorriso binary
@ -77,6 +129,7 @@ install-exec-hook:
 	ln -s xorriso "$(DESTDIR)$(bindir)"/osirrox
 	if test -e "$(DESTDIR)$(bindir)"/xorrecord ; then rm "$(DESTDIR)$(bindir)"/xorrecord ; else echo ; fi
 	ln -s xorriso "$(DESTDIR)$(bindir)"/xorrecord
+	$(LIBBURNIA_LDCONFIG_CMD) "$(DESTDIR)$(libdir)" || echo 'NOTE: Explicite dynamic library configuration failed. If needed, configure manually for:' "$(DESTDIR)$(libdir)"


 # Alternative to the disabled .PHONY above.
@ -91,6 +144,12 @@ buildstamped: buildstamp
 	make


+# "make clean" shall remove a few stubborn .libs directories
+# which George Danchev reported Dec 03 2011.
+# Learned from: http://www.gnu.org/software/automake/manual/automake.html#Clean
+clean-local:
+	-rm -rf test/.libs
+

 ## Build companion applications
 noinst_PROGRAMS = \
@ -113,6 +172,11 @@ xorriso_make_xorriso_1_CFLAGS =
 xorriso_make_xorriso_1_LDADD =
 xorriso_make_xorriso_1_SOURCES = xorriso/make_xorriso_1.c

+# A Proof-of-concept for frontends
+bin_SCRIPTS = \
+	frontend/xorriso-tcltk
+
+
 ## ========================================================================= ##

 ## Build documentation (You need Doxygen for this to work)
@ -131,7 +195,9 @@ doc/html: doc/doxygen.conf
 doc-upload: doc/html
 	scp -r $</* $(webhost):$(webpath)

-all: doc
+## Not by default any more.
+## It is unclear who is supposed to create file ./doc/doc.lock
+# all: doc

 install-data-local: 
 	if [ -f ./doc/doc.lock ]; then \
@ -164,25 +230,56 @@ indent: $(indent_files)
 nodist_pkgconfig_DATA = \
 	libisoburn-1.pc

-man_MANS = xorriso/xorriso.1
+man_MANS = \
+	xorriso/xorriso.1 \
+	xorriso/xorrisofs.1 \
+	xorriso/xorrecord.1

-info_TEXINFOS = xorriso/xorriso.texi
+info_TEXINFOS = \
+	xorriso/xorriso.texi \
+	xorriso/xorrisofs.texi \
+	xorriso/xorrecord.texi

 EXTRA_DIST = \
+	bootstrap \
 	libisoburn-1.pc.in \
 	version.h.in \
 	doc/comments \
 	doc/doxygen.conf.in \
+	doc/partition_offset.wiki \
+	doc/qemu_xorriso.wiki \
+	doc/startup_file.txt \
+	frontend/frontend_pipes_xorriso.c \
+	frontend/README-tcltk \
+	frontend/xorriso-tcltk \
 	README \
 	AUTHORS \
 	CONTRIBUTORS \
 	COPYRIGHT \
 	COPYING \
 	INSTALL \
+	ChangeLog \
+	libisoburn/libisoburn.ver \
 	xorriso/changelog.txt \
 	xorriso/xorriso_buildstamp_none.h \
 	xorriso/README_gnu_xorriso \
 	xorriso/make_docs.sh \
+	releng/README \
+	releng/auto_cxx \
+	releng/auto_isocontent \
+	releng/auto_printsize \
+	releng/change_shell_to_use \
+	releng/codesamples/api_3lib.cpp \
+	releng/codesamples/api_xorriso.cpp \
+	releng/inc/releng_getopts.inc \
+	releng/jigdo-gen-md5-list \
+	releng/jigdo-gen-md5-list.1 \
+	releng/manual_burn \
+	releng/manual_devices \
+	releng/manual_isojigdo \
+	releng/releng_generated_data \
+	releng/run_all_auto \
+	releng/template_new \
 	$(man_MANS)


--- a/160
+++ b/160
@ -4,8 +4,9 @@
 libisoburn and xorriso. By Vreixo Formoso <metalpain2002@yahoo.es> 
                       and Thomas Schmitt <scdbackup@gmx.net>
 Integrated sub project of libburnia-project.org.
-http://files.libburnia-project.org/releases/libisoburn-0.5.2.pl00.tar.gz
-Copyright (C) 2006-2010 Vreixo Formoso, Thomas Schmitt.
+http://files.libburnia-project.org/releases/libisoburn-1.2.8.tar.gz
+Copyright (C) 2006-2009 Vreixo Formoso,
+Copyright (C) 2006-2013 Thomas Schmitt.
 Provided under GPL version 2 or later.
 ------------------------------------------------------------------------------

@ -18,10 +19,13 @@ The price for that is thorough specialization on data files in ISO-9660
 filesystem images. So libisoburn is not suitable for audio (CD-DA) or any
 other CD layout which does not entirely consist of ISO-9660 sessions.

-xorriso is a command line application of libisoburn, libisofs, and libburn.
+xorriso is an application of libisoburn, libisofs, and libburn, which reads
+commands from program arguments, files, stdin, or readline.
+Its features are also available via a C language API of libisoburn.

-Currently they are fully supported on Linux with kernels >= 2.4 and on
-FreeBSD versions with ATAPI/CAM support enabled in the kernel, see atapicam(4).
+Currently they are fully supported on Linux with kernels >= 2.4,
+on FreeBSD with ATAPI/CAM support enabled in the kernel, see atapicam(4),
+and on OpenSolaris (tested with kernel 5.11).
 On other X/Open compliant systems libburn will only offer POSIX i/o with disk
 file objects, but no direct MMC operation on CD/DVD/BD drives.

@ -31,17 +35,17 @@ By using this software you agree to the disclaimer at the end of this text:

                   Compilation, First Glimpse, Installation

-Dynamic library and compile time header requirements for libisoburn-0.5.2 :
- libburn.so.4  , version libburn-0.7.6 or higher
- libisofs.so.6 , version libisofs-0.6.28 or higher
+Dynamic library and compile time header requirements for libisoburn-1.2.8 :
+- libburn.so.4  , version libburn-1.2.8 or higher
+- libisofs.so.6 , version libisofs-1.2.8 or higher
 libisoburn and xorriso will not start with libraries which are older than their
-headers seen at compile time.
+include headers seen at compile time.

-Obtain libisoburn-0.5.2.pl00.tar.gz, take it to a directory of your choice
+Obtain libisoburn-1.2.8.tar.gz, take it to a directory of your choice
 and do:

-    tar xzf libisoburn-0.5.2.pl00.tar.gz
-    cd libisoburn-0.5.2
+    tar xzf libisoburn-1.2.8.tar.gz
+    cd libisoburn-1.2.8

 Within that directory execute:

@ -52,11 +56,25 @@ Then become superuser and execute
    make install
 which will make available libisoburn.so.1 and the program xorriso.

-For the API concepts and calls see
-    ./libisoburn/libisoburn.h
-as well as
-    /usr/lib/libisofs/libisofs.h
-    /usr/lib/libburn/libburn.h
+On GNU/Linux it will try to run program ldconfig with the library installation
+directory as only argument. Failure to do so will not abort installation.
+One may disable ldconfig by ./configure option --disable-ldconfig-at-install .
+
+
+By use of a version script, the libisoburn.so library exposes no other function
+names but those of the API definitions in <libisoburn/libisoburn.h> and
+<libisoburn/xorriso.h>.
+If -Wl,--version-script=... makes problems with the local compiler, then
+disable this encapsulation feature by
+    ./configure --disable-versioned-libs
+    make clean ; make
+
+The ./configure script of libisoburn can check via pkg-config whether suitable
+libburn and libisoburn are installed. Regrettably this test failed on several
+systems due to local pkg-config problems. So it is disabled by default and may
+be enabled by:
+   ./configure --enable-pkg-check-modules
+In this case, ./configure fails if no suitable installations are found.


                              xorriso
@ -71,6 +89,8 @@ xorriso binary depending on libburn.so, libisofs.so, libisoburn.so.

 After installation documentation is available via
    man xorriso
+    man xorrisofs
+    man xorrecord

 Several alias links point to the xorriso binary:
    xorrisofs  starts xorriso with -as mkisofs emulation already enabled
@ -84,8 +104,10 @@ are present. This dependcy can be avoided by running
 Never omit the "make clean" command after switching libreadline enabling.
 Other deliberate dependency reduction options of ./configure are:
    --disable-libacl   avoid use of ACL functions like acl_to_text()
-    --disable-xattr    avoid use of xattr functions like listxattr()
+    --disable-xattr    avoid use of xattr functions like listxattr() on Linux
+                       resp. extattr_list_file() on FreeBSD
    --disable-zlib     avoid use of zlib functions like compress2()
+    --disable-libjte   avoid use of libjte for -jigdo command

 xorriso allows to use external processes as file content filters. This is
 a potential security risk which may be avoided by ./configure option
@ -100,24 +122,102 @@ if 64 KB rather than 32 KB are transmitted in each write operation.
    --enable-dvd-obs-64k


+          libisoburn, libisofs, and libburn C language API
+
+For the lower API concepts and calls see
+    ./libisoburn/libisoburn.h
+as well as
+    /usr/include/libisofs/libisofs.h
+    /usr/include/libburn/libburn.h
+
+
+                      xorriso C language API
+
+Actually the dynamically linked xorriso binary is only a small start program
+for the xorriso API that is implemented inside libisoburn.
+There are API calls for command readers and interpreters, and there are
+API calls for each single command of xorriso.
+
+Interested programmers should have a look into the API definition at
+  xorriso/xorriso.h
+and the start program
+  xorriso/xorriso_main.c
+
+The header file  xorriso.h  gets installed suitable for
+  #include <libisoburn/xorriso.h>
+
+So after installation of a binary libisoburn package you may find it e.g. as
+  /usr/include/libisoburn/xorriso.h
+
+
+             xorriso under control of a (GUI) frontend process
+
+The dialog mode allows frontend programs to connect via pipes to the standard
+input and output of xorriso. Several commands of xorriso help with receiving
+and parsing of reply messages.
+
+As a proof of concept, there is the Tcl/Tk script xorriso-tcltk which can
+be launched by this shell command:
+
+    xorriso-tcltk
+
+Or in the xorriso build directory, without installation of xorriso:
+
+    xorriso/xorriso -launch_frontend frontend/xorriso-tcltk --stdio --
+
+In the running GUI, click with the rightmost mouse button on any GUI element
+to get its particular help text. The "Help" button at the upper right corner
+gives a short introduction and instructions for some common use cases.
+See also file frontend/README-tcltk.
+See its Tcl code for getting an idea how this gets achieved.
+
+The script is part of the tarball and gets installed by make install. If a
+xorriso distro package does not install it, you may get it directly from
+  http://libburnia-project.org/export/head/libisoburn/trunk/frontend/xorriso-tcltk
+
+Further there is the C program frontend/frontend_pipes_xorriso.c which
+forks a xorriso process and shows the same communication gestures as
+xorriso-tcltk.
+In particular it connects to xorriso via two pipes, sends commands, waits
+for all replies of a command, picks info out of the xorriso message sieve,
+and parses reply message lines into words.
+
+
                       Drives and Disk File Objects 

-The user of libisoburn applications needs rw-permission for the CD/DVD/BD
-drives which shall be used, even if only reading is intended.
+The user of libisoburn applications needs operating system dependent
+permissions for the CD/DVD/BD drives which shall be used.
+On Linux and FreeBSD this means -rw-permissions, even if only reading is
+intended. On Solaris one needs privileges "basic,sys_devices" and r-permission,
+even if writing is intended.
+
 A list of rw-accessible drives can be obtained by
    xorriso -devices
+resp. by xorriso API call
+    Xorriso_option_devices()
 resp. by libburn API call
    burn_drive_scan()

-
 A possible source of problems are hald or other automounters. 
 If you can spot a process "hald-addon-storage" with the address of
 your desired drive, then consider to kill it.
+A similar process "udisks-daemon: polling ..." can be seen on newer Linuxes.

-If you cannot get rid of the automounter that easily, try whether it helps
-to always load the drive tray manually before starting a write run of
-xorriso. Wait until the drive light is off.
-Better try to unmount an eventually mounted media before a write run.
+On Debian GNU/Linux 6.0.2 amd64 there is
+  /lib/udev/rules.d/80-udisks.rules
+where one can remove all CD drives ("sr*") from the list of automountable
+devices:
+  KERNEL=="sd*|hd*|mmcblk*|mspblk*", ENV{UDISKS_PRESENTATION_NOPOLICY}="0"
+  # KERNEL=="sd*|hd*|sr*|mmcblk*|mspblk*", ENV{UDISKS_PRESENTATION_NOPOLICY}="0"
+Copying the recognition criterion from
+  /etc/udev/rules.d/70-persistent-cd.rules
+one can prevent automounting a single drive, too. E.g.:
+  SUBSYSTEM=="block", ENV{ID_CDROM}=="?*", ENV{ID_PATH}=="pci-0000:00:11.0-scsi-2:0:0:0", ENV{UDISKS_PRESENTATION_NOPOLICY}:="1"
+
+If you cannot get rid of the automounter, try whether it helps to always load
+the drive tray manually before starting a write run of xorriso. Wait until the
+drive light is off and the mounted media appears.
+Then try to unmount the mounted media before a write run.


 Besides true optical drives, libisoburn can also address disk files as input or
@ -131,13 +231,19 @@ Note: xorriso by default prefixes "stdio:" to addresses outside the /dev tree

                              Testing

+For automated and manual tests of xorriso's functionality see file
+  releng/README.
+
+
+              Result comparison with self produced ISO images
+
 We are quite sure that libisofs produces accurate representations of the disk
 files. This opinion is founded on a lot of test burns and checks by a little
 test program which compares files from the mounted image with the orignals
 on disk. It uses the normal POSIX filesystem calls, i.e. no libburnia stuff.

 This program is not installed systemwide but stays in the installation
-directory of the xorriso tarball as  test/compare_file . Usually it is
+directory of the libisoburn tarball as  test/compare_file . Usually it is
 run as -exec payload of a find command. It demands at least three arguments:
 The path of the file to compare, the prefix1 to be cut off from path
 and the prefix2 which gets prepended afterwards to obtain the path of the
@ -179,7 +285,7 @@ libburnia-project.org
 By Mario Danic           <mario.danic@gmail.com>,
   Vreixo Formoso        <metalpain2002@yahoo.es>
   Thomas Schmitt        <scdbackup@gmx.net>
-Copyright (C) 2006-2010 Mario Danic, Vreixo Formoso, Thomas Schmitt.
+Copyright (C) 2006-2013 Mario Danic, Vreixo Formoso, Thomas Schmitt.

 We will not raise any legal protest to dynamic linking of our libraries
 with applications that are not under GPL, as long as they fulfill
--- a/acinclude.m4
+++ b/acinclude.m4
@ -5,6 +5,8 @@ freebsd*)
        LDFLAGS="$LDFLAGS -L/usr/local/lib"
        CPPFLAGS="$CPPFLAGS -I/usr/local/include"
        ;;
+solaris*)
+        LDFLAGS="$LDFLAGS -L/usr/local/lib"
 esac
 ])

@ -16,10 +18,12 @@ AC_DEFUN([TARGET_SHIZZLE],

  AC_MSG_CHECKING([target operating system])

+  LIBBURNIA_LDCONFIG_CMD="echo 'No ldconfig run performed. If needed, configure manually for:'"
  case $target in
    *-*-linux*)
      ARCH=linux
      LIBBURN_ARCH_LIBS=
+      LIBBURNIA_LDCONFIG_CMD=ldconfig
      ;;
    *-*-freebsd*)
      ARCH=freebsd
@ -50,8 +54,9 @@ dnl From Bruno Haible.
 dnl
 AC_DEFUN([LIBBURNIA_CHECK_ICONV],
 [
+
  dnl Check whether it is allowed to link with -liconv
-  AC_MSG_CHECKING([for separate -liconv ])
+  AC_MSG_CHECKING([for iconv() in separate -liconv ])
  libburnia_liconv="no"
  libburnia_save_LIBS="$LIBS"
  LIBS="$LIBS -liconv"
@ -65,6 +70,13 @@ AC_DEFUN([LIBBURNIA_CHECK_ICONV],
  )
  AC_MSG_RESULT([$libburnia_liconv])

+  if test x"$libburnia_save_LIBS" = x"$LIBS"
+  then
+    dnl GNU iconv has no function iconv() but libiconv() and a macro iconv()
+    dnl It is not tested whether this is detected by above macro.
+    AC_CHECK_LIB(iconv, libiconv, , )
+  fi
+
  dnl Check for iconv(..., const char **inbuf, ...)
  AC_MSG_CHECKING([for const qualifier with iconv() ])
  AC_TRY_COMPILE([
@ -73,13 +85,133 @@ AC_DEFUN([LIBBURNIA_CHECK_ICONV],
 size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);
 ], [], [libburnia_iconv_const=""], [libburnia_iconv_const="const"]
  )
-  AC_DEFINE_UNQUOTED([ICONV_CONST], [$libburnia_iconv_const])
+  if test x$libburnia_iconv_const = xconst
+  then
+    AC_DEFINE_UNQUOTED([ICONV_CONST], [const])
+  else
+    AC_DEFINE_UNQUOTED([ICONV_CONST], [])
+  fi
  test -z "$libburnia_iconv_const" && libburnia_iconv_const="no"
  AC_MSG_RESULT([$libburnia_iconv_const])
 ])


-dnl LIBBURNIA_SET_PKGCONFIG determines the install directory for the *.pc file.
+dnl LIBBURNIA_ASSERT_ICONV is by Thomas Schmitt, libburnia project
+dnl 
+AC_DEFUN([LIBBURNIA_ASSERT_ICONV],
+[
+  if test x$XORRISO_ASSUME_ICONV = x
+  then
+    dnl Check for the essential gestures of libisofs/util.c
+    AC_MSG_CHECKING([for iconv() to be accessible now ])
+    AC_TRY_LINK([
+#include <stdlib.h>
+#include <wchar.h>
+#include <string.h>
+#include <errno.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <limits.h>
+#include <iconv.h>
+#include <locale.h>
+#include <langinfo.h>
+#include <unistd.h>],
+[iconv_t cd = iconv_open("","");
+iconv(cd,NULL,NULL,NULL,NULL);
+iconv_close(cd);
+], [iconv_test="yes"], [iconv_test="no"]
+    )
+    AC_MSG_RESULT([$iconv_test])
+    if test x$iconv_test = xno
+    then
+      echo >&2
+      echo "Cannot get function iconv() to work. Configuration aborted." >&2
+      echo "Check whether your system needs a separate libiconv installed." >&2
+      echo "If it is installed but not found, try something like" >&2
+      echo '  export LDFLAGS="$LDFLAGS -L/usr/local/lib"' >&2 
+      echo '  export CPPFLAGS="$CPPFLAGS -I/usr/local/include"' >&2
+      echo '  export LIBS="$LIBS -liconv"' >&2
+      echo "You may override this test by exporting variable" >&2
+      echo "  XORRISO_ASSUME_ICONV=yes" >&2
+      echo >&2
+      (exit 1); exit 1;
+    fi
+  fi
+])
+
+
+dnl LIBBURNIA_TRY_READLINE is by Thomas Schmitt, libburnia project
+dnl It performs the actual test compilation for readline.
+dnl Variable LIBS has to be set by the caller.
+AC_DEFUN([LIBBURNIA_TRY_READLINE],
+[
+    AC_TRY_LINK([
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <readline/readline.h>
+#include <readline/history.h>],
+[HIST_ENTRY **hl;
+readline("");
+add_history("");
+hl= history_list();
+], [readline_test="yes"], [readline_test="no"]
+    )
+])
+
+
+dnl LIBBURNIA_ASSERT_READLINE is by Thomas Schmitt, libburnia project
+dnl It disables xorriso readline if not all needed functions are present
+AC_DEFUN([LIBBURNIA_ASSERT_READLINE],
+[
+  if test x$XORRISO_ASSUME_READLINE = x
+  then
+    dnl Check for the essential gestures of libisofs/util.c
+    AC_MSG_CHECKING([for desired functions in libreadline])
+    readline_msg=
+    libburnia_save_LIBS="$LIBS"
+    LIBS="$LIBS -lreadline"
+    LIBBURNIA_TRY_READLINE
+    if test x$readline_test = xno
+    then
+        LIBS="$libburnia_save_LIBS"
+        LIBS="$LIBS -lreadline -lcurses"
+        LIBBURNIA_TRY_READLINE
+        if test x$readline_test = xyes
+        then
+            readline_msg=", with -lcurses"
+        fi
+    fi
+    if test x$readline_test = xno
+    then
+        READLINE_DEF=
+        LIBS="$libburnia_save_LIBS"
+    fi
+    AC_MSG_RESULT([$readline_test $readline_msg])
+  fi
+])
+
+
+dnl LIBISOBURN_ASSERT_VERS_LIBS is by Thomas Schmitt, libburnia project
+dnl It tests whether -Wl,--version-script=... works with the compiler
+AC_DEFUN([LIBISOBURN_ASSERT_VERS_LIBS],
+[
+    libburnia_save_LDFLAGS="$LDFLAGS"
+    LDFLAGS="$LDFLAGS -Wl,--version-script=libisoburn/libisoburn.ver"
+    AC_TRY_LINK([#include <stdio.h>], [printf("Hello\n");],
+                [vers_libs_test="yes"], [vers_libs_test="no"])
+    if test x$vers_libs_test = xno
+    then
+        LDFLAGS="$libburnia_save_LDFLAGS"
+    fi
+])
+
+
+dnl LIBBURNIA_SET_PKGCONFIG is by Thomas Schmitt, libburnia project
+dnl It determines the install directory for the *.pc file.
 dnl Important: Must be performed _after_ TARGET_SHIZZLE
 dnl
 AC_DEFUN([LIBBURNIA_SET_PKGCONFIG],
--- a/6
+++ b/6
@ -1,7 +1,11 @@
 #!/bin/sh -x

-aclocal
+aclocal -I .
 libtoolize --copy --force
 autoconf
+
+# Not with libisoburn
+# autoheader
+
 automake --foreign --add-missing --copy --include-deps

--- a/configure.ac
+++ b/configure.ac
@ -1,4 +1,4 @@
-AC_INIT([libisoburn], [0.5.2], [http://libburnia-project.org])
+AC_INIT([libisoburn], [1.2.8], [http://libburnia-project.org])
 AC_PREREQ([2.50])
 dnl AC_CONFIG_HEADER([config.h])	

@ -8,6 +8,7 @@ AC_CANONICAL_TARGET
 LIBBURNIA_SET_FLAGS

 AM_INIT_AUTOMAKE([subdir-objects])
+AC_CONFIG_MACRO_DIR([./])

 dnl Hint: Search list for version code aspects:
 dnl       /AC_INIT(
@ -21,9 +22,9 @@ dnl configure.ac only rules the libtool revision numbering about
 dnl LT_CURREN, LT_AGE, LT_REVISION where SONAME becomes LT_CURRENT - LT_AGE
 dnl 
 dnl These three are only copies to provide libtool with unused LT_RELEASE
-ISOBURN_MAJOR_VERSION=0
-ISOBURN_MINOR_VERSION=5
-ISOBURN_MICRO_VERSION=2
+ISOBURN_MAJOR_VERSION=1
+ISOBURN_MINOR_VERSION=2
+ISOBURN_MICRO_VERSION=8

 dnl ISOBURN_VERSION=$ISOBURN_MAJOR_VERSION.$ISOBURN_MINOR_VERSION.$ISOBURN_MICRO_VERSION
 
@ -36,16 +37,16 @@ dnl Libtool versioning
 dnl Generate libisoburn.so.1.x.y
 dnl SONAME will become LT_CURRENT - LT_AGE
 dnl 
-dnl ts B00329
-dnl This is the release version 0.5.2 = libisoburn.so.1.41.0
+dnl ts B30318
+dnl This is the release version 1.2.8 = libisoburn.so.1.85.0
 dnl ### This is the development version after above stable release
 dnl LT_CURRENT++, LT_AGE++ have not happened yet.
 dnl ### LT_CURRENT++, LT_AGE++ has happened meanwhile.
 dnl
-dnl SONAME = 42 - 41 = 1 . Library name = libisoburn.so.1.41.0
+dnl SONAME = 86 - 85 = 1 . Library name = libisoburn.so.1.85.0
 LT_RELEASE=$ISOBURN_MAJOR_VERSION.$ISOBURN_MINOR_VERSION
-LT_CURRENT=42
-LT_AGE=41
+LT_CURRENT=86
+LT_AGE=85
 LT_REVISION=0
 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`

@ -73,11 +74,22 @@ if test ! $ac_cv_func_fseeko; then
   AC_ERROR([Libburn requires largefile support.])
 fi

+if test x$LIBISOBURN_OLD_ICONV_CONFIGURE = x
+then
+
+dnl ts B00410 : To detect the need for -liconv and const argument of iconv()
+    LIBBURNIA_CHECK_ICONV
+
+else
+
+dnl Outdated: produces double -liconv and warnings about parameter mismatch
 dnl If iconv(3) is in an extra lib, then it gets added to variable LIBS.
 dnl If not, then no -liconv will be added.
-AC_CHECK_LIB(iconv, iconv, , )
+    AC_CHECK_LIB(iconv, iconv, , )
 dnl GNU iconv has no function iconv() but libiconv() and a macro iconv()
-AC_CHECK_LIB(iconv, libiconv, , )
+    AC_CHECK_LIB(iconv, libiconv, , )
+
+fi

 AC_PROG_LIBTOOL
 AC_SUBST(LIBTOOL_DEPS)
@ -87,6 +99,13 @@ AC_PROG_INSTALL

 AC_CHECK_HEADERS()

+dnl Check for tm_gmtoff field in struct tm
+AC_CHECK_MEMBER([struct tm.tm_gmtoff],
+	[AC_DEFINE(HAVE_TM_GMTOFF, 1,
+		[Define this if tm structure includes a tm_gmtoff entry.])],
+	,
+	[#include <time.h>])
+
 THREAD_LIBS=-lpthread
 AC_SUBST(THREAD_LIBS)

@ -109,10 +128,19 @@ if test x$enable_libreadline = xyes; then
 dnl Check whether there is readline-devel and readline-runtime.
 dnl If not, erase this macro which would enable use of readline(),add_history()
    READLINE_DEF="-DXorriso_with_readlinE"
+
+    if test x$XORRISO_OLD_READLINE_CONFIGURE = x
+    then
+
+dnl ts B00411 : To disable readline if not all needed functions are present
+        LIBBURNIA_ASSERT_READLINE
+
+    else
 dnl The empty yes case obviously causes -lreadline to be linked
-    AC_CHECK_HEADER(readline/readline.h, AC_CHECK_LIB(readline, readline, , READLINE_DEF= ), READLINE_DEF= )
+        AC_CHECK_HEADER(readline/readline.h, AC_CHECK_LIB(readline, readline, , READLINE_DEF= ), READLINE_DEF= )
 dnl The X= in the yes case prevents that -lreadline gets linked twice
-    AC_CHECK_HEADER(readline/history.h, AC_CHECK_LIB(readline, add_history, X= , READLINE_DEF= ), READLINE_DEF= )
+        AC_CHECK_HEADER(readline/history.h, AC_CHECK_LIB(readline, add_history, X= , READLINE_DEF= ), READLINE_DEF= )
+    fi
 else
    READLINE_DEF=
 fi
@ -175,14 +203,33 @@ else
 fi
 AC_SUBST(ZLIB_DEF)

+dnl ts B00928
+AC_ARG_ENABLE(libjte,
+[  --enable-libjte         Enable use of libjte by xorriso, default=yes],
+               , enable_libjte=yes)
+if test "x$enable_libjte" = xyes; then
+    LIBJTE_DEF="-DXorriso_with_libjtE"
+    AC_CHECK_HEADER(libjte/libjte.h, AC_CHECK_LIB(jte, libjte_new, , LIBJTE_DEF= ), LIBJTE_DEF= )
+else
+    LIBJTE_DEF=
+fi
+AC_SUBST(LIBJTE_DEF)

 dnl ts B00107
 dnl Just for the case that it is necessary to give link option -lcdio not only
 dnl with libburn but also with libburn apps like xorriso.
 dnl On SuSE 10.2 this is not needed. libburn finds libcdio on its own.
+case $host_os in
+    cygwin*|mingw*)
+        default_libcdio=yes
+        ;;
+    *)
+        default_libcdio=no
+        ;;
+esac
 AC_ARG_ENABLE(libcdio,
-[  --enable-libcdio         Enable EXPERIMENTAL use of libcdio as system adapter, default=no],
-               , enable_libcdio=no)
+[  --enable-libcdio        Enable use of libcdio as system adapter, default=no (except on MSWindows)],
+               , enable_libcdio=$default_libcdio)
 if test x$enable_libcdio = xyes; then
 dnl Check whether there is libcdio-devel and libcdio-runtime.
 dnl If not, erase this macro
@ -192,11 +239,20 @@ dnl The empty yes case obviously causes -lcdio to be linked
 else
    LIBCDIO_DEF=
 fi
+if test x$LIBCDIO_DEF = x
+then
+    if test x$enable_libcdio = xyes
+    then
+      echo "WARNING: could not enable use of libcdio as system adapter"
+    fi
+else
+    echo "enabled  use of libcdio as system adapter"
+fi
 AC_SUBST(LIBCDIO_DEF)


 AC_ARG_ENABLE(external-filters,
-[  --enable-external-filters   Enable use of external filter programs by xorriso, default=yes],
+[  --enable-external-filters       Enable use of external filter programs by xorriso, default=yes],
               , enable_external_filters=yes)
 if test x"$enable_external_filters" = xyes; then
    EXTF_DEF="-DXorriso_allow_external_filterS"
@ -219,9 +275,35 @@ else
 fi
 AC_SUBST(EXTF_SUID_DEF)

+
+AC_ARG_ENABLE(launch-frontend,
+[  --enable-launch-frontend        Enable start of piped frontend program by xorriso, default=yes],
+               , enable_launch_frontend=yes)
+if test x"$enable_launch_frontend" = xyes; then
+    LFRONT_DEF="-DXorriso_allow_launch_frontenD"
+    echo "enabled  xorriso command -launch_frontend"
+else
+    LFRONT_DEF=
+    echo "disabled xorriso command -launch_frontend"
+fi
+AC_SUBST(LFRONT_DEF)
+
+AC_ARG_ENABLE(launch-frontend-setuid,
+[  --enable-launch-frontend-setuid   Enable start of piped frontend program under setuid, default=no],
+               , enable_launch_frontend_setuid=no)
+if test x$enable_launch_frontend_setuid = xyes; then
+    LFRONT_SUID_DEF="-DXorriso_allow_extf_suiD"
+    echo "enabled  xorriso command -launch_frontend under setuid"
+else
+    LFRONT_SUID_DEF=
+    echo "disabled xorriso command -launch_frontend under setuid"
+fi
+AC_SUBST(LFRONT_SUID_DEF)
+
+
 AC_ARG_ENABLE(dvd-obs-64k,
 [  --enable-dvd-obs-64k            64 KB default size for xorriso DVD/BD writing, default=no],
-               , enable_fifo_odirect=no)
+               , enable_dvd_obs_64=no)
 if test x$enable_dvd_obs_64k = xyes; then
    XORRISO_DVD_OBS_64K="-DXorriso_dvd_obs_default_64K"
    echo "enabled  xorriso write size default 64 KB on DVD and BD"
@ -231,31 +313,87 @@ else
 fi
 AC_SUBST(XORRISO_DVD_OBS_64K)

-
-AC_CHECK_HEADER(libburn/libburn.h)
-AC_CHECK_HEADER(libisofs/libisofs.h)
-
-dnl Check for proper library versions
-LIBBURN_REQUIRED=0.7.8
-LIBISOFS_REQUIRED=0.6.28
-PKG_CHECK_MODULES(LIBBURN, libburn-1 >= $LIBBURN_REQUIRED)
-PKG_CHECK_MODULES(LIBISOFS, libisofs-1 >= $LIBISOFS_REQUIRED)
-
-if test x$LIBCDIO_DEF = x
-then
-    if test x$enable_libcdio = xyes
+# Library versioning normally serves a complex purpose.
+# Since libisoburn obeys strict ABI backward compatibility, it needs only the
+# simple feature to declare function names "global:" or "local:". Only the
+# global ones are visible to applications at library load time.
+AC_ARG_ENABLE(versioned-libs,
+[  --enable-versioned-libs         Enable strict symbol encapsulation , default=yes],
+               , enable_versioned_libs=yes)
+if test x$enable_versioned_libs = xyes; then
+    vers_libs_test=no
+    LIBISOBURN_ASSERT_VERS_LIBS
+    if test x$vers_libs_test = xno
    then
-      echo "WARNING: could not enable use of libcdio as system adapter"
+        echo "disabled strict symbol encapsulation (test failed)"
+    else
+        echo "enabled  strict symbol encapsulation"
    fi
 else
-    echo "enabled  EXPERIMENTAL use of libcdio as system adapter"
+    echo "disabled strict symbol encapsulation"
+fi

-dnl For some reason this check may not be done earlier or else pkg-config
-dnl is not found.
+AC_ARG_ENABLE(ldconfig-at-install,
+[  --enable-ldconfig-at-install    On GNU/Linux run ldconfig, default=yes],
+               , ldconfig_at_install=yes)
+if test x$ldconfig_at_install = xyes; then
+    dummy=dummy
+else
+    LIBBURNIA_LDCONFIG_CMD="echo 'NOTE: ldconfig is disabled. If needed, configure manually for:'"
+    echo "disabled run of ldconfig during installation on GNU/Linux"
+fi
+AC_SUBST(LIBBURNIA_LDCONFIG_CMD)
+
+
+AC_CHECK_HEADER(libburn/libburn.h, LIBBURNIA_HAVE_LIBBURN=1, LIBBURNIA_HAVE_LIBBURN=0)
+AC_CHECK_HEADER(libisofs/libisofs.h, LIBBURNIA_HAVE_LIBISOFS=1, LIBBURNIA_HAVE_LIBISOFS=0)
+if test x$LIBBURNIA_HAVE_LIBBURN = x0; then
+    echo "FATAL: Lacking libburn development header file <libburn/libburn.h>" 2>&1
+    echo "HINT: You first have to install libburn before you can build libisoburn" 2>&1
+fi
+if test x$LIBBURNIA_HAVE_LIBISOFS = x0; then
+    echo "FATAL: Lacking libisofs development header file <libisofs/libisofs.h>" 2>&1
+    echo "HINT: You first have to install libisofs before you can build libisoburn" 2>&1
+fi
+if test x$LIBBURNIA_HAVE_LIBBURN = x0 -o x$LIBBURNIA_HAVE_LIBISOFS = x0; then
+    echo "ABORT: Lacking mandatory prerequisites" 2>&1
+    exit 1
+fi
+
+# ------- Visible mark in configure : Start of library check
+
+# Check for proper library versions if this is desired.
+# (It fails too often on too many systems.)
+AC_ARG_ENABLE(pkg-check-modules,
+[  --enable-pkg-check-modules      Enable pkg-config check for libburn and libisofs , default=no],
+               , enable_pkg_check_modules=no)
+if test x$enable_pkg_check_modules = xyes; then
+
+dnl If PKG_CHECK_MODULES is to be used after this if-block,
+dnl then it might be necessary to perform PKG_PROG_PKG_CONFIG before the block.
+
+  LIBBURN_REQUIRED=1.2.8
+  LIBISOFS_REQUIRED=1.2.8
+  PKG_CHECK_MODULES(LIBBURN, libburn-1 >= $LIBBURN_REQUIRED)
+  PKG_CHECK_MODULES(LIBISOFS, libisofs-1 >= $LIBISOFS_REQUIRED)
+  if test x$LIBCDIO_DEF = x; then
+    dummy=dummy
+  else
    LIBCDIO_REQUIRED=0.83
    PKG_CHECK_MODULES(LIBCDIO, libcdio >= $LIBCDIO_REQUIRED)
+  fi
+else
+  echo "checking for LIBBURN... skipped, no --enable-pkg-check-modules"
+  echo "checking for LIBISOFS... skipped, no --enable-pkg-check-modules"
+  if test x$LIBCDIO_DEF = x; then
+    dummy=dummy
+  else
+    echo "checking for LIBCDIO... skipped, no --enable-pkg-check-modules"
+  fi
 fi

+# ------- Visible mark in configure : End of library check
+
 dnl Add compiler-specific flags

 dnl See if the user wants aggressive optimizations of the code
@ -264,17 +402,19 @@ AC_ARG_ENABLE(debug,
              , enable_debug=yes)
 if test x$enable_debug != xyes; then
    if test x$GCC = xyes; then
-        CFLAGS="$CFLAGS -O3"
-        CFLAGS="$CFLAGS -fexpensive-optimizations"
+        CFLAGS="-O3 $CFLAGS"
+        CFLAGS="-fexpensive-optimizations $CFLAGS"
    fi
-    CFLAGS="$CFLAGS -DNDEBUG"
+    CFLAGS="-DNDEBUG $CFLAGS"
 else
    if test x$GCC = xyes; then
-        CFLAGS="$CFLAGS -g -pedantic -Wall"
+        CFLAGS="-g -pedantic -Wall -Wextra -Wno-unused-parameter $CFLAGS"
    fi
-    CFLAGS="$CFLAGS -DDEBUG"
+    CFLAGS="-DDEBUG $CFLAGS"
 fi

+CFLAGS="$READLINE_DEF $LIBACL_DEF $XATTR_DEF $EXTF_DEF $EXTF_SUID_DEF $LFRONT_DEF $LFRONT_SUID_DEF $ZLIB_DEF $LIBJTE_DEF $XORRISO_DVD_OBS_64K $CFLAGS"
+
 AC_CONFIG_FILES([
 	Makefile
 	doc/doxygen.conf
--- a/doc/comments
+++ b/doc/comments
@ -10,7 +10,7 @@ optical discs. This page is about its capability to read, manipulate, and
 write ISO 9660 filesystems with Rock Ridge extensions. Media can be optical
 media or filesystem objects.

-Our scope is currently Linux 2.4 and 2.6, or FreeBSD .
+Our scope is currently Linux 2.4 and 2.6, or FreeBSD, or OpenSolaris.

 libisoburn is an add-on to libburn and libisofs which coordinates both and
 also allows to grow ISO-9660 filesystem images on multi-session media as well
@ -21,7 +21,9 @@ xorriso is an application of all three libraries which creates, loads,
 manipulates and writes ISO 9660 filesystem images with Rock Ridge extensions.
 Manipulation is not only adding or overwriting of files but also deletion,
 renaming, and attribute changing. An incremental backup feature is provided.
-See xorriso/README for more
+The xorriso features are accessible via built-in command interpreters and
+via a C language API.
+

 SONAME:
 libisoburn.so.1 (since 0.1.0, February 2008).
@ -32,7 +34,7 @@ libisoburn.so.1 (since 0.1.0, February 2008).
 Our build system is based on autotools.
 User experience tells us that you will need at least autotools version 1.7.

-To build libisoburn go into its toplevel directory and execute
+To build libisoburn go into its toplevel directory and execute:

 -  ./bootstrap  (needed if you downloaded from SVN)

@ -40,14 +42,28 @@ To build libisoburn go into its toplevel directory and execute

 -  make

-To make the libraries accessible for running resp. developing applications 
+To make the library and the xorriso application accessible for running resp.
+software development:

 -  make install

-Read libisoburn/libisoburn.h for a description of the API.
-See also README, xorriso/README, and the man page xorriso/xorriso.1 which
-gives an idea of the capabilities provided by Libburnia.

+For direct use as command line tool use the xorriso binary which among many
+other features provides a mkisofs emulation via command "-as mkisofs".
+See man page xorriso/xorriso.1 or GNU info document xorriso/xorriso.info.
+
+
+If you want to link an own application with libisoburn, you have
+two alternative APIs for choice:
+
+-  libisoburn, together with libburn and libisofs.
+
+-  xorriso, a complete representation of xorriso command line options.
+   It encapsulates the three lower level libraries.
+   Calls of both API families shall not be mixed.
+
+For a description of the lbisoburn API read libisoburn/libisoburn.h
+See file README for download and installation of a release tarball.
 You will also have to install and understand the two libraries of the 
 Libburnia project which provide fundamental services:
 libburn is the library by which preformatted data get onto optical media.
@ -55,4 +71,15 @@ See libburn/libburn.h for its API description.
 libisofs is the library to handle ISO 9660 filesystems with Rock Ridge 
 extensions. Its API is described in libisofs/libisofs.h .

+For xorriso features see its man page xorriso/xorriso.1 or
+its GNU info document xorriso/xorriso.info.
+For the corresponding C language API see libisoburn/xorriso.h (resp.
+xorriso/xorriso.h in the build directory).
+The implementation this API is part of libisoburn.
+The xorriso command line tool gets installed as dynamically linked
+binary together with libisoburn.
+
+There is also a statically linked release named GNU xorriso.
+See xorriso/README_gnu_xorriso for its download and installation.
+
 */
--- a/doc/doxygen.conf.in
+++ b/doc/doxygen.conf.in
@ -154,13 +154,6 @@ QT_AUTOBRIEF           = NO

 MULTILINE_CPP_IS_BRIEF = YES

-# If the DETAILS_AT_TOP tag is set to YES then Doxygen 
-# will output the detailed description near the top, like JavaDoc.
-# If set to NO, the detailed description appears after the member 
-# documentation.
-
-DETAILS_AT_TOP         = YES
-
 # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
 # member inherits the documentation from any documented member that it 
 # re-implements.
@ -495,7 +488,9 @@ INPUT_ENCODING         = UTF-8
 # *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx 
 # *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py

-FILE_PATTERNS          = 
+FILE_PATTERNS          = libisoburn.h \
+                         xorriso.h \
+                         comments

 # The RECURSIVE tag can be used to turn specify whether or not subdirectories 
 # should be searched for input files as well. Possible values are YES and NO. 
@ -1150,7 +1145,8 @@ HIDE_UNDOC_RELATIONS   = YES
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section 
 # have no effect if this option is set to NO (the default)

-HAVE_DOT               = YES
+# ts B10415: dot causes sigsegv on Debian buildd
+HAVE_DOT               = NO

 # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
 # will generate a graph for each documented class showing the direct and 
--- a/doc/faq.wiki
+++ b/doc/faq.wiki
@ -0,0 +1,308 @@
+
+'''Libburnia Frequently Asked Questions'''
+
+Please post your questions to
+[http://mailman-mail1.webfaction.com/listinfo/libburn-hackers/ libburn-hackers mailing list].
+
+----------------------------------------------------------------------------
+'''Content:'''
+
+Burning:
+
+ [#diff_cdrskin_xorriso  What is the difference between cdrskin and xorriso ?]
+
+ [#scsi_error  What does that SCSI error message mean ?]
+
+Imaging:
+
+ [#edit_files  Is there a way to edit files inside the ISO image ?]
+
+ [#boot_arch  For which architectures xorriso is able to create bootable images ?]
+
+ [#isohybrid  How to enable booting from USB stick ?]
+
+ [#partition_offset  What is partition offset feature all about?]
+
+ [#partition_offset_apple  Partition offset bad on Apple ?]
+
+Development:
+
+ [#api_specs  Where are the APIs of libburnia libraries described ?]
+
+ [#gui_advise  I want to write a GUI on the top of libburnia libraries. Any pointers or recommendations ?]
+
+Miscellaneous:
+
+ [#example_links  Where to see examples ?]
+
+ [#xorriso_aliases  What personalities are supported by xorriso ?]
+
+ [#xorriso_dialog_mode  What is xorriso dialog mode useful for ?]
+
+ [#version_numbers  Why is every second release missing ?]
+
+----------------------------------------------------------------------------
+'''Burning'''
+----------------------------------------------------------------------------
+
+===== What is the difference between cdrskin and xorriso ? ===== #diff_cdrskin_xorriso
+
+[wiki:Cdrskin cdrskin] is a dedicated emulator of program cdrecord, based on
+libburn. It tries to be as similar to cdrecord as is possible under that
+premise.
+
+[wiki:Xorriso xorriso] is an integrated tool which creates, loads, manipulates,
+and writes ISO 9660 filesystem images with Rock Ridge extensions.
+It is based on libburn, libisofs, and libisoburn. One of its features is
+the emulation of the corresponding tasks as done by mkisofs and cdrecord.
+
+===== What does that SCSI error message mean ? ===== #scsi_error
+
+Error messages labled as "SCSI" stem from the drive. They are codes of
+three hexadecimal numbers, like [3 0C 00]. The first number gives an overall
+classification of the problem. The other two numbers give the particular
+error description.
+
+libburn translates known error codes into text messages. They consist of
+two statements: the overall classification and the error description.
+
+E.g. [3 0C 00] Medium error. Write error.
+
+The classification allows a guess where the problem cause might sit:
+
+2 "Drive not ready" : This is a well normal drive state and should be handled
+by libburn. If you see this outside of DEBUG messages then it happened
+at an unexpected occasion. Either libburn did its job wrong, or the hardware
+suffers from blackouts. Hardware can be: drive, cable, bus controller.
+
+Workaround: Check cables. If possible, try the drive at a different
+bus controller.
+
+3 "Medium error" : This indicates a problem between drive and medium. libburn
+cannot directly cause such an error by any mistake. If drive and medium
+are balancing on the edge of defect, it is possible that optional settings
+can cause or prevent such errors. But in many cases of drive-medium conflicts
+it is mere incident whether a burn run succeeds or not.
+
+Workaround: Try other media or another drive.
+
+4 "Drive error" : The drive or the bus controller accuse themselves of
+doing it wrong. As with "Medium error" this might be aggravated or eased by
+optional settings.
+
+Workaround: Check cables. If possible, try the drive at a different
+bus controller.
+
+5 "Illegal request" : The drive did not like a command sent by libburn.
+This may be normal. But if you see this outside of DEBUG messages, then
+either the drive does not comply to MMC or libburn does not do its job right.
+
+Workaround: Submit an error report to
+[http://mailman-mail1.webfaction.com/listinfo/libburn-hackers/ libburn-hackers mailing list].
+
+B "Command aborted" : Seems to be generated by some bus controllers or
+operating system SCSI drivers.
+
+Workaround: Contact
+[http://mailman-mail1.webfaction.com/listinfo/libburn-hackers/ libburn-hackers mailing list]
+and be ready for experiments.
+
+
+----------------------------------------------------------------------------
+'''Imaging'''
+----------------------------------------------------------------------------
+
+===== Is there a way to edit files inside the ISO image ? ===== #edit_files
+
+File content cannot be altered. But files may be replaced by new copies from
+the disk filesystem.
+
+The main method of manipulating an existing ISO image is to append a session
+with a new complete directory tree and the file content of the added or
+overwritten files. Depending on the media type you get gaps between sessions
+of up to 20 MB. So better try to do all foreseeable changes by one add-on
+session.
+
+===== For which architectures xorriso is able to create bootable images ? ===== #boot_arch
+
+Currently it supports systems with PC-BIOS via El Torito for booting from
+CD, DVD, or BD media, and via MBR for booting from memory sticks or hard
+disks. Further it supports machines with MIPS processor from SGI (Big Endian)
+and DEC (Little Endian), and SUN SPARC machines.
+(See [http://bazaar.launchpad.net/%7Elibburnia-team/libisofs/scdbackup/annotate/head%3A/doc/boot_sectors.txt libisofs/doc/boot_sectors.txt]
+for technical details.)
+
+Machines which support EFI may either boot via El Torito or use the files
+of the ISO image directly. It is possible to append to the ISO image a
+writeable FAT12 partition where files for EFI may be stored and changed.
+
+===== How to enable booting from USB stick ? ===== #isohybrid
+
+The ISOLINUX boot loader is normally started from CD, DVD or BD media
+by a PC-BIOS via an El Torito boot record. But if the ISO image resides on an
+USB stick or another hard-disk-like device, then PC-BIOS ignores El Torito
+and rather expects a Master Boot Record (MBR). Both boot record types can
+reside in the same ISO image. Therefore it is possible to create an MBR that
+starts the boot image file of ISOLINUX which is already target of the El Torito
+boot record. This kind of MBR is called "isohybrid". ISOLINUX provides
+a program named isohybrid to patch existing images, but libisofs can create an
+MBR already when producing the ISO image. See in
+[http://www.gnu.org/software/xorriso/man_1_xorriso.html manual page of xorriso] 
+option -boot_image with arguments "isolinux" "system_area=",
+and -as mkisofs option -isohybrid-mbr.
+
+See [http://en.wikipedia.org/wiki/Master_boot_record Wikipedia on MBR] for
+general information about PC-DOS Master Boot Records, and
+[http://syslinux.zytor.com/wiki/index.php/ISOLINUX ISOLINUX wiki] for special
+information about ISOLINUX. The wiki example with mkisofs can be performed
+as well by help of xorriso option -as mkisofs.
+
+A similar combination of El Torito and MBR is created by GRUB2 tool
+grub-mkrescue. See [http://www.gnu.org/software/grub/ homepage of GNU GRUB 2]
+for general information.
+
+===== What is partition offset feature all about? ===== #partition_offset
+
+If an MBR is present, then it contains a partition table with up to four
+entries. The MBR is located at the very start of the ISO image. By
+tradition the first partition should begin only after the range of MBR and
+eventual supporting data blocks. On hard disk one often sees partition 1
+starting at byte 63*512. Further it is tradition that the payload filesystem
+is mountable via one of the partitions.
+
+The isohybrid MBR has its only partition start at byte 0. Thus it is mountable
+but does not obey the tradition to begin only after the MBR. The grub-mkrescue
+MBR on the other hand has partition 1 start at byte 512, which makes it
+unmountable. Only the unpartitioned base device can be mounted. (On GNU/Linux
+e.g. /dev/sdb is the base device whereas /dev/sdb1 is partition 1.)
+
+The compromise offered by libisofs is to create a second superblock at
+address 16*2048 and to let start partition 1 at this address. The second
+superblock leads to a second directory tree which takes into account the
+address difference between partition 1 and the base device. So the image
+gets mountable via both devices and reserves 32 kB for boot manager software
+where it may manipulate and augment the MBR.
+(See [http://libburnia-project.org/wiki/PartitionOffset Partition Offset Wiki]
+for examples.)
+
+There are reports of machines which will not boot from USB stick if
+partition offset is 0.
+
+===== Partition offset bad on Apple ? ===== #partition_offset_apple
+
+Apple's "Snow Leopard" operating system refuses to mount Debian CD images
+with non-zero partition offset.
+
+The issue is still under investigation. But for now one has to choose
+between mountability on Apple "Snow Leopard" or bootability from USB stick
+on Kontron CG2100 "carrier grade server".
+
+----------------------------------------------------------------------------
+'''Developing'''
+----------------------------------------------------------------------------
+
+===== Where are the APIs of libburnia libraries described ? ===== #api_specs
+
+The decisive references are the inclusion headers of the libraries
+<libburn/libburn.h>, <libisofs/libisofs.h>, <libisoburn/libisoburn.h>,
+and <libisoburn/xorriso.h>.
+
+Current SVN versions of these files: 
+[http://libburnia-project.org/browser/libburn/trunk/libburn/libburn.h libburn/libburn.h] ,
+[http://bazaar.launchpad.net/%7Elibburnia-team/libisofs/scdbackup/annotate/head%3A/libisofs/libisofs.h libisofs/libisofs.h] ,
+[http://libburnia-project.org/browser/libisoburn/trunk/libisoburn/libisoburn.h libisoburn/libisoburn.h] ,
+[http://libburnia-project.org/browser/libisoburn/trunk/xorriso/xorriso.h libisoburn/xorriso.h]
+
+Doxygen generated API descriptions at
+[http://api.libburnia-project.org api.libburnia-project.org]
+might be slightly behind the latest developments.
+
+===== I want to write a GUI on the top of libburnia libraries. Any pointers or recommendations ? ===== #gui_advise
+
+Most appreciated would be a GUI for xorriso which allows to copy files from
+a view of the hard disk filesystem to a view of the ISO filesystem, and vice
+versa. The xorriso implementation is located inside libisoburn.
+
+Each option that is described in
+[http://www.gnu.org/software/xorriso/man_1_xorriso.html man 1 xorriso]
+can be performed by a corresponding C function that is defined in
+[http://libburnia-project.org/browser/libisoburn/trunk/xorriso/xorriso.h xorriso.h].
+Further there are calls for library startup and shutdown, for problem
+handling, and for the interpreters of xorriso's command line interface.
+The xorriso API encapsulates calls to libisofs, libburn, and libisoburn.
+
+An alternative to the xorriso C API is xorriso dialog mode.
+[#xorriso_dialog_mode See below.]
+The script
+[http://libburnia-project.org/browser/libisoburn/trunk/frontend/xorriso-tcltk xorriso-tcltk]
+demonstrates this approach. It is part of the
+libisoburn release tarball and of the GNU xorriso tarball.
+
+The known existing GUIs [http://www.xfce.org/projects/xfburn/ Xfburn],
+[http://projects.gnome.org/brasero/ Brasero],
+[http://flburn.sourceforge.net/ FlBurn]
+rather use libisofs and libburn directly.
+(Please submit an URI if you want your libburnia GUI application mentioned
+here.)
+
+----------------------------------------------------------------------------
+'''Miscellaneous'''
+----------------------------------------------------------------------------
+
+===== Where to see examples ? ===== #example_links
+
+[http://www.gnu.org/software/xorriso/man_1_xorriso.html#EXAMPLES xorriso examples] ,
+[http://scdbackup.sourceforge.net/man_1_cdrskin_devel.html#EXAMPLES cdrskin examples] ,
+[http://libburnia-project.org/browser/libburn/trunk/test/libburner.c libburner.c a minimal but complete burn program]
+(also illustrated at the end of [http://api.libburnia-project.org/libburn/ libburn API intro]).
+
+
+===== What personalities are supported by xorriso ? ===== #xorriso_aliases
+
+The name by which xorriso is started may trigger certain features which
+normally would need to be enabled by program options.
+
+xorrisofs starts up in mkisofs emulation mode, which otherwise would have to
+be entered by command -as "mkisofs".
+
+xorrecord starts up in cdrecord emulation mode, which is normally entered by
+command -as "cdrecord". This emulation is only able to write a single data
+track as new session to blank or appendable media. No audio. No multiple
+tracks in one session.
+
+osirrox allows to copy files from ISO image to disk and to apply option -mount
+to one or more of the existing ISO sessions. This is normally enabled by
+option -osirrox "on:o_excl_off".
+
+===== What is xorriso dialog mode useful for ? ===== #xorriso_dialog_mode
+
+Dialog mode is initiated if -dialog "on" is among the program arguments.
+It can be used to inspect and exploit existing ISO 9660 images or
+to explore xorriso's behavior in order to develop the command sequence
+for a batch run.
+
+Frontend programmers may fork xorriso initiating a xorriso dialog session
+(-dialog "on" -use_readline "off" -pkt_output "on" -mark "done"),
+and interact with it from their own program via pipes connected to
+xorriso's stdin and stdout. This is more efficient than forking xorriso
+every now and then to perform various commands in order to complete
+complex tasks like image size prediction.
+
+The script
+[http://libburnia-project.org/browser/libisoburn/trunk/frontend/xorriso-tcltk xorriso-tcltk]
+demonstrates this approach. It is part of the
+libisoburn release tarball and of the GNU xorriso tarball.
+
+===== Why is every second release missing ? ===== #version_numbers
+
+Releases have an even third version number. Like 0.5.6 or 1.0.4.
+During development the next higher odd number is used. E.g. 0.5.7 or 1.0.5.
+
+The content of release tarballs does not get changed without changing
+their name. The development tarballs of xorriso and cdrskin may change
+their content without notice.
+
+----------------------------------------------------------------------------
+Site maintainer: Do not edit this wiki directly but rather the SVN version
+of libisoburn/trunk/doc/faq.wiki. When done, paste it into the wiki editor.
+
--- a/doc/partition_offset.wiki
+++ b/doc/partition_offset.wiki
@ -0,0 +1,232 @@
+
+The partition offset feature of libisofs can produce ISO 9660 images which bear
+a quite conventional partition table if copied onto a USB stick. The first
+partition marks the size of the ISO image but starts at a non-zero address.
+Thus it marks a small part of the device as unclaimed by partitions and
+available for storing boot loader code.
+
+Nevertheless the USB stick is mountable via its overall device file as well as
+via the partition device file. E.g. on GNU/Linux: /dev/sdb and /dev/sdb1.
+This is achieved by two distinct sets of meta-data which refer to the same
+file content.
+
+The dual-mount feature supports Rock Ridge and Joliet too.
+It is capable of multi-session.
+
+Currently only offset 32 kB seems to make sense. Smaller offsets are prohibited
+by fundamental assumptions of libisofs and libisoburn. Larger offsets would
+extend the unclaimed area into vital blocks of the ISO image.
+
+--------------------------------------------------------------------------
+
+Meanwhile Debian
+[http://cdimage.debian.org/cdimage/daily-builds/daily/current/ daily]
+and [http://cdimage.debian.org/cdimage/weekly-builds/ weekly] builds make
+use of this feature with their bootable ISO images for i386 and amd64. E.g. 
+[http://cdimage.debian.org/cdimage/daily-builds/daily/current/i386/iso-cd/debian-testing-i386-businesscard.iso debian-testing-i386-businesscard.iso].
+
+According to a
+[http://syslinux.zytor.com/archives/2011-March/016201.html thread of march 2011]
+on Syslinux mailing list this enabled booting of a Kontron CG2100 server
+from USB stick, which otherwise failed.
+
+Regrettably the feature seems to prevent mounting of ISO 9660 images on
+Apple "Snow Leopard" systems.
+At least this is the outcome of a
+[http://lists.debian.org/debian-cd/2011/04/msg00029.html debian-cd thread of april 2011].
+
+--------------------------------------------------------------------------
+
+Example:
+
+Testing mountability and ISOLINUX bootability from USB stick and CD.
+
+Overview:
+
+The test image was derived from one year old RIPLinux-9.3-non-X.iso which
+has an isohybrid MBR. Syslinux version seems to be 3.82. That MBR and the file
+tree from the mounted RIPLinux image was used to build a new ISO image
+with 16 * 2kB partition offset. Isohybrid MBR patching was done by xorriso.
+
+Details:
+
+The first 32 kB of an ISO 9660 image are called System Area and may host any
+byte pattern. In the case of RIPLinux-9.3-non-X.iso only the first 512 bytes
+are non-zero. But to avoid any assumptions, all 32 kB get copied here.
+{{{
+  dd if=RIPLinux-9.3-non-X.iso bs=1K count=32 of=RIPLinux-9.3-non-X.sysarea
+}}}
+Normally the System Area file with its MBR is provided by the Syslinux
+installation under the name isohdp[fp]x*.bin .
+E.g. /usr/lib/syslinux/isohdpfx.bin
+
+The files of the image are made accessible for reading
+{{{
+  mount -o loop RIPLinux-9.3-non-X.iso /mnt
+}}}
+
+A new ISO image gets composed. The first three lines of arguments are taken
+from the prescriptions of ISOLINUX wiki and adapted to the names used in
+RIPLinux-9.3-non-X.iso.
+Option -isohybrid-mbr imports the copied System Area and patches the MBR
+according to rules published by hpa on Syslinux mailing list.
+Option -partition_offset 16 causes the first partition to start at 2 kB block
+number 16. It also prepares the image to be mountable by this partition, too.
+{{{
+  xorriso -as mkisofs \
+     -o new_image.iso \
+     -b boot/isolinux/isolinux.bin -c boot/boot.cat \
+     -no-emul-boot -boot-load-size 4 -boot-info-table \
+     -isohybrid-mbr RIPLinux-9.3-non-X.sysarea \
+     -partition_offset 16 \
+     /mnt
+}}}
+The image was copied onto a USB stick
+{{{
+  dd if=new_image.iso of=/dev/sdc
+}}}
+and plugged into a Debian system.
+{{{
+  fdisk -lu /dev/sdb
+}}}
+yields
+{{{
+   Device Boot      Start         End      Blocks   Id  System
+/dev/sdb1   *          64      120831       60384   17  Hidden HPFS/NTFS
+}}}
+
+I can mount /dev/sdb and /dev/sdb1 alike:
+{{{
+  mount /dev/sdb1 /mnt1
+  mount -o loop /dev/sdb /mnt
+}}}
+-o loop avoids failure with "mount: /dev/sdb already mounted or /mnt busy".
+A comparison by
+{{{
+  diff -r /mnt /mnt1
+}}}
+reports no difference.
+Human readable files look ok.
+Test-reading all content by
+{{{
+  tar cf - /mnt | wc
+}}}
+yields a reasonable byte count of 60743680 and no errors.
+
+The machine boots RIPLinux from this USB stick with no visible problems.
+It can then mount /dev/sdb as well as /dev/sdb1.
+The ISO image boots from CD too.
+
+Mounting the partition can be simulated with an image file on hard disk by
+cutting off the first partition_offset blocks of 2 KB:
+{{{
+  dd if=new_image.iso of=partition_image.iso bs=2048 skip=16
+  mount -o loop partition_image.iso /mnt1
+}}}
+
+--------------------------------------------------------------------------
+
+Another test was made with GRUB 2 by downloading
+{{{
+  bzr branch http://bzr.savannah.gnu.org/r/grub/trunk/grub
+}}}
+
+Before building GRUB 2, the file
+{{{
+  util/grub-mkrescue.in
+}}}
+was edited to replace in the options of the xorriso command:
+{{{
+  --protective-msdos-label
+}}}
+by
+{{{
+  -partition_offset 16 -no-pad
+}}}
+Then GRUB 2 was built and installed.
+
+The resulting image from
+{{{
+  ./grub-mkrescue -o image.iso
+}}}
+was put onto USB stick. It passed the same tests on Debian
+as above RIPLinux example. It boots to a GRUB prompt.
+
+Due to option -no-pad the image is about 250 kB smaller than
+the image produced by original grub-mkrescue. Else it would have grown by
+about 50 kB.
+
+Unpadded ISO images are safe except for burning on CD in TAO mode.
+In this case problems may occur with reading the last few data blocks.
+So when burning onto CD make sure to require SAO mode and/or to
+require padding by 300 kB.
+Burning on DVD or BD needs no such caution. Neither does copying
+on USB stick or hard disk.
+
+Program fdisk will complain about "different physical/logical" addresses.
+This can be silenced by adding option
+{{{
+ -partition_cyl_align on
+}}}
+at the cost of image padding up to the next full MB.
+E.g. by 402 kB to 2 MB.
+
+--------------------------------------------------------------------------
+
+Open questions:
+
+- Shall the partition of an isohybrid image be marked bootable ?
+Currently xorriso keeps the 0x80 mark of an imported MBR
+resp. the 0x80 mark which xorriso sets by its own MBR
+preparations.
+  - If not to be marked bootable:
+    What equipment would the partition need to justify having the mark ?
+
+------------------------------------------------------------------------
+
+Application:
+
+The partition offset feature can be controlled by libisofs API calls
+{{{
+int iso_write_opts_set_part_offset(IsoWriteOpts *opts,
+                                   uint32_t block_offset_2k,
+                                   int secs_512_per_head,
+                                   int heads_per_cyl);
+
+int iso_write_opts_set_system_area(IsoWriteOpts *opts, char data[32768],
+                                   int options, int flag);
+}}}
+resp. by libisoburn calls
+{{{
+int isoburn_igopt_set_part_offset(struct isoburn_imgen_opts  *opts,
+                                  uint32_t block_offset_2k,
+                                  int secs_512_per_head, int heads_per_cyl);
+
+int isoburn_igopt_get_part_offset(struct isoburn_imgen_opts *opts,
+                                  uint32_t *block_offset_2k,
+                                  int *secs_512_per_head, int *heads_per_cyl);
+
+int isoburn_igopt_set_system_area(struct isoburn_imgen_opts *o,
+                                  char data[32768], int options);
+
+int isoburn_igopt_get_system_area(struct isoburn_imgen_opts *o,
+                                  char data[32768], int *options);
+}}}
+resp. by xorriso options
+{{{
+  -boot_image any partition_offset=(2kb_block_adr)
+  -boot_image any partition_sec_hd=(number)
+  -boot_image any partition_hd_cyl=(number)
+  -boot_image any partition_cyl_align(on|auto|off)
+
+  -as mkisofs ... -partition_offset (2kb_block_adr) \
+                  -partition_hd_cyl (number) \
+                  -partition_sec_hd (number) \
+                  -partition_cyl_align (on|auto|off) ...
+}}}
+
+As stated above, an offset larger than 16 would expose vital parts of the
+ISO image as unclaimed space. Values smaller than 16 are not accepted.
+So use either an offset of 16 blocks or keep the feature disabled by
+offset 0.
+
--- a/doc/qemu_xorriso.wiki
+++ b/doc/qemu_xorriso.wiki
@ -0,0 +1,503 @@
+
+This text describes how to set up a qemu virtual machine so that xorriso
+on its guest GNU/Linux can operate a CD, DVD or BD recorder of the host
+system.
+
+The options follow proposals of Paolo Bonzini on qemu-devel mailing list.
+My compliments for his patient guidance.
+
+Basic knowledge about Debian and qemu was learned from
+[http://www.gnu.org/s/hurd/hurd/running/qemu.html GNU Hurd qemu page].
+
+----------------------------------------------------------------------
+This start command works with with qemu-1.0-rc3:
+
+{{{
+  $ qemu \
+    -enable-kvm \
+    -nographic \
+    -m 512 \
+    -net nic,model=ne2k_pci \
+    -net user,hostfwd=tcp::5557-:22 \
+    -hda /dvdbuffer/i386-install.qemu \
+    -drive file=/dev/sr2,if=none,id=scsicd,format=raw \
+    -device virtio-blk-pci,drive=scsicd,logical_block_size=2048,physical_block_size=2048 \
+    -cdrom .../some_image.iso
+}}}
+
+With this setup of -drive and -device it is necessary to have a
+medium in the drive, when qemu gets started. Else it will refuse.
+
+The guest system is accessible via ssh and scp at port 5557 of the
+host system.
+
+'''/dev/sr2''' is the address of the DVD drive which is handed over to the
+guest system.
+
+'''.../some_image.iso''' may be any readable file which shall serve as
+virtual DVD-ROM. qemu is not happy without such a thing.
+
+'''/dvdbuffer/i386-install.qemu''' is the disk image, where the guest operating
+system was installed by:
+{{{
+  $ qemu-img create /dvdbuffer/i386-install.qemu 8G
+  $ qemu \
+    -enable-kvm \
+    -m 512 \
+    -net nic,model=ne2k_pci \
+    -hda /dvdbuffer/i386-install.qemu \
+    -cdrom debian-6.0.3-i386-netinst.iso \
+    -boot d
+}}}
+
+Host system of my test is Debian GNU/Linux 6.0.2 amd64,
+which had access to the Internet when the guest was installed.
+
+----------------------------------------------------------------------
+
+Preparations on guest system Debian GNU/Linux 6.0.3 i386
+
+There appears no /dev/sr for the passthrough drive. Thus libburn will not
+list it by its drive search function. One may use it nevertheless. But
+xorriso will only do so if prefix "mmc:" is used with the address:
+{{{
+  -dev mmc:/dev/vda
+}}}
+The drive will be listed by libburn if there is a symbolic link /dev/sr*
+pointing to it. On Debian 6, this link persists only if it is created
+by an udev rule.
+
+In /lib/udev/rules.d/50-udev-default.rules:
+{{{
+    KERNEL=="vda", SYMLINK+="sr1"
+}}}
+
+libburn on Linux needs rw-permission for the drive's device node.
+The virtual device /dev/vda is in group "disk". Usual for CD drives is
+group "cdrom", to which i (or the Debian installer ?) have added my
+normal user when i installed the guest system.
+Like with the symbolic link, such a change persists on Debian 6 only as
+udev rule.
+
+In /lib/udev/rules.d/91-permissions.rules:
+{{{
+    KERNEL=="vda", GROUP="cdrom"
+}}}
+
+This should yield
+{{{
+  lrwxrwxrwx 1 root root       3 Nov  8 11:19 /dev/sr1 -> vda
+  brw-rw---- 1 root cdrom 254, 0 Nov  8 11:19 /dev/vda
+}}}
+
+xorriso version must be >= 1.1.8
+{{{
+  $ xorriso -version
+}}}
+tells the versions of its components on stdout:
+{{{
+  ...
+  xorriso version   :  1.1.8
+  ...
+}}}
+
+If your distro's xorriso is too old, consider to get and build GNU xorriso.
+{{{
+  http://ftpmirror.gnu.org/xorriso/xorriso-1.1.8.tar.gz
+}}}
+Do
+{{{
+  $ tar xzf xorriso-1.1.8.tar.gz
+  $ cd xorriso-1.1.8
+  $ ./configure && make
+}}}
+Either do as superuser
+{{{
+  # make install
+}}}
+or execute it where it was built as
+{{{
+  $ ./xorriso/xorriso ...arguments...
+}}}
+After compilation, this binary does not depend on files in the build
+directory. You may move it to any other location.
+
+For details about the following xorriso commands, read
+{{{
+  man xorriso
+  man ./xorriso/xorriso.1
+}}}
+or with the same content
+{{{
+  info xorriso
+  info ./xorriso/xorriso.info
+}}}
+Or read the [http://scdbackup.sourceforge.net/man_1_xorriso_devel.html online man page of xorriso].
+
+
+Note that the sequence of xorriso arguments matters. They are commands
+which get performed one after the other.
+This differs from the behavior of mkisofs, cdrecord, et.al.,
+which parse all arguments and then perform actions in a hardcoded
+sequence.
+
+Writing happens automatically if ISO filetree changes are pending
+at the end of the program run. This is like with other burn tools.
+(There is a command -commit for intermediate writing e.g. in dialog
+mode.)
+
+----------------------------------------------------------------------
+
+Listing accessible drives:
+{{{
+  $ xorriso -devices
+}}}
+shows on stdout:
+{{{
+  0  -dev '/dev/sr0' rwrw-- :  'QEMU    ' 'QEMU DVD-ROM' 
+  1  -dev '/dev/sr1' rwrw-- :  'Optiarc ' 'BD RW BD-5300S' 
+}}}
+
+----------------------------------------------------------------------
+
+The burn tests are presented here for unformatted DVD-RW media.
+The xorriso commands apply also to other types of optical media.
+See "Other applicable media types:" further below.
+
+----------------------------------------------------------------------
+
+Inspecting drive and medium:
+{{{
+  $ xorriso -outdev /dev/sr1 -toc
+}}}
+should show on stdout something like
+{{{
+  Drive current: -dev '/dev/sr1'
+  Drive type   : vendor 'Optiarc' product 'BD RW BD-5300S' revision '1.04'
+  Media current: DVD-RW sequential recording
+  Media product: RITEKW04 , Ritek Corp
+  Media status : is written , is closed
+  Media blocks : 306592 readable , 0 writable , 2298496 overall
+  TOC layout   : Idx ,  sbsector ,       Size , Volume Id
+  ISO session  :   1 ,         0 ,    106696s , ISOIMAGE
+  ISO session  :   2 ,    135536 ,    108385s , ISOIMAGE
+  ISO session  :   3 ,    250240 ,     56202s , ISOIMAGE
+  Media summary: 3 sessions, 271744 data blocks,  531m data,     0 free
+}}}
+
+----------------------------------------------------------------------
+
+Blanking to single session capability:
+
+This medium has to be blanked before further writing. For the DAO
+test, one can save time by fast blanking, which xorriso normally
+dislikes because the result is not capable of multi-session:
+{{{
+   $ xorriso -outdev /dev/sr1 -blank deformat_quickest
+}}}
+should report on stderr
+{{{
+   ...
+   xorriso : UPDATE : Blanking  ( 1.0% done in 2 seconds )
+   ...
+   xorriso : UPDATE : Blanking  ( 95.4% done in 36 seconds )
+   xorriso : UPDATE : Blanking  ( 99.0% done in 37 seconds )
+   ...
+   Media current: DVD-RW sequential recording
+   Media status : is blank
+   Media summary: 0 sessions, 0 data blocks, 0 data, 4489m free
+}}}
+Do not worry if the pacifier messages show no neat percentage progress.
+Some drives report "1.0%" until they are done. Some report "1.0%"
+after "99%".
+
+----------------------------------------------------------------------
+
+Writing a DAO session:
+
+Use one or more moderately sized directories as input. Here: /usr/bin.
+Terminate the list of -add arguments by argument "--".
+It is important to have command -close "on" among the arguments.
+{{{
+  $ xorriso -md5 on -outdev /dev/sr1 -close on -add /usr/bin --
+}}}
+should report on stderr
+{{{
+  ...
+  xorriso : UPDATE : 594 files added in 1 seconds
+  ...
+  xorriso : UPDATE : Thank you for being patient. Working since 2 seconds.
+  xorriso : UPDATE : Writing:       32s    0.1%   fifo 100%  buf   0%  0.1xD
+  ...
+  xorriso : UPDATE : Writing:     2704s    5.1%   fifo  11%  buf   0%  3.9xD
+  ...
+  xorriso : UPDATE : Writing:    20208s   38.2%   fifo  52%  buf  99%  4.0xD
+  ...
+  xorriso : UPDATE : Writing:    52885s  100.0%   fifo   0%  buf  99%  0.0xD
+  ISO image produced: 52735 sectors
+  Written to media  : 52885 sectors at LBA 0
+  Writing to '/dev/sr1' completed successfully.
+}}}
+Do not worry if there is no progress to see for a few dozen seconds
+at the beginning.
+The run will last at least as long as writing of 1 GB would need.
+If you write less data, then there will be a lot of zero progress
+messages at the end of writing.
+
+----------------------------------------------------------------------
+
+Checkreading the result:
+{{{
+  $ xorriso -md5 on -indev /dev/sr1 -check_md5_r sorry / --
+}}}
+The word "sorry" sets the severity class of the event message, which is
+emitted in case of MD5 mismatch. (See man xorriso, "Exception processing".)
+
+This should report on stderr
+{{{
+  ...
+  Drive current: -indev '/dev/sr1'
+  Media current: DVD-RW sequential recording
+  Media status : is written , is closed
+  Media summary: 1 session, 52885 data blocks,  103m data,     0 free
+  Volume id    : 'ISOIMAGE'
+  xorriso : UPDATE : 568079 content bytes read in 5 seconds
+  xorriso : UPDATE :  17074k content bytes read in 10 seconds
+  ...
+  xorriso : UPDATE :  103.7m content bytes read in 35 seconds
+  File contents and their MD5 checksums match.
+}}}
+and the exit value should be 0, if no mismatch was reported.
+
+A mismatch message would look like
+{{{
+  ...
+  MD5 MISMATCH: '/usr/bin/ncursesw5-config'
+  ...
+  Mismatch detected between file contents and MD5 checksums.
+  xorriso : SORRY : Event triggered by MD5 comparison mismatch
+  xorriso : NOTE : Tolerated problem event of severity 'SORRY'
+  xorriso : NOTE : -return_with SORRY 32 triggered by problem severity SORRY
+}}}
+and the exit value would be non-zero.
+
+----------------------------------------------------------------------
+
+Blanking to multi-session capability:
+{{{
+  $ xorriso -outdev /dev/sr1 -blank as_needed
+}}}
+This will need as long as writing the DVD-RW up to its end.
+Blanking option "as_needed" lets xorriso decide what to do in order
+to make the medium writable from scratch. With DVD-RW it will decide for
+-blank "all".
+
+The report on stderr should end by
+{{{
+  ...
+  xorriso : UPDATE : Blanking  ( 98.9% done in 902 seconds )
+  xorriso : UPDATE : Blanking  ( 99.0% done in 903 seconds )
+  xorriso : UPDATE : Blanking  ( 99.0% done in 904 seconds )
+  Blanking done
+  xorriso : NOTE : Re-assessing -outdev '/dev/sr1'
+  Drive current: -outdev '/dev/sr1'
+  Media current: DVD-RW sequential recording
+  Media status : is blank
+  Media summary: 0 sessions, 0 data blocks, 0 data, 4489m free
+}}}
+
+----------------------------------------------------------------------
+ 
+Writing multiple sessions (DVD-RW write type Incremental):
+
+This time do not perform command  -close "on", so that the medium
+stays writable:
+{{{
+  $ xorriso -md5 on -dev /dev/sr1 -add /usr/lib --
+  ...
+  xorriso : UPDATE : Writing:   105280s   98.6%   fifo   0%  buf  77%  3.5xD
+  xorriso : UPDATE : Writing:   106796s  100.0%   fifo   0%  buf  62%  2.2xD
+  xorriso : UPDATE : Closing track/session. Working since 44 seconds
+  ...
+  xorriso : UPDATE : Closing track/session. Working since 77 seconds
+  ISO image produced: 106646 sectors
+  Written to media  : 106800 sectors at LBA 0
+  Writing to '/dev/sr1' completed successfully.
+}}}
+Checkread like after the DAO test:
+{{{
+  $ xorriso -md5 on -indev /dev/sr1 -check_md5_r sorry / --
+  ...
+  xorriso : UPDATE :  204.0m content bytes read in 63 seconds
+  File contents and their MD5 checksums match.
+}}}
+Writing the second session looks like the first one. Just use another
+set of input files to get a visible change in the ISO 9660 file tree:
+{{{
+  $ xorriso -md5 on -dev /dev/sr1 -add /usr/bin --
+  ...
+  Written to media  : 53408 sectors at LBA 135488
+  Writing to '/dev/sr1' completed successfully.
+}}}
+And checkread the whole tree of files (i.e. both sessions):
+{{{
+  $ xorriso -md5 on -indev /dev/sr1 -check_md5_r sorry / --
+  ...
+  xorriso : UPDATE :  307.8m content bytes read in 89 seconds
+  File contents and their MD5 checksums match.
+}}}
+At the end of writing a final session, the medium can be closed.
+It will not take more writing unless it gets blanked or formatted.
+So use command -close "on" to demand closing after writing.
+{{{
+  $ xorriso -md5 on -dev /dev/sr1 -close on -add /usr/sbin --
+  ...
+  Written to media  : 16160 sectors at LBA 195056
+  Writing to '/dev/sr1' completed successfully.
+}}}
+Checkread
+{{{
+  $ xorriso -md5 on -indev /dev/sr1 -check_md5_r sorry / --
+  ...
+  Media current: DVD-RW sequential recording
+  Media status : is written , is closed
+  Media summary: 3 sessions, 176368 data blocks,  344m data, 4064m free
+  ...
+  xorriso : UPDATE :  337.7m content bytes read in 97 seconds
+  File contents and their MD5 checksums match.
+}}}
+
+-----------------------------------------------------------------------------
+
+If the drive tray can move by itself, you may now eject the medium:
+{{{
+  $ xorriso -outdev /dev/sr1 -eject all
+}}}
+
+-----------------------------------------------------------------------------
+
+Other applicable media types:
+
+These test runs for sequential DVD-RW may be performed on CD-RW with the
+same xorriso arguments. Be aware that /usr/lib will hardly fit on a CD.
+So choose smaller directories for CD.
+
+-blank "deformat_quickest" addresses a peculiarity of DVD-RW.
+It will work on other media like -blank "fast".
+
+Except the blanking runs, the tests may also be performed on BD-R, DVD-R,
+DVD+R, and CD-R. But you would waste two media by this.
+
+The first session on CD will always be written with write type SAO,
+further sessions will be written with TAO.
+
+CD-R and DVD-R have a simulation mode. It can be enabled by xorriso
+command -dummy "on", but of course it will not produce readable results.
+So this simulation is usable only for first sessions on blank media.
+
+-----------------------------------------------------------------------------
+
+Now for formatted overwritable media:
+
+All blank, write and check runs of above tests "Writing multiple sessions"
+may also be performed with DVD+RW, DVD-RAM, formatted DVD-RW, and BD-RE.
+There is no way to close formatted media. The command -close "on"
+gets silently ignored.
+
+The write methods and states of formatted media differ from those of
+sequential media. But xorriso presents to the user a unified
+multi-session usage model, under the assumption that all emulated
+sessions contain ISO 9660 filesystem images, which successively
+build on each other.
+
+So from the view of xorriso commands, the only task which makes
+them differ from sequential media, is to apply optional formatting
+or re-formatting.
+A special case are BD-R, which xorriso may format but will not bring
+into (pseudo-) overwritable state. Formatted BD-R perform Defect
+Management by default, which checkreads during writing and replaces
+bad block.
+
+The mandatory formatting of unused DVD+RW and BD-RE is done by xorriso
+automatically. Just start a normal write run. DVD-RAM are sold formatted.
+
+xorriso treats overwritable media with a valid ISO 9660 filesystem as
+appendable media. To make then writable from scratch, apply
+-blank "as_needed", which will actually write a few bytes into the PVD
+(superblock) of the ISO filesystem to invalidate it.
+
+De-formatting is only possible with DVD-RW. E.g. by -blank "deformat".
+
+-----------------------------------------------------------------------------
+
+Format DVD-RW for overwriting without intermediate blanking,
+or format BD-R for Defect Management:
+{{{
+  $ xorriso -outdev /dev/sr1 -format as_needed 
+}}}
+should report on stderr
+{{{
+  ...
+  xorriso : UPDATE : Formatting  ( 99.0% done in 912 seconds )
+  Formatting done
+  xorriso : NOTE : Re-assessing -outdev '/dev/sr1'
+  Drive current: -outdev '/dev/sr1'
+  Media current: DVD-RW restricted overwrite
+  Media status : is blank
+  Media summary: 0 sessions, 0 data blocks, 0 data, 4488m free
+}}}
+As with blanking, one should not worry if the progress messages show
+unplausible percentages. Some drives are more equal than others.
+
+Formatting is said to be much stress to the medium. -format option
+"as_needed" applies it only to yet unformatted media.
+
+When performing above write tests, take care to use -blank "as_needed"
+rather than -blank "deformat_quickest". Else you will get a sequential
+unformatted DVD-RW rather than a formatted DVD-RW which xorriso is
+willing to write from scratch.
+There is no use in a separate "DAO" test on overwritable media anyway.
+
+-----------------------------------------------------------------------------
+
+Change the formatted size of a BD-RE:
+
+First learn about formatted size and proposals of other sizes.
+(One can issue own wishes, too. See in man xorriso, command -format.)
+{{{
+  $ xorriso -outdev /dev/sr1 -list_formats
+}}}
+should tell on stdout
+{{{
+  ...
+  Format status: formatted, with 23610.0 MiB
+  BD Spare Area: 0 blocks consumed, 131072 blocks available
+  Format idx 0 : 00h , 11826176s , 23098.0 MiB
+  Format idx 1 : 01h , 11564032s , 22586.0 MiB
+  Format idx 2 : 30h , 11826176s , 23098.0 MiB
+  Format idx 3 : 30h , 11564032s , 22586.0 MiB
+  Format idx 4 : 30h , 12088320s , 23610.0 MiB
+  Format idx 5 : 31h , 12219392s , 23866.0 MiB
+}}}
+So lets go back from 23610.0 MiB to the default size of 23098.0 MiB
+{{{
+  $ xorriso -outdev /dev/sr1 -format by_index_2 -blank as_needed
+  ...
+  Media summary: 2 sessions, 105470 data blocks,  206m data, 22.4g free
+}}}
+Although the heads of the old sessions might remain readable after
+-format, better do not rely on this and a append -blank "as_needed" to
+avoid any data corruption.
+If you want to keep the data, then make at least a checkread run.
+
+Check whether the size has changed:
+{{{
+  $ xorriso -outdev /dev/sr1 -list_formats
+}}}
+should tell on stdout
+{{{
+  ...
+  Format status: formatted, with 23098.0 MiB
+  BD Spare Area: 0 blocks consumed, 393216 blocks available
+  ...
+}}}
--- a/doc/startup_file.txt
+++ b/doc/startup_file.txt
@ -0,0 +1,22 @@
+# This is an example for a xorriso startup file.
+# If found at one of the following addresses then its text lines will get
+# executed by xorriso as commands before any of its program arguments:
+#   /etc/default/xorriso
+#   /etc/opt/xorriso/rc
+#   /etc/xorriso/xorriso.conf
+#   $HOME/.xorrisorc
+# Note: Command -no_rc as first program argument prevents this execution.
+
+
+# Disallow the use of hard disk /dev/sda and its partitions as
+# pseudo-drive (e.g. as output target of an ISO image).
+
+-drive_class banned   /dev/sda*
+
+  
+# Allow the use of /dev/sdb, /dev/sdc, and /dev/sdd as pseudo-drives
+# without the prefix "stdio:" which is usually required for device addresses
+# which begin by "/dev/" but represent no CD drives.
+
+-drive_class harmless /dev/sd[bcd]
+
--- a/frontend/README-tcltk
+++ b/frontend/README-tcltk
@ -0,0 +1,127 @@
+------------------------------------------------------------------------------
+                                xorriso-tcltk
+------------------------------------------------------------------------------
+Copyright (C) 2012 - 2013
+Thomas Schmitt <scdbackup@gmx.net>, libburnia-project.org
+Provided under BSD license: Use, modify, and distribute as you like.
+------------------------------------------------------------------------------
+
+xorriso-tcltk is mainly a proof of concept for a frontend that operates
+xorriso in dialog mode.
+
+Dependencies:
+- xorriso ISO 9660 Rock Ridge filesystem manipulator and CD/DVD/BD burn program
+- Tcl programming language
+- Tk widget toolkit
+- optionally the Tcl/Tk package BWidget
+
+It exercises several fundamental gestures of communication:
+- connecting via two pipes
+- sending commands
+- receiving replies
+- inquiring the xorriso message sieve
+- using the xorriso parsing service
+
+Note that any other language than Tcl/Tk could be used, if it only can
+do i/o via standard input and standard output or via named pipes.
+Further it has to perform integer arithmetics and string manipulations.
+And, well, a graphical widget set would be nice.
+
+See man xorriso for a documentation of xorriso concepts and commands.
+See man xorrecord for details of the burn image file feature.
+
+
+                             Quick start
+
+In the xorriso build directory, without installation of xorriso:
+
+  xorriso/xorriso -launch_frontend frontend/xorriso-tcltk --stdio --
+
+After installation of xorriso by make install:
+
+  xorriso-tcltk
+
+
+                            Overview of GUI
+
+The window is separated into three main areas:
+- Connection to xorriso.
+- Management of drives and image files.
+- Inspection, manipulation, and exploitation of xorriso ISO image model.
+
+Click the rightmost mouse button while being over any of the GUI elements
+in order to get the particular help text for that element.
+There is no need to close the help window. Just click another element to
+get another help text.
+
+The "Help" button in the upper right corner gives a short overview and
+instructions for several common use cases.
+
+
+                         Program start options
+
+The Tcl shell "wish" is allergic to options which start by "-h".
+So here is the output of  xorriso-tcltk --help :
+------------------------------------------------------------------------
+
+Usage:
+  frontend/xorriso-tcltk [options]
+Options:
+ All options must be given with two dashes ("--option") in
+ order to distinguish them from any options of the Tcl shell.
+ --help
+     Print this text and exit.
+ --stdio
+     Establish connection to xorriso via stdin and stdout.
+     E.g. when letting xorriso start this frontend program:
+       xorriso -launch_frontend $(which xorriso-tcltk) --stdio --
+ --named_pipes cmd_fifo reply_fifo
+     Establish connection to a xorriso process started by:
+       xorriso -dialog on <cmd_fifo >reply_fifo
+     which is then ready for a run of:
+       xorriso-tcltk --named_pipes cmd_fifo reply_fifo
+     It is important that the parent of xorriso and of this
+     tcl/tk frontend opens the named pipe for commands before
+     it opens the named pipe for replies. This avoids deadlock.
+ --silent_start
+     Do not issue the start message xorriso-tcltk-version.
+     This works only if --silent_start is the first argument.
+ --no_extract
+     Do not allow extraction of files from ISO filesystem to
+     hard disk. This is not revokable during the program run.
+ --no_bwidget
+     Do not try to load the Tcl/Tk package BWidget which is
+     a prerequisite for the "/" file browser buttons.
+ --geometry {+|-}X{+|-}Y
+     Sets the position of the main window.
+ --click_to_focus
+     Chooses that input fields and list boxes get the keyboard
+     focus only when being clicked by the mouse. (Default)
+ --auto_focus
+     Chooses that the keyboard focus is where the mouse
+     pointer is.
+ --pipe_log_file path
+     Set a file address for logging of xorriso commands and
+     reply messages and enable this logging.
+     The log lines will be appended. Path "-" means stderr.
+ --script_log_file path
+     Set a file address for logging of essential xorriso
+     commands and enable this logging.
+     The log lines will be appended. Path "-" means stderr.
+ --script_log_all_commands
+     With logging of commands log non-essential commands too.
+ --use_command_move
+     Use xorriso command -move for the "Move to: button
+     if xorriso version is >= 1.2.8
+ --use_command_mv
+     Use xorriso command -mv for the "Move to:" button.
+
+If neither --stdio nor --named_pipes is given, then this script
+will try to locate itself in the filesystem and start a xorriso
+run that launches it again.
+
+In the running GUI, click with the rightmost mouse button on
+any GUI element to get its particular help text.
+
+------------------------------------------------------------------------
+
--- a/frontend/frontend_pipes_xorriso.c
+++ b/frontend/frontend_pipes_xorriso.c
@ -0,0 +1,980 @@
+
+/* Beefed-up example from man 2 pipe
+   to illustrate how xorriso is to be used by frontend programs via two pipes.
+   Additionally there is a standalone implementation of Xorriso_parse_line().
+
+   Copyright 2012 Thomas Schmitt, <scdbackup@gmx.net> 
+   Unaltered provided under BSD license.
+   You may issue licenses of your choice for derived code, provided that they
+   do not infringe anybody's right to do the same for this original code.
+
+   Build:
+     cc -g -o frontend_pipes_xorriso frontend_pipes_xorriso.c
+
+   Usage:
+     ./frontend_pipes_xorriso [path_to_xorriso_binary | -h]
+
+*/
+
+#include <sys/wait.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <ctype.h>
+
+
+static int usage()
+{
+    static char helptext[][80] = {
+"usage: frontend_pipes_xorriso [path_to_xorriso|-h]",
+"",
+"Forks a process that runs xorriso and communicates with it via two pipes.",
+"The command pipe sends payload commands and -mark commands. The reply pipe",
+"receives -pkt_output lines which it dispatches to stdout and stderr.",
+"The communication between both processes is made synchronous by the parent",
+"awaiting the -mark message of the child.",
+"Optionally the reply lines can be parsed into words. This is initiated by",
+"meta command",
+"  @parse [prefix [separators [max_words [flag]]]]",
+"which sets the four parameters for a function equivalent to",
+"Xorriso_parse_line() (see xorriso.h). All reply will then be parsed and",
+"non-empty word arrays are displayed. Meta command",
+"  @noparse",
+"ends this mode.",
+"Meta command",
+"  @drain_sieve",
+"reports all recorded results of all installed message sieve filter rules.",
+"For illustration perform this xorriso command sequence",
+"  -msg_op start_sieve - -outdev /dev/sr0 -msg_op clear_sieve - -toc",
+"and then @drain_sieve.", 
+"@END@"
+    };
+    int i;
+
+    for (i = 0; strcmp(helptext[i], "@END@") != 0; i++)
+        fprintf(stderr, "%s\n", helptext[i]);
+    return(1);
+}
+
+
+/* Local helpers of parent process */
+
+struct boss_state {
+    /* What the parent needs to know about its connection to xorriso */
+
+    /* The ends of the dialog pipes */
+    int command_fd;
+    int reply_fd;
+
+    /* For synchronization between boss and xorriso */
+    int mark_count;
+    char pending_mark[16];
+
+    /* Parsing_parameters. See xorriso.h Xorriso_parse_line */
+    int do_parse;
+    char progname[1024];
+    char prefix[1024];
+    char separators[256];
+    int max_words;
+    int flag;
+
+    /* A primitive catcher for result lines */
+    int reply_lines_size; /* 0= catching disabled */
+    char **reply_lines;
+    int reply_lines_count;
+};
+
+#define Frontend_xorriso_max_resulT 1000
+
+
+/* Some basic gestures of this program: */
+
+static int prompt_for_command(struct boss_state *boss,
+                              char *line, int line_size);
+
+static int transmit_command(struct boss_state *boss, char *line);
+
+static int await_all_replies(struct boss_state *boss);
+
+static int de_pkt_result(struct boss_state *boss);
+
+static int drain_sieve(struct boss_state *boss);
+
+int parse_line(char *progname, char *line,
+               char *prefix, char *separators, int max_words,
+               int *argc, char ***argv, int flag);
+
+int dispose_parsed_words(int *argc, char ***argv);
+
+
+
+/* Parent and child */
+int main(int argc, char *argv[])
+{
+    int command_pipe[2], reply_pipe[2];
+    pid_t cpid;
+    char *xorriso_path = "/usr/bin/xorriso";
+
+    if (argc > 1) {
+        if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "-help") == 0 ||
+            strcmp(argv[1], "--help") == 0) {
+            usage();
+            exit(0);
+        }
+        xorriso_path = argv[1];
+    }
+
+    if (pipe(command_pipe) == -1)
+        { perror("pipe"); exit(1); }
+    if (pipe(reply_pipe) == -1)
+        { perror("pipe"); exit(1); }
+
+    cpid = fork();
+    if (cpid == -1)
+        { perror("fork"); exit(2); }
+
+    if (cpid == 0) {
+        /* Child redirects stdin and stdout. Then it becomes xorriso. */
+
+        char *xargv[8];
+
+        close(command_pipe[1]);        /* Close unused write end */
+        close(reply_pipe[0]);          /* Close unused read end */
+
+        /* Attach pipe ends to stdin and stdout */
+        close(0);
+        if (dup2(command_pipe[0], 0) == -1)
+            { perror("dup2(,0)"); exit(1); }
+        close(1);
+        if (dup2(reply_pipe[1], 1) == -1)
+            { perror("dup2(,1)"); exit(1); }
+
+        xargv[0] = xorriso_path;
+        xargv[1] = "-dialog";
+        xargv[2] = "on";
+        xargv[3] = "-pkt_output";
+        xargv[4] = "on";
+        xargv[5] = "-mark";
+        xargv[6] = "0";       /* corresponds to mark_count = 0 in parent */
+        xargv[7] = NULL;
+        execv(xorriso_path, xargv);
+        perror("execv"); exit(1);
+
+    } else {
+        /* Parent prompts user for command lines and prints xorriso replies.
+           It knows when all reply text of the pending command line has arrived
+           by watching for -mark reply pending_mark. 
+        */
+
+        int ret;
+        char line[4096];
+        struct boss_state boss;
+
+        close(command_pipe[0]);        /* Close unused read end */
+        close(reply_pipe[1]);          /* Close unused write end */
+
+        memset(&boss, 0, sizeof(boss));
+        boss.command_fd = command_pipe[1];
+        boss.reply_fd = reply_pipe[0];
+        strcpy(boss.progname, argv[0]);
+        boss.reply_lines = NULL;
+
+        /* Dialog loop */
+        sprintf(boss.pending_mark, "%d", boss.mark_count);
+        while (1) {
+
+            /* Wait for pending mark and print all replies */
+            ret = await_all_replies(&boss);
+            if (ret < 0)
+        break;
+
+            /* Prompt for command line */
+            ret = prompt_for_command(&boss, line, sizeof(line));
+            if (ret <= 0)
+        break;
+
+            /* Send line and -mark command */
+            ret = transmit_command(&boss, line);
+            if (ret <= 0)
+        break;
+        }
+
+
+        /* >>> if child is still operational: send -rollback_end */;
+
+        /* >>> wait a short while */;
+
+        /* >>> if not yet ended: kill child  */;
+
+        wait(NULL);             /* Wait for child */
+        exit(0);
+    }
+}
+
+
+/* ------------------- Local helpers of parent process -------------------- */
+
+static int show_parsed(struct boss_state *boss, char *line);
+static int record_reply_line(struct boss_state *boss, char *line);
+static int make_reply_lines(struct boss_state *boss);
+static int input_interpreter(char *line, struct boss_state *boss);
+
+
+/* Ask the user for command input and trigger processing of meta commands.
+*/
+static int prompt_for_command(struct boss_state *boss,
+                              char *line, int line_size)
+{
+    int l, ret;
+    char *line_res;
+
+    while (1) {
+        fprintf(stderr, "+++ Enter a command and its parameters :\n");
+        line_res = fgets(line, line_size - 1, stdin);
+        if (line_res == NULL)
+            return(0);
+        l = strlen(line);
+        if (l == 0) {
+            line[0] = '\n';
+            line[1] = 0;
+        } else if (line[l - 1] != '\n') {
+            line[l] = '\n';
+            line[l + 1] = 0;
+        }
+        /* Interpret meta commands which begin by @ */
+        ret = input_interpreter(line, boss);
+        if (ret == 0)
+            return(1);
+        if (ret < 0)
+            return(-1);
+    }
+}
+
+
+/* Transmit a command (which must end by white space, e.g. newline)
+   and its unique synchronization mark.
+*/
+static int transmit_command(struct boss_state *boss, char *line)
+{
+    int ret;
+    char mark_line[32];
+
+    ret = write(boss->command_fd, line, strlen(line));
+    if (ret == -1) {
+        perror("write");
+        return(0);
+    }
+    /* Produce new unique -mark text to watch for */
+    (boss->mark_count)++;
+    sprintf(boss->pending_mark, "%d", boss->mark_count);
+    sprintf(mark_line, "-mark %s\n", boss->pending_mark);
+    ret = write(boss->command_fd, mark_line, strlen(mark_line));
+    if (ret == -1) {
+        perror("write");
+        return(0);
+    }
+    return(1);
+}
+
+
+/* Read reply messages from xorriso and wait for the expected synchronization
+   mark. Messages can be printed or collected in boss->reply_lines.
+*/
+static int await_all_replies(struct boss_state *boss)
+{
+    int count, remainder = 0, ret;
+    char buf[32769], *line, *npt;
+
+    while (1) {
+        count = read(boss->reply_fd, buf + remainder,
+                     sizeof(buf) - 1 - remainder);
+        if (count == -1) {
+            perror("read");
+            return(-1);
+        }
+        if (count == 0) {
+            fprintf(stderr, "+++ EOF encounterd by Master process\n");
+            return(-2);
+        }
+        for (npt = buf + remainder; npt < buf + count; npt++) {
+             if (*npt == 0) {
+                    fprintf(stderr,
+                            "+++ Protocol error : Reply contains 0-chars\n");
+                    return(-1);
+             }
+        }
+
+        /* Split buf into lines */
+        buf[remainder + count] = 0; /* for convenience */
+        line = buf;
+        while (1) {
+            npt = strchr(line, '\n');
+            if (npt == NULL) {
+                /* Move line to start of buffer and set remainder */
+                if (line != buf) {
+                    remainder = 0;
+                    for (npt = line; *npt; npt++)
+                         buf[remainder++] = *npt;
+                }
+                /* Now read more data in the hope to get a newline char */
+        break;
+            }
+            /* Interpret line */
+            *npt = 0;
+            if (line[0] == 'M') {
+                /* M-replies will be outdated until the pending command line
+                   is completely done and the appended -mark command gets
+                   into effect.
+                */
+                if (strlen(line) < 6) {
+                    fprintf(stderr,
+                 "+++ Protocol error : M-channel line shorter than 6 chars\n");
+                    return(-1);
+                }
+                if (strcmp(line + 5, boss->pending_mark) == 0) {
+                    if ((line - buf) + strlen(line) + 1 < count) {
+                        fprintf(stderr,
+                    "+++ Protocol error : Surplus reply data after M-match\n");
+                        fprintf(stderr, "%s\n", line + strlen(line) + 1);
+                        return(-1);
+                    }
+                    return (1); /* Expected mark has arrived */
+                }
+            } else if (line[0] == 'R') {
+                /* R-replies are result lines of inquiry commands, like -ls.
+                   They should be handled by specialized code which knows
+                   how to parse and interpret them.
+                */
+                if (boss->reply_lines_count < boss->reply_lines_size) {
+                    ret = record_reply_line(boss, line);
+                    if (ret <= 0)
+                        return(ret);
+                } else
+                    printf("%s\n", line);
+            } else {
+                /* I-replies are pacifiers, notifications, warnings, or
+                   error messages. They should be handled by a general
+                   message interpreter which determines their severity
+                   and decides whether to bother the user.
+                */
+                if (boss->reply_lines_count < boss->reply_lines_size) {
+                    ret = record_reply_line(boss, line);
+                    if (ret <= 0)
+                        return(ret);
+                } else
+                    fprintf(stderr, "%s\n", line);
+            }
+
+            /* Parse line and show words */
+            if (strlen(line) >= 5)
+                show_parsed(boss, line + 5);
+
+            line = npt + 1;
+        }
+    }
+    return(1);
+}
+
+
+/* Throw away I channel.
+   Unpack and reconstruct payload of R channel lines.
+*/
+static int de_pkt_result(struct boss_state *boss)
+{
+    int i, l, w;
+    char *payload = NULL, *new_payload = NULL;
+
+    w = 0;
+    for (i = 0; i < boss->reply_lines_count; i++) {
+        if (boss->reply_lines[i][0] != 'R' ||
+            strlen(boss->reply_lines[i]) < 5)
+    continue;
+
+        if (payload == NULL) {
+            payload = strdup(boss->reply_lines[i] + 5);
+        } else {
+            l = strlen(payload);
+            new_payload = calloc(l + strlen(boss->reply_lines[i] + 5) + 1, 1);
+            if (new_payload == NULL)
+                goto no_mem;
+            strcpy(new_payload, payload);
+            strcpy(new_payload + l, boss->reply_lines[i] + 5);
+            free(payload);
+            payload = new_payload;
+        }
+        if (payload == NULL)
+            goto no_mem;
+        l = strlen(payload);
+        if (l > 0)
+           if (payload[l - 1] == '\n')
+               payload[l - 1] = 0;
+
+        if (boss->reply_lines[i][2] != '0') {
+           free(boss->reply_lines[w]);
+           boss->reply_lines[w] = payload;
+           w++;
+           payload = NULL;
+        }
+    }
+    for (i = w ; i < boss->reply_lines_count; i++) {
+        free(boss->reply_lines[i]);
+        boss->reply_lines[i] = NULL;
+    }
+    boss->reply_lines_count = w;
+    return(1);
+no_mem:;
+    fprintf(stderr, "FATAL: Out of memory !\n");
+    return(-1);
+}
+
+
+/* Inquire and print all recorded message sieve results.
+*/
+static int drain_sieve(struct boss_state *boss)
+{
+    int ret, i, j, names_size = 0, names_count = 0, first_result;
+    int number_of_strings, available, xorriso_ret, number_of_lines, k, r;
+    char **names = NULL, line[1024];
+
+    /* Install catcher for reply_lines */
+    ret = make_reply_lines(boss);
+    if (ret <= 0)
+        goto ex;
+    boss->reply_lines_size = Frontend_xorriso_max_resulT;
+    boss->reply_lines_count = 0;
+
+    /* Get list of filter rule names from -msg_op show_sieve */
+    ret = transmit_command(boss, "-msg_op show_sieve -\n");
+    if (ret <= 0)
+        goto ex;
+    ret = await_all_replies(boss);
+    if (ret <= 0)
+        goto ex;
+    ret = de_pkt_result(boss);
+    if (ret <= 0)
+        goto ex;
+
+    names = boss->reply_lines;
+    boss->reply_lines = NULL;
+    names_size = Frontend_xorriso_max_resulT;
+    names_count= boss->reply_lines_count;
+    ret = make_reply_lines(boss);
+    if (ret <= 0)
+        goto ex;
+    boss->reply_lines_size = Frontend_xorriso_max_resulT;
+
+    /* Inquire caught results of each name by -msg_op read_sieve
+       until return value is <= 0
+    */
+    printf("--------------------------------------------------\n");
+    for (i = 0; i < names_count; i++) {
+        available = 1;
+        first_result = 1;
+        while (available > 0) {
+            boss->reply_lines_count = 0;
+            sprintf(line, "-msg_op read_sieve '%s'\n", names[i]);
+            ret = transmit_command(boss, line);
+            if (ret <= 0)
+                goto ex;
+            ret = await_all_replies(boss);
+            if (ret <= 0)
+                goto ex;
+            ret = de_pkt_result(boss);
+            if (ret <= 0)
+                goto ex;
+
+            if (boss->reply_lines_count < 2) {
+                fprintf(stderr, "drain_sieve: illegible result reply\n");
+                {ret= 0; goto ex;}
+            }
+            xorriso_ret = -1;
+            sscanf(boss->reply_lines[0], "%d", &xorriso_ret);
+            if(xorriso_ret <= 0)
+        break;
+            number_of_strings = -1;
+            sscanf(boss->reply_lines[1], "%d", &number_of_strings);
+            if(xorriso_ret < 0)
+        break;
+            if (first_result)
+                printf(" '%s' |\n", names[i]);
+            first_result = 0;
+            for (j = 0; names[i][j] != 0; j++)
+                printf("-");
+            printf("-----\n");
+            r = 2;
+            for (j = 0; j < number_of_strings && r < boss->reply_lines_count;
+                 j++) {
+                number_of_lines = -1;
+                sscanf(boss->reply_lines[r], "%d", &number_of_lines);
+                r++;
+                printf("|");
+                for (k = 0; k < number_of_lines
+                            && r < boss->reply_lines_count; k++) {
+                   printf("%s%s", boss->reply_lines[r],
+                                  k < number_of_lines - 1 ? "\n" : "");
+                   r++;
+                }
+                printf("|\n");
+            }
+        }
+        if (first_result == 0)
+            printf("--------------------------------------------------\n");
+    }
+
+    /* Dispose all recorded results */
+    ret = transmit_command(boss, "-msg_op clear_sieve -\n");
+    if (ret <= 0)
+        goto ex;
+    ret = await_all_replies(boss);
+    if (ret <= 0)
+        goto ex;
+
+    ret = 1;
+ex:;
+    /* Disable result catcher */
+    boss->reply_lines_size = 0;
+    if (names != NULL)
+        dispose_parsed_words(&names_size, &names);
+    return(ret);
+}
+
+
+/* ------------------------- Helpers of local helpers ---------------------- */
+
+
+static int show_parsed(struct boss_state *boss, char *line)
+{
+    int argc, ret = 0, i;
+    char **argv = NULL;
+
+    if (!boss->do_parse)
+        return(2);
+    ret = parse_line(boss->progname, line, boss->prefix, boss->separators,
+                     boss->max_words, &argc, &argv, boss->flag);
+    if (ret <= 0 || argc <= 0)
+        return(0);
+    fprintf(stderr, "-----------------------------------------------------\n");
+    fprintf(stderr, "parse_line returns %d, argc = %d\n", ret, argc);
+    for (i = 0; i < argc; i++)
+         fprintf(stderr, "%2d : %s\n", i, argv[i]);
+    fprintf(stderr, "-----------------------------------------------------\n");
+    dispose_parsed_words(&argc, &argv); /* release memory */
+    return(1);    
+}
+
+
+static int make_reply_lines(struct boss_state *boss)
+{
+    int i;
+
+    if (boss->reply_lines != NULL)
+        return(1);
+
+    boss->reply_lines = calloc(Frontend_xorriso_max_resulT,
+                                 sizeof(char *));
+    if (boss->reply_lines == 0) {
+        fprintf(stderr, "FATAL: Out of memory !\n");
+        return(-1);
+    }
+    boss->reply_lines_count = 0;
+    boss->reply_lines_size = 0;
+    for (i = 0; i < Frontend_xorriso_max_resulT; i++)
+        boss->reply_lines[i] = NULL;
+    return(1);
+}
+
+
+static int record_reply_line(struct boss_state *boss, char *line)
+{
+    if (boss->reply_lines[boss->reply_lines_count] != NULL)
+        free(boss->reply_lines[boss->reply_lines_count]);
+    boss->reply_lines[boss->reply_lines_count] = strdup(line);
+    if (boss->reply_lines[boss->reply_lines_count] == NULL) {
+        fprintf(stderr, "FATAL: Out of memory !\n");
+        return(-1);
+    }
+    boss->reply_lines_count++;
+    return(1);
+}
+
+
+static int input_interpreter(char *line, struct boss_state *boss)
+{
+    int argc, ret = 0;
+    char **argv = NULL;
+
+    ret = parse_line(boss->progname, line, "", "", 6, &argc, &argv, 0);
+    if (ret <= 0 || argc <= 0)
+        return(0);
+    if (strcmp(argv[0], "@parse") == 0) {
+        boss->do_parse = 1;
+        boss->prefix[0] = 0;
+        if (argc > 1)
+            strcpy(boss->prefix, argv[1]);
+        boss->separators[0] = 0;
+        if (argc > 2)
+            strcpy(boss->separators, argv[2]);
+        boss->max_words = 0;
+        if (argc > 3)
+            sscanf(argv[3], "%d", &(boss->max_words));
+        boss->max_words = 0;
+        if (argc > 4)
+            sscanf(argv[4], "%d", &(boss->flag));
+        ret = 1;
+    } else if(strcmp(argv[0], "@noparse") == 0) {
+        boss->do_parse = 0;
+        ret = 1;
+    } else if(strcmp(argv[0], "@drain_sieve") == 0) {
+        ret= drain_sieve(boss);
+    } else {
+        ret = 0;
+    }
+    dispose_parsed_words(&argc, &argv); /* release memory */
+    return ret;
+}
+
+
+/* -------- Line-to-word parser equivalent to Xorriso_parse_line() -------- */
+
+
+static int Sfile_sep_make_argv(char *progname, char *line, char *separators,
+                             int max_words, int *argc, char ***argv, int flag);
+
+
+int parse_line(char *progname, char *line,
+               char *prefix, char *separators, int max_words,
+               int *argc, char ***argv, int flag)
+{
+    int ret, bsl_mode;
+    char *to_parse;
+ 
+    *argc = 0;
+    *argv = NULL;
+ 
+    to_parse = line;
+    bsl_mode = (flag >> 1) & 15;
+    if (prefix[0]) {
+        if (strncmp(line, prefix, strlen(prefix)) == 0) {
+            to_parse = line + strlen(prefix);
+        } else {
+            ret = 2; goto ex;
+        }
+    }
+    ret = Sfile_sep_make_argv(progname, to_parse, separators,
+                              max_words, argc, argv,
+                              (!(flag & 32)) | 4 | (bsl_mode << 5));
+    if (ret < 0) {
+        fprintf(stderr,
+                "%s : Severe lack of resources during command line parsing\n",
+                progname);
+        goto ex;
+    }
+    if (ret == 0) {
+        fprintf(stderr,
+                "%s : Incomplete quotation in %s line: %s\n",
+                progname, (flag & 32) ? "command" : "parsed", to_parse);
+        goto ex;
+    }
+ex:;
+    if (ret <= 0)
+        Sfile_sep_make_argv("", "", "", 0, argc, argv, 2); /* release memory */
+    return(ret);
+}
+
+
+int dispose_parsed_words(int *argc, char ***argv)
+{
+    Sfile_sep_make_argv("", "", "", 0, argc, argv, 2);
+    return(1);
+}
+
+
+/* -------------- Some helpers copied from xorriso/sfile.c ----------------- */
+
+
+static int Sfile_destroy_argv(int *argc, char ***argv, int flag)
+{
+ int i;
+
+ if(*argc>0 && *argv!=NULL){
+   for(i=0;i<*argc;i++){
+     if((*argv)[i]!=NULL)
+       free((*argv)[i]);
+   }
+   free((char *) *argv);
+ }
+ *argc= 0;
+ *argv= NULL;
+ return(1);
+}
+
+
+/* Converts backslash codes into single characters:
+    \a BEL 7 , \b BS 8 , \e ESC 27 , \f FF 12 , \n LF 10 , \r CR 13 ,
+    \t  HT 9 , \v VT 11 , \\ \ 92 
+    \[0-9][0-9][0-9] octal code , \x[0-9a-f][0-9a-f] hex code ,
+    \cX control-x (ascii(X)-64)
+   @param upto  maximum number of characters to examine for backslash.
+                The scope of a backslash (0 to 3 characters) is not affected.
+   @param eaten returns the difference in length between input and output
+   @param flag bit0= only determine *eaten, do not convert
+               bit1= allow to convert \000 to binary 0 
+*/
+static int Sfile_bsl_interpreter(char *text, int upto, int *eaten, int flag)
+{
+ char *rpt, *wpt, num_text[8], wdummy[8];
+ unsigned int num= 0;
+
+ *eaten= 0;
+ wpt= text;
+ for(rpt= text; *rpt != 0 && rpt - text < upto; rpt++) {
+   if(flag & 1)
+     wpt= wdummy;
+   if(*rpt == '\\') {
+     rpt++;
+     (*eaten)++;
+     if(*rpt == 'a') {
+       *(wpt++)= 7;
+     } else if(*rpt == 'b') {
+       *(wpt++)= 8;
+     } else if(*rpt == 'e') {
+       *(wpt++)= 27;
+     } else if(*rpt == 'f') {
+       *(wpt++)= 12;
+     } else if(*rpt == 'n') {
+       *(wpt++)= 10;
+     } else if(*rpt == 'r') {
+       *(wpt++)= 13;
+     } else if(*rpt == 't') {
+       *(wpt++)= 9;
+     } else if(*rpt == 'v') {
+       *(wpt++)= 11;
+     } else if(*rpt == '\\') {
+       *(wpt++)= '\\';
+     } else if(rpt[0] >= '0' && rpt[0] <= '7' &&
+               rpt[1] >= '0' && rpt[1] <= '7' &&
+               rpt[2] >= '0' && rpt[2] <= '7') {
+       num_text[0]= '0';
+       num_text[1]= *(rpt + 0);
+       num_text[2]= *(rpt + 1);
+       num_text[3]= *(rpt + 2);
+       num_text[4]= 0;
+       sscanf(num_text, "%o", &num);
+       if((num > 0 || (flag & 2)) && num <= 255) {
+         rpt+= 2;
+         (*eaten)+= 2;
+         *(wpt++)= num;
+       } else
+         goto not_a_code;
+     } else if(rpt[0] == 'x' &&
+               ((rpt[1] >= '0' && rpt[1] <= '9') ||
+                (rpt[1] >= 'A' && rpt[1] <= 'F') ||
+                (rpt[1] >= 'a' && rpt[1] <= 'f'))
+               &&
+               ((rpt[2] >= '0' && rpt[2] <= '9') ||
+                (rpt[2] >= 'A' && rpt[2] <= 'F') ||
+                (rpt[2] >= 'a' && rpt[2] <= 'f'))
+               ) {
+       num_text[0]= *(rpt + 1);
+       num_text[1]= *(rpt + 2);
+       num_text[2]= 0;
+       sscanf(num_text, "%x", &num);
+       if(num > 0 && num <= 255) {
+         rpt+= 2;
+         (*eaten)+= 2;
+         *(wpt++)= num;
+       } else
+         goto not_a_code;
+     } else if(*rpt == 'c') {
+       if(rpt[1] > 64 && rpt[1] < 96) {
+         *(wpt++)= rpt[1] - 64;
+         rpt++;
+         (*eaten)++;
+       } else
+         goto not_a_code;
+     } else {
+not_a_code:;
+       *(wpt++)= '\\';
+       rpt--;
+       (*eaten)--;
+     }
+   } else
+     *(wpt++)= *rpt;
+ }
+ *wpt= *rpt;
+ return(1);
+}
+
+
+#define SfileadrL 4096
+
+static int Sfile_sep_make_argv(char *progname, char *line, char *separators,
+                              int max_words, int *argc, char ***argv, int flag)
+/*
+ bit0= read progname as first argument from line
+ bit1= just release argument list argv and return
+ bit2= abort with return(0) if incomplete quotes are found
+ bit3= eventually prepend missing '-' to first argument read from line
+ bit4= like bit2 but only check quote completeness, do not allocate memory
+ bit5+6= interpretation of backslashes:
+       0= no interpretation, leave unchanged
+       1= only inside double quotes
+       2= outside single quotes
+       3= everywhere
+ bit7= append a NULL element to argv
+*/
+{
+ int i,pass,maxl=0,l,argzaehl=0,bufl,line_start_argc, bsl_mode, ret= 0, eaten;
+ char *cpt,*start;
+ char *buf= NULL;
+
+ Sfile_destroy_argv(argc,argv,0);
+ if(flag&2)
+   {ret= 1; goto ex;}
+
+ if(flag & 16)
+   flag|= 4;
+ bsl_mode= (flag >> 5) & 3;
+
+ buf= calloc(strlen(line) + SfileadrL, 1);
+ if(buf == NULL)
+   {ret= -1; goto ex;}
+ for(pass=0;pass<2;pass++) {
+   cpt= line-1;
+   if(!(flag&1)){
+     argzaehl= line_start_argc= 1;
+     if(pass==0)
+       maxl= strlen(progname);
+     else
+       strcpy((*argv)[0],progname);
+   } else {
+     argzaehl= line_start_argc= 0;
+     if(pass==0) maxl= 0;
+   }
+   while(*(++cpt)!=0){
+     if(*separators) {
+       if(strchr(separators, *cpt) != NULL)
+   continue;
+     } else if(isspace(*cpt))
+   continue;
+     start= cpt;
+     buf[0]= 0;
+     cpt--;
+
+     if(max_words > 0 && argzaehl >= max_words && *cpt != 0) {
+       /* take uninterpreted up to the end */
+       cpt+= strlen(cpt) - 1;
+     }
+
+     while(*(++cpt)!=0) {
+       if(*separators) {
+         if(strchr(separators, *cpt) != NULL)
+     break;
+       } else if(isspace(*cpt))
+     break;
+       if(*cpt=='"'){
+         l= cpt-start; bufl= strlen(buf);
+         if(l>0) {
+           strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
+           if(bsl_mode >= 3) {
+             ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
+             if(ret <= 0)
+               goto ex;
+           }
+         }
+         l= strlen(buf);
+         start= cpt+1;
+         while(*(++cpt)!=0) if(*cpt=='"') break;
+         if((flag&4) && *cpt==0)
+           {ret= 0; goto ex;}
+         l= cpt-start; bufl= strlen(buf);
+         if(l>0) {
+           strncpy(buf + bufl, start, l);
+           buf[bufl + l]= 0;
+           if(bsl_mode >= 1) {
+             ret= Sfile_bsl_interpreter(buf + bufl, l, &eaten, 0);
+             if(ret <= 0)
+               goto ex;
+           }
+         }
+         start= cpt+1;
+       }else if(*cpt=='\''){
+         l= cpt-start; bufl= strlen(buf);
+         if(l>0) {
+           strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
+           if(bsl_mode >= 3) {
+             ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
+             if(ret <= 0)
+               goto ex;
+           }
+         }
+         l= strlen(buf);
+         start= cpt+1;
+         while(*(++cpt)!=0) if(*cpt=='\'') break;
+         if((flag&4) && *cpt==0)
+           {ret= 0; goto ex;}
+         l= cpt-start; bufl= strlen(buf);
+         if(l>0) {
+           strncat(buf,start,l);buf[bufl+l]= 0;
+           if(bsl_mode >= 2) {
+             ret= Sfile_bsl_interpreter(buf + bufl, l, &eaten, 0);
+             if(ret <= 0)
+               goto ex;
+           }
+         }
+         start= cpt+1;
+       }
+     if(*cpt==0) break;
+     }
+     l= cpt-start;
+     bufl= strlen(buf);
+     if(l>0) {
+       strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
+       if(bsl_mode >= 3) {
+         ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
+         if(ret <= 0)
+           goto ex;
+       }
+     }
+     l= strlen(buf);
+     if(pass==0){
+       if(argzaehl==line_start_argc && (flag&8))
+         if(buf[0]!='-' && buf[0]!=0 && buf[0]!='#')
+           l++;
+       if(l>maxl) maxl= l;
+     }else{
+       strcpy((*argv)[argzaehl],buf);
+       if(argzaehl==line_start_argc && (flag&8))
+         if(buf[0]!='-' && buf[0]!=0 && buf[0]!='#')
+           sprintf((*argv)[argzaehl],"-%s", buf);
+     }
+     argzaehl++;
+   if(*cpt==0) break;
+   }
+   if(pass==0){
+     if(flag & 16)
+       {ret= 1; goto ex;}
+     *argc= argzaehl;
+     if(argzaehl>0 || (flag & 128)) {
+       *argv= (char **) calloc((argzaehl + !!(flag & 128)), sizeof(char *));
+       if(*argv==NULL)
+         {ret= -1; goto ex;}
+     }
+     for(i=0;i<*argc;i++) {
+       (*argv)[i]= (char *) calloc(maxl + 1, 1);
+       if((*argv)[i]==NULL)
+         {ret= -1; goto ex;}
+     }
+     if(flag & 128)
+       (*argv)[*argc]= NULL;
+   }
+ }
+ ret= 1;
+ex:
+ if(buf != NULL)
+   free(buf);
+ return(ret);
+}
+
--- a/frontend/xorriso-tcltk
+++ b/frontend/xorriso-tcltk
--- a/libisoburn/burn_wrap.c
+++ b/libisoburn/burn_wrap.c
@ -6,10 +6,14 @@
 */
 /* libburn wrappers for libisoburn 

-   Copyright 2007 - 2010  Thomas Schmitt, <scdbackup@gmx.net> 
+   Copyright 2007 - 2011  Thomas Schmitt, <scdbackup@gmx.net> 
   Provided under GPL version 2 or later.
 */

+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 /* <<< A70929 : hardcoded CD-RW with fabricated -msinfo 
 #define Hardcoded_cd_rW 1
 #define Hardcoded_cd_rw_c1     12999
@ -27,17 +31,21 @@
 #include <time.h>
 #include <regex.h>

-
 #ifndef Xorriso_standalonE

 #include <libburn/libburn.h>
-
 #include <libisofs/libisofs.h>
+#ifdef Xorriso_with_libjtE
+#include <libjte/libjte.h>
+#endif

 #else /* ! Xorriso_standalonE */

 #include "../libisofs/libisofs.h"
 #include "../libburn/libburn.h"
+#ifdef Xorriso_with_libjtE
+#include "../libjte/libjte.h"
+#endif

 #endif /* Xorriso_standalonE */

@ -65,10 +73,10 @@ static int isoburn_emulate_toc(struct burn_drive *d, int flag);

 int isoburn_initialize(char msg[1024], int flag)
 {
- int major, minor, micro, bad_match= 0;
+ int major, minor, micro, bad_match= 0, no_iso_init= 0;


-/* First two ugly compile time checks for header version compatibility.
+/* First the ugly compile time checks for header version compatibility.
   If everthing matches, then they produce no C code. In case of mismatch,
   intentionally faulty C code will be inserted.
 */
@ -104,7 +112,7 @@ int isoburn_initialize(char msg[1024], int flag)

 #ifdef Isoburn_libisofs_dot_h_too_olD
 LIBISOFS_MISCONFIGURATION = 0;
-INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisofs_dot_h_TOO_OLD__SEE_libisoburn_dot_h_AND_burn_wrap_dot_h = 0;
+INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisofs_dot_h_TOO_OLD__SEE_libisoburn_dot_h_AND_burn_wrap_dot_c = 0;
 LIBISOFS_MISCONFIGURATION_ = 0;
 #endif

@ -145,14 +153,62 @@ INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libburn_dot_h_TOO_OLD__SEE_libisobu
 LIBBURN_MISCONFIGURATION_ = 0;
 #endif

+
+#ifdef Xorriso_with_libjtE
+
+/* The minimum requirement of libisoburn towards the libjte header
+   at compile time is the same as the one of a usable libisofs towards libjte.
+   So the requirement is defined in libisofs/libisofs.h :
+     iso_libjte_req_major , iso_libjte_req_minor , iso_libjte_req_micro
+*/
+ /* The indendation is an advise of man gcc to help old compilers ignoring */
+ #if iso_libjte_req_major > LIBJTE_VERSION_MAJOR
+ #define Libisofs_libjte_dot_h_too_olD 1
+ #endif
+ #if iso_libjte_req_major == LIBJTE_VERSION_MAJOR && iso_libjte_req_minor > LIBJTE_VERSION_MINOR
+ #define Libisofs_libjte_dot_h_too_olD 1
+ #endif
+ #if iso_libjte_req_minor == LIBJTE_VERSION_MINOR && iso_libjte_req_micro > LIBJTE_VERSION_MICRO
+ #define Libisofs_libjte_dot_h_too_olD 1
+ #endif
+
+#ifdef Libisofs_libjte_dot_h_too_olD
+LIBJTE_MISCONFIGURATION = 0;
+INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libjte_dot_h_TOO_OLD__SEE_libisofs_dot_h_AND_burn_wrap.c_c = 0;
+LIBJTE_MISCONFIGURATION_ = 0;
+#endif
+
+#endif /* Xorriso_with_libjtE */
+
+
 /* End of ugly compile time tests (scroll up for explanation) */


-
 msg[0]= 0;
- if(iso_init()<0) {
-   sprintf(msg+strlen(msg), "Cannot initialize libisofs\n");
-   return(0);
+
+#ifdef Xorriso_with_libjtE
+
+ libjte__version(&major, &minor, &micro);
+ sprintf(msg + strlen(msg), "libjte-%d.%d.%d ", major, minor, micro);
+ if (libjte__is_compatible(LIBJTE_VERSION_MAJOR, LIBJTE_VERSION_MINOR,
+                                LIBJTE_VERSION_MICRO, 0)) {
+   sprintf(msg+strlen(msg), "ok, ");
+ } else {
+   sprintf(msg + strlen(msg),
+           "- TOO OLD -, need at least libjte-%d.%d.%d ,\n",
+           LIBJTE_VERSION_MAJOR, LIBJTE_VERSION_MINOR,
+           LIBJTE_VERSION_MICRO);
+   bad_match= 1;
+   no_iso_init= 1; /* iso_init() will fail anyway */
+ }
+
+#endif /* Xorriso_with_libjtE */
+
+ if(!no_iso_init) {
+   if(iso_init()<0) {
+     sprintf(msg+strlen(msg), "Cannot initialize libisofs\n");
+     return(0);
+   }
 }
 iso_lib_version(&major, &minor, &micro);
 sprintf(msg+strlen(msg), "libisofs-%d.%d.%d ", major, minor, micro);
@ -184,6 +240,7 @@ LIBBURN_MISCONFIGURATION_ = 0;
   sprintf(msg+strlen(msg), "Cannot initialize libburn\n");
   return(0);
 }
+
 burn_version(&major, &minor, &micro);
 sprintf(msg+strlen(msg), "libburn-%d.%d.%d ", major, minor, micro);
 if(major > burn_header_version_major
@ -229,6 +286,20 @@ int isoburn_libburn_req(int *major, int *minor, int *micro)
 }


+/* API @since 0.6.4 */
+int isoburn_libjte_req(int *major, int *minor, int *micro)
+{
+#ifdef Xorriso_with_libjtE
+ *major= LIBJTE_VERSION_MAJOR;
+ *minor= LIBJTE_VERSION_MINOR;
+ *micro= LIBJTE_VERSION_MICRO;
+#else
+ *major= *minor= *micro= 0;
+#endif /* ! Xorriso_with_libjtE */
+ return(1);
+}
+
+
 int isoburn_set_msgs_submit(int (*msgs_submit)(void *handle, int error_code,
                                               char msg_text[], int os_errno,
                                               char severity[], int flag),
@ -261,7 +332,7 @@ int isoburn_is_intermediate_dvd_rw(struct burn_drive *d, int flag)
 }


-/** Examines the media and sets appropriate emulation if needed.
+/** Examines the medium and sets appropriate emulation if needed.
    @param flag bit0= pretent blank on overwriteable media
                bit3= if the drive reports a -ROM profile then try to read 
                      table of content by scanning for ISO image headers.
@ -269,11 +340,15 @@ int isoburn_is_intermediate_dvd_rw(struct burn_drive *d, int flag)
                bit5= ignore ACL from external filesystems
                bit6= ignore POSIX Extended Attributes from external filesystems
                bit7= pretend -ROM and scan for table of content
+                bit9= when scanning for ISO 9660 sessions on overwritable
+                      media: Do not demand a valid superblock at LBA 0
+                      and scan until end of medium.
 */ 
 static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
                                 int flag)
 {
- int ret, lba, nwa, profile, readonly= 0;
+ int ret, profile, readonly= 0, role, random_access;
+ int emulation_started= 0;
 struct burn_multi_caps *caps= NULL;
 struct isoburn_toc_entry *t;
 char profile_name[80];
@ -284,13 +359,17 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
 char msg[80];
 enum burn_disc_status s;

+#ifndef Hardcoded_cd_rW
+ int lba, nwa;
+#endif
+
 s= burn_disc_get_status(d);
 profile_name[0]= 0;
 ret= burn_disc_get_profile(d, &profile, profile_name);
 if(ret<=0)
   profile= 0x00;
 ret= burn_disc_get_multi_caps(d, BURN_WRITE_NONE, &caps, 0);
- if(ret<0) /* == 0 is read-only media, but it is too early to reject it here */
+ if(ret<0) /*== 0 is read-only medium, but it is too early to reject it here */
   goto ex;
 if(ret==0 || (flag & 128))
   readonly= 1;
@ -312,16 +391,18 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
 (*o)->fabricated_disc_status= BURN_DISC_APPENDABLE;
 #endif

- if(caps->start_adr)
+ role= burn_drive_get_drive_role(d);
+ random_access= caps->start_adr || role == 4;
+ if(random_access)
   (*o)->emulation_mode= 1;
- if(caps->start_adr && !readonly) {       /* set emulation to overwriteable */
+ if(random_access && !readonly) {       /* set emulation to overwriteable */
   ret= isoburn_is_intermediate_dvd_rw(d, 0);
   if(ret>0) {
     (*o)->min_start_byte= 0;
     (*o)->nwa= 0;
     (*o)->zero_nwa= 0;
   }
-   if(flag&1) {
+   if((flag & 1) && role != 4 && role != 5) {
     (*o)->nwa= (*o)->zero_nwa;
     (*o)->fabricated_disc_status= BURN_DISC_BLANK;
   } else {
@ -330,8 +411,9 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
       (*o)->emulation_mode= -1;
       goto ex;
     }
+     emulation_started= 1;
     /* try to read emulated toc */
-     ret= isoburn_emulate_toc(d, flag & 16);
+     ret= isoburn_emulate_toc(d, (flag & 16) | ((!!(flag & 512)) << 1));
     if(ret<0) {
       (*o)->emulation_mode= -1;
       goto ex;
@ -342,14 +424,20 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
    /* >>> recognize unsuitable media (but allow read-only media) */;

   if(readonly && s != BURN_DISC_EMPTY) {
+
+     /* >>> ts B10712: This maps BURN_DISC_UNSUITABLE to BURN_DISC_FULL
+                       which can hardly be correct in general.
+        ??? What reason does this have ?
+     */
     (*o)->fabricated_disc_status= BURN_DISC_FULL;
-     /* This might be overwriteable media in a -ROM drive.
+
+     /* This might be an overwriteable medium in a -ROM drive.
        Pitfall:
        Multi-session media which bear a xorriso image for overwriteables
        in their first session would get a TOC of that first image rather
-        than of the media.
+        than of the medium.
        It is not possible to distinguish a BD-RE from a single session
-        BD-R with an image for overwriteables. But as soon as the media
+        BD-R with an image for overwriteables. But as soon as the medium
        bears 2 logical tracks it cannot be overwriteable.
        So count the number of tracks first.
     */
@ -359,18 +447,25 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
       for(session_no= 0; session_no < num_sessions; session_no++) {
         tracks= isoburn_toc_session_get_tracks(sessions[session_no],
                                                &num_tracks);
-         track_count+= num_tracks;
+         if(tracks != NULL)
+           track_count+= num_tracks;
       }
       isoburn_toc_disc_free(disc);
     }

-     sprintf(msg, "ROM media has libburn track count = %d", track_count);
+     sprintf(msg, "ROM medium has libburn track count = %d", track_count);
     isoburn_msgs_submit(*o, 0x00060000, msg, 0, "DEBUG", 0);

     if((flag & 16) || track_count >= 2) {
       ret= 0; /* toc emulation off, or not overwriteable */
     } else {
-       ret= isoburn_emulate_toc(d, 1);
+       ret= isoburn_start_emulation(*o, 1);
+       if(ret<=0) {
+         (*o)->emulation_mode= -1;
+         goto ex;
+       }
+       emulation_started= 1;
+       ret= isoburn_emulate_toc(d, 1 | ((!!(flag & 512)) << 1));
       if(ret<0)
         goto ex;
       else if(ret > 0)
@ -382,7 +477,14 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
          CD-R TOC (profile 0x08) can be trusted. Others not.
          Do a scan search of ISO headers.
       */
-       ret= isoburn_emulate_toc(d, 1|2);
+       if(!emulation_started) {
+         ret= isoburn_start_emulation(*o, 1);
+         if(ret<=0) {
+           (*o)->emulation_mode= -1;
+           goto ex;
+         }
+       }
+       ret= isoburn_emulate_toc(d, 1 | 2);
       if(ret<0)
         goto ex;
       if(ret>0) { /* point msc1 to last session */
@ -399,6 +501,8 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
   ret= burn_disc_track_lba_nwa(d, NULL, 0, &lba, &nwa);
   if(ret>0)
     (*o)->nwa= nwa;
+   if((*o)->nwa < (*o)->zero_nwa)
+     (*o)->zero_nwa= 0;
 #endif

 }
@ -424,37 +528,37 @@ ex:
                bit5= ignore ACL from external filesystems
                bit6= ignore POSIX Extended Attributes from external filesystems
                bit7= pretend -ROM profile and scan for table of content
+                bit8= re-assess (*drive_infos)[0] rather than aquiring adr
+                bit9= when scanning for ISO 9660 sessions on overwritable
+                      media: Do not demand a valid superblock at LBA 0
+                      and scan until end of medium.
 */
 int isoburn_drive_aquire(struct burn_drive_info *drive_infos[],
                         char *adr, int flag)
 {
 int ret, drive_grabbed= 0;
 struct isoburn *o= NULL;
-
-#ifndef NIX
-
-/* <<< should be obsolete by new drive addressing of libburn-0.5.2 */
-/* >>> but helps with kernel 2.4 to use /dev/sr */
-
 int conv_ret;
- char libburn_drive_adr[BURN_DRIVE_ADR_LEN];
+ char *libburn_drive_adr= NULL;

+ /* Should be obsolete by new drive addressing of libburn-0.5.2 */
+ /* but helps with kernel 2.4 to use /dev/sr */
+ libburn_drive_adr= calloc(1, BURN_DRIVE_ADR_LEN);
+ if(libburn_drive_adr == NULL)
+   {ret= -1; goto ex;}
 conv_ret= burn_drive_convert_fs_adr(adr, libburn_drive_adr);
 if(conv_ret<=0)
   strcpy(libburn_drive_adr, adr);
- ret= burn_drive_scan_and_grab(drive_infos, libburn_drive_adr, flag&1);
-
-#else
-
- ret= burn_drive_scan_and_grab(drive_infos, adr, flag & 1);
-
-#endif /* ! NIX */

+ if(flag & 256)
+   ret= burn_drive_re_assess((*drive_infos)[0].drive, 0);
+ else
+   ret= burn_drive_scan_and_grab(drive_infos, libburn_drive_adr, flag&1);
 if(ret<=0)
   goto ex;
 drive_grabbed= 1;
 ret= isoburn_welcome_media(&o, (*drive_infos)[0].drive,
-                            (flag & (8 | 16 | 32 | 64 | 128)) | !!(flag&2));
+                         (flag & (8 | 16 | 32 | 64 | 128 | 512)) | !!(flag&2));
 if(ret<=0)
   goto ex;

@ -471,6 +575,8 @@ ex:
     burn_drive_release((*drive_infos)[0].drive, 0);
   isoburn_destroy(&o, 0);
 }
+ if(libburn_drive_adr != NULL)
+   free(libburn_drive_adr);
 return(ret);
 }

@ -505,8 +611,8 @@ ex:
 }


-/** Retrieve media emulation and eventual isoburn emulator of drive.
-    @return -1 unsuitable media, 0 generic media, 1 emulated media.
+/** Retrieve medium emulation and eventual isoburn emulator of drive.
+    @return -1 unsuitable medium, 0 generic medium, 1 emulated medium.
 */
 int isoburn_find_emulator(struct isoburn **pt,
                                 struct burn_drive *drive, int flag)
@ -518,7 +624,7 @@ int isoburn_find_emulator(struct isoburn **pt,
   return(0);
 if((*pt)->emulation_mode==-1) {
   isoburn_msgs_submit(*pt, 0x00060000,
-                    "Unsuitable drive and media state", 0, "FAILURE", 0);
+                    "Unsuitable drive and medium state", 0, "FAILURE", 0);
   return(-1);
 }
 if((*pt)->emulation_mode==0)
@ -565,12 +671,19 @@ int isoburn_disc_erasable(struct burn_drive *d)

 void isoburn_disc_erase(struct burn_drive *drive, int fast)
 {
- int ret, do_pseudo_blank= 0;
+ int ret, do_pseudo_blank= 0, role;
 struct isoburn *o;
 enum burn_disc_status s;
- char zero_buffer[Libisoburn_target_head_sizE];
+ char *zero_buffer= NULL;
 struct burn_multi_caps *caps= NULL;

+ zero_buffer= calloc(1, Libisoburn_target_head_sizE);
+ if(zero_buffer == NULL) {
+   /* To cause a negative reply with burn_drive_wrote_well() */
+   burn_drive_cancel(drive);
+   goto ex;
+ }
+
 ret= isoburn_find_emulator(&o, drive, 0);
 if(ret>0) {
   if(o->emulation_mode==-1) {
@ -578,7 +691,15 @@ void isoburn_disc_erase(struct burn_drive *drive, int fast)
     burn_drive_cancel(drive);
     goto ex;
   }
-
+   role = burn_drive_get_drive_role(drive);
+   if (role == 5) {
+     /* libburn will truncate the random-access write-only file
+        to zero size and change its state */
+     burn_disc_erase(drive, fast);
+     o->fabricated_disc_status= burn_disc_get_status(drive);
+     o->nwa= o->zero_nwa= 0;
+     goto ex;
+   }
   if(o->emulation_mode > 0) { /* might be readonly with emulated sessions */
     ret= burn_disc_get_multi_caps(drive, BURN_WRITE_NONE, &caps, 0);
     if(ret > 0 && caps->start_adr)
@ -602,6 +723,8 @@ void isoburn_disc_erase(struct burn_drive *drive, int fast)
 ex:;
 if(caps!=NULL)
   burn_disc_free_multi_caps(&caps);
+ if(zero_buffer != NULL)
+   free(zero_buffer);
 }


@ -647,7 +770,7 @@ int isoburn_disc_get_msc1(struct burn_drive *d, int *start_lba)
 if(isoburn_disc_get_status(d)!=BURN_DISC_APPENDABLE &&
    isoburn_disc_get_status(d)!=BURN_DISC_FULL) {
   isoburn_msgs_submit(NULL, 0x00060000,
-                       "Media contains no recognizable data", 0, "SORRY", 0);
+                       "Medium contains no recognizable data", 0, "SORRY", 0);
   return(0);
 }
 ret= isoburn_find_emulator(&o, d, 0);
@ -671,6 +794,7 @@ int isoburn_disc_track_lba_nwa(struct burn_drive *d,
 {
 int ret;
 struct isoburn *o;
+ enum burn_disc_status s;

 #ifdef Hardcoded_cd_rW
 /* <<< A70929 : hardcoded CD-RW with fabricated -msinfo */
@ -690,6 +814,10 @@ int isoburn_disc_track_lba_nwa(struct burn_drive *d,
 }
 if(burn_drive_get_drive_role(d) != 1)
   return(1);
+
+ s= isoburn_disc_get_status(d);
+ if(s == BURN_DISC_BLANK) /* We do not believe in anything but nwa = lba = 0 */
+   return(1);
 return(burn_disc_track_lba_nwa(d, opts, trackno, lba, nwa));
 }

@ -710,6 +838,29 @@ int isoburn_get_msc2(struct isoburn *o,
 return(1);
 }

+/* @param flag bit0= truncate (else do not truncate)
+               bit1= do not warn if call is inappropriate to drive 
+               bit2= only set if truncation is currently enabled
+*/
+int isoburn_set_truncate(struct burn_drive *drive, int flag)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret= isoburn_find_emulator(&o, drive, 0);
+ if(ret < 0)
+   return ret;
+ if(o == NULL) {
+   if(!(flag & (2 | 4)))
+     isoburn_msgs_submit(o, 0x00060000,
+        "Drive type or role is inappropriate for truncation", 0, "WARNING", 0);
+   return(0);
+ }
+ if(o->truncate || !(flag & 4))
+   o->truncate= flag & 1;
+ return(1);
+}
+

 void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 {
@ -717,15 +868,24 @@ void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 off_t nwa= 0;
 struct isoburn *o;
 struct burn_drive *drive;
- char reasons[BURN_REASONS_LEN],msg[160+BURN_REASONS_LEN];
- char adr[BURN_DRIVE_ADR_LEN];
- enum burn_write_types write_type;
+ char *reasons= NULL, *msg= NULL, *adr= NULL;
 struct stat stbuf;
+ enum burn_write_types write_type;

 drive= burn_write_opts_get_drive(opts);
+
+ reasons= calloc(1, BURN_REASONS_LEN);
+ msg= calloc(1, 160+BURN_REASONS_LEN);
+ adr= calloc(1, BURN_DRIVE_ADR_LEN);
+ if(reasons == NULL || msg == NULL || adr == NULL) {
+   /* To cause a negative reply with burn_drive_wrote_well() */
+   burn_drive_cancel(drive);
+   goto ex;
+ }
+
 ret= isoburn_find_emulator(&o, drive, 0);
 if(ret<0)
-   return;
+   goto ex;
 if(o!=NULL) {
   o->wrote_well= -1;
   if(o->emulation_mode!=0) {
@ -755,31 +915,49 @@ void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
                "It might help to first deformat it and then format it again");
         isoburn_msgs_submit(o, 0x00060000, msg, 0, "HINT", 0);
         burn_drive_cancel(drive); /* mark run as failure */
-         return;
+         goto ex;
       }
       /* end of DVD-RW oriented check */
-
       burn_write_opts_set_start_byte(opts, nwa * (off_t) 2048);
     }
   }
 }

- write_type= burn_write_opts_auto_write_type(opts, disc, reasons, 0);
- if (write_type == BURN_WRITE_NONE) {
-    sprintf(msg, "Failed to find a suitable write mode:\n%s", reasons);
-    isoburn_msgs_submit(o, 0x00060000, msg, 0, "FAILURE", 0);
-    if(o!=NULL)
-      o->wrote_well= 0;
-    /* To cause a negative reply with burn_drive_wrote_well() */
-    burn_drive_cancel(drive);
-    return;
- }
+ if(o->do_tao) {
+   if (o->do_tao > 0)
+     burn_write_opts_set_write_type(opts, BURN_WRITE_TAO, BURN_BLOCK_MODE1);
+   else
+     burn_write_opts_set_write_type(opts, BURN_WRITE_SAO, BURN_BLOCK_SAO);

- sprintf(reasons, "%d", (int) write_type);
- sprintf(msg, "Write_type = %s\n",
-              (write_type == BURN_WRITE_SAO ? "SAO" :
-              (write_type == BURN_WRITE_TAO ? "TAO" : reasons)));
- isoburn_msgs_submit(o, 0x00060000, msg, 0, "DEBUG", 0);
+   ret = burn_precheck_write(opts, disc, reasons, 0);
+   if(ret <= 0) {
+     sprintf(msg, "Cannot set write type %s for this medium.",
+             o->do_tao > 0 ? "TAO" : "SAO");
+     sprintf(msg + strlen(msg), "Reasons given:\n   %s", reasons);
+     goto no_write_type;
+   }
+   sprintf(msg, "Explicitly chosen write type: %s",
+           o->do_tao > 0 ? "TAO" : "SAO");
+   isoburn_msgs_submit(o, 0x00060000, msg, 0, "NOTE", 0);
+ } else {
+   write_type= burn_write_opts_auto_write_type(opts, disc, reasons, 0);
+   if (write_type == BURN_WRITE_NONE) {
+      sprintf(msg, "Failed to find a suitable write type:\n%s", reasons);
+no_write_type:;
+      isoburn_msgs_submit(o, 0x00060000, msg, 0, "FAILURE", 0);
+      if(o!=NULL)
+        o->wrote_well= 0;
+      /* To cause a negative reply with burn_drive_wrote_well() */
+      burn_drive_cancel(drive);
+      goto ex;
+   }
+
+   sprintf(reasons, "%d", (int) write_type);
+   sprintf(msg, "Write_type = %s\n",
+                (write_type == BURN_WRITE_SAO ? "SAO" :
+                (write_type == BURN_WRITE_TAO ? "TAO" : reasons)));
+   isoburn_msgs_submit(o, 0x00060000, msg, 0, "DEBUG", 0);
+ }

 #ifdef Hardcoded_cd_rW
 /* <<< A70929 : hardcoded CD-RW with fabricated -msinfo */
@ -790,18 +968,26 @@ void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)

 if(o->truncate) {
   ret= burn_drive_get_drive_role(drive);
-   if(ret==2) {
+   if(ret == 2 || ret == 5) {
     ret= burn_drive_d_get_adr(drive, adr);
     if(ret>0) {
       ret= lstat(adr, &stbuf);
       if(ret!=-1)
         if(S_ISREG(stbuf.st_mode))
-           truncate(adr, nwa * (off_t) 2048);
+           ret= truncate(adr, nwa * (off_t) 2048);
+           /* (result of truncate intentionally ignored) */
     }
   }
 }

 burn_disc_write(opts, disc);
+ex:;
+ if(reasons != NULL)
+   free(reasons);
+ if(msg != NULL)
+   free(msg);
+ if(adr != NULL)
+   free(adr);
 }


@ -866,6 +1052,8 @@ int isoburn_set_start_byte(struct isoburn *o, off_t value, int flag)
 if(value % caps->start_alignment)
   value+= caps->start_alignment - (value % caps->start_alignment);
 o->nwa= value/2048;
+ if(o->nwa < o->zero_nwa)
+   o->zero_nwa= 0;
 /* If suitable for media alignment, round up to Libisoburn_nwa_alignemenT */
 if((o->nwa % Libisoburn_nwa_alignemenT) &&
     ((Libisoburn_nwa_alignemenT*2048) % caps->start_alignment)==0 )
@ -1017,7 +1205,7 @@ int isoburn_report_iso_error(int iso_error_code, char msg_text[], int os_errno,
               bit15= -reserved-
   @return 1 seems to be a valid ISO image , 0 format not recognized, <0 error
 */
-int isoburn_read_iso_head_parse(struct burn_drive *d, unsigned char *data,
+int isoburn_read_iso_head_parse(unsigned char *data,
                                int *image_blocks, char *info, int flag)
 {
 int i, info_mode;
@ -1068,46 +1256,68 @@ int isoburn_read_iso_head_parse(struct burn_drive *d, unsigned char *data,
 int isoburn_read_iso_head(struct burn_drive *d, int lba,
                          int *image_blocks, char *info, int flag)
 {
- unsigned char buffer[64*1024];
+ unsigned char *buffer= NULL;
 int ret, info_mode, capacity, role;
- off_t data_count;
+ off_t data_count, to_read;
+ struct isoburn *o;
+
+ buffer= calloc(1, 64 * 1024);
+ if(buffer == NULL)
+   {ret= -1; goto ex;}

 info_mode= flag&255;
 *image_blocks= 0;
 if(flag&(1<<13)) {
   memcpy(buffer, info, 64*1024);
 } else {
+   memset(buffer, 0, 64 * 1024);
   role = burn_drive_get_drive_role(d);
+   if (role == 3 || role == 5)
+
+     /* >>> ??? return always 0 ? */
+     {ret= (-1*!!(flag&(1<<15))); goto ex;}
+
   ret = burn_get_read_capacity(d, &capacity, 0);
-   if (ret <= 0 && role == 2) {
+   if (ret <= 0 && (role == 2 || role == 4)) {
     /* Might be a block device on a system where libburn cannot determine its
        size.  Try to read anyway. */
     capacity = 0x7ffffff0;
     ret = 1;
   }
-   if(ret > 0 && (off_t) capacity * (off_t) 2048 >= (off_t) (64 * 1024)) {
+   to_read= (off_t) capacity * ((off_t) 2048);
+   if(ret > 0 && to_read >= (off_t) (36 * 1024)) {
+     ret= isoburn_find_emulator(&o, d, 0);
+     if(ret > 0)
+       if(o->media_read_error)
+         {ret= (-1 * !!(flag & (1 << 15))); goto ex;}
+     if(to_read >= (off_t) (64 * 1024))
+       to_read= 64 * 1024;
     ret = burn_read_data(d, ((off_t) lba) * (off_t) 2048, (char *) buffer,
-                      (off_t) 64*1024, &data_count, 2); /* no error messages */
-  } else
-    ret= 0;
+                      to_read, &data_count, 2); /* no error messages */
+   } else
+     ret= 0;
   if(ret<=0)
-     return(-1*!!(flag&(1<<15)));
+     {ret= (-1*!!(flag&(1<<15))); goto ex;}
   if(info_mode==2)
     memcpy(info, buffer, 64*1024);
 }

 if(flag&(1<<14)) {
-   ret= isoburn_read_iso_head_parse(d, buffer, image_blocks, info, info_mode);
+   ret= isoburn_read_iso_head_parse(buffer, image_blocks, info, info_mode);
   if(ret<0)
-     return(ret);
+     goto ex;
   if(ret>0)
-     return(2);
+     {ret= 2; goto ex;}
 }
- ret= isoburn_read_iso_head_parse(d, buffer+32*1024, image_blocks, info,
+ ret= isoburn_read_iso_head_parse(buffer+32*1024, image_blocks, info,
                                  info_mode);
 if(ret<=0)
-   return(ret);
- return(1);
+   goto ex;
+ ret= 1;
+ex:;
+ if(buffer != NULL)
+   free(buffer);
+ return(ret);
 }


@ -1153,41 +1363,52 @@ int isoburn_emulate_toc(struct burn_drive *d, int flag)
 int scan_start= 0, scan_count= 0, probe_minus_16= 0, growisofs_nwa, role;
 int with_enclosure= 0, readable_blocks= -1;
 struct isoburn *o;
- char msg[160], size_text[80], *sev, volid[33], *volid_pt= NULL;
+ char *msg= NULL, *size_text= NULL, *sev, volid[33], *volid_pt= NULL;
 time_t start_time, last_pacifier, now;
+
+ msg= calloc(1, 160);
+ size_text= calloc(1, 80);
+ if(msg == NULL || size_text == NULL)
+   {ret= -1; goto ex;}
 
- /* is the media emulated multi-session ? */
+ /* is the medium emulated multi-session ? */
 ret= isoburn_find_emulator(&o, d, 0);
 if(ret<0)
-   return(-1);
+   {ret= -1; goto ex;}
 if(o==NULL)
-   return(-1);
+   {ret= -1; goto ex;}
 if(o->emulation_mode<=0 && !(flag&1))
-   return(0);
+   {ret= 0; goto ex;}

 ret= burn_get_read_capacity(d, &readable_blocks, 0);
 if(ret <= 0) {
-
   role = burn_drive_get_drive_role(d);
-   if (role == 2)
+   if (role == 2 || role == 4)
     /* Might be a block device on a system where libburn cannot determine its
        size.  Try to read anyway. */
     readable_blocks= 0x7ffffff0; /* try to read anyway */
   else
     readable_blocks= -1;
 }
+ if(o->fabricated_disc_status == BURN_DISC_BLANK)
+   {ret= 0; goto failure;}

 start_time= last_pacifier= time(NULL);
 lba= 0;
- if(!(flag&2)) {
+ if(flag & 2) {
+   /* If there is a PVD at LBA 32 then this is an image with emulated TOC */
+   ret= isoburn_read_iso_head(d, 32, &image_size, NULL, 0);
+   if(ret > 0)
+     lba= 32;
+ } else {
   ret= isoburn_read_iso_head(d, lba, &image_size, NULL, 0);
   if(ret<=0)
     {ret= 0; goto failure;}
-   lba= Libisoburn_overwriteable_starT;
+   lba= o->target_iso_head_size / 2048;
   with_enclosure= 1;
   if((flag & 16) && o->emulation_mode == 1) {
     ret= 1;
-     goto failure; /* This will represent the media as single session */
+     goto failure; /* This will represent the medium as single session */
   }
 }
 while(lba<image_size || (flag&2)) {
@ -1210,7 +1431,7 @@ int isoburn_emulate_toc(struct burn_drive *d, int flag)
     /* growisofs aligns to 16 rather than 32. Overwriteable TOC emulation
        relies on not accidentially seeing inter-session trash data.
        But one can safely access 16 blocks earlier because a xorriso header
-        would have overwritten with the unused 16 blocks at its start.
+        would have been overwritten with the unused 16 blocks at its start.
        If libisoburn alignment would increase, then this would not be
        possible any more.
     */
@ -1289,7 +1510,7 @@ int isoburn_emulate_toc(struct burn_drive *d, int flag)
 sprintf(msg, "Found %d ISO sessions by scanning %s in %.f seconds",
         session_count, size_text, (double) (now - start_time));
 isoburn_msgs_submit(o, 0x00060000, msg, 0, sev, 0);
- return(1);
+ {ret= 1; goto ex;}
 failure:;
 isoburn_toc_entry_destroy(&(o->toc), 1);
 if(with_enclosure && o->emulation_mode == 1) {
@ -1302,6 +1523,11 @@ failure:;
   session_count= 0;
   ret= isoburn_make_toc_entry(o, &session_count, 0, image_size, NULL, 0);
 }
+ex:;
+ if(msg != NULL)
+   free(msg);
+ if(size_text != NULL)
+   free(size_text);
 return(ret);
 }

@ -1360,6 +1586,7 @@ int isoburn_toc_destroy_arrays(struct isoburn_toc_disc *o, int flag)
 struct isoburn_toc_disc *isoburn_toc_drive_get_disc(struct burn_drive *d)
 {
 int ret, session_count= 0, track_count= 0, num_tracks= 0, i, j;
+ int open_sessions= 0;
 struct isoburn *o;
 struct isoburn_toc_entry *t;
 struct isoburn_toc_disc *toc_disc= NULL;
@ -1375,10 +1602,11 @@ struct isoburn_toc_disc *isoburn_toc_drive_get_disc(struct burn_drive *d)
 toc_disc->tracks= NULL;
 toc_disc->track_pointers= NULL;
 toc_disc->session_count= 0;
+ toc_disc->incomplete_session_count= 0;
 toc_disc->track_count= 0;
 toc_disc->toc= NULL; 

- /* is the media emulated multi-session ? */
+ /* is the medium emulated multi-session ? */
 ret= isoburn_find_emulator(&o, d, 0);
 if(ret<0)
   goto libburn;
@ -1415,18 +1643,26 @@ failure:;
   return(NULL);
 }
 s= burn_disc_get_sessions(toc_disc->disc, &session_count);
- for(i= 0; i<session_count; i++) {
+ open_sessions= burn_disc_get_incomplete_sessions(toc_disc->disc);
+ for(i= 0; i < session_count + open_sessions; i++) {
   tracks = burn_session_get_tracks(s[i], &num_tracks);
+   if(i == session_count + open_sessions - 1 && open_sessions > 0) {
+     /* Do not count the invisible track of the last incomplete session */
+     num_tracks--;
+   }
   track_count+= num_tracks;
 }
- if(session_count<=0 || track_count<=0)
+ if(session_count + open_sessions <= 0 || track_count <= 0)
   goto failure;
- ret= isoburn_toc_new_arrays(toc_disc, session_count, track_count, 0);
+ ret= isoburn_toc_new_arrays(toc_disc, session_count + open_sessions,
+                             track_count, 0);
 if(ret<=0)
   goto failure;
 track_count= 0;
- for(i= 0; i<session_count; i++) {
+ for(i= 0; i < session_count + open_sessions; i++) {
   tracks = burn_session_get_tracks(s[i], &num_tracks);
+   if(i == session_count + open_sessions - 1 && open_sessions > 0)
+     num_tracks--;
   toc_disc->sessions[i].session= s[i];
   toc_disc->sessions[i].track_pointers= toc_disc->track_pointers+track_count;
   toc_disc->sessions[i].track_count= num_tracks;
@ -1438,6 +1674,7 @@ failure:;
   track_count+= num_tracks;
 }
 toc_disc->session_count= session_count;
+ toc_disc->incomplete_session_count= open_sessions;
 toc_disc->track_count= track_count;
 return(toc_disc);
 }
@ -1446,7 +1683,7 @@ failure:;
 int isoburn_toc_disc_get_sectors(struct isoburn_toc_disc *disc)
 {
 struct isoburn_toc_entry *t;
- int ret= 0, num_sessions, num_tracks;
+ int ret= 0, num_sessions, num_tracks, open_sessions= 0, session_idx= -1;
 struct burn_session **sessions;
 struct burn_track **tracks;
 struct burn_toc_entry entry;
@ -1458,9 +1695,23 @@ int isoburn_toc_disc_get_sectors(struct isoburn_toc_disc *disc)
     ret= t->start_lba + t->track_blocks;
 } else if(disc->disc!=NULL) {
   sessions= burn_disc_get_sessions(disc->disc, &num_sessions);
-   if(num_sessions > 0) {
-     tracks = burn_session_get_tracks(sessions[num_sessions - 1],
-                                      &num_tracks);
+   open_sessions= burn_disc_get_incomplete_sessions(disc->disc);
+   if(num_sessions + open_sessions > 0) {
+     session_idx= num_sessions + open_sessions - 1;
+     tracks = burn_session_get_tracks(sessions[session_idx], &num_tracks);
+     if(open_sessions > 0) {
+       /* Do not count the invisible track of the last incomplete session */
+       num_tracks--;
+     }
+     if(num_tracks <= 0)
+       session_idx--;
+   }
+   if(session_idx >= 0) {
+     tracks = burn_session_get_tracks(sessions[session_idx], &num_tracks);
+     if(session_idx == num_sessions + open_sessions - 1 && open_sessions > 0) {
+       /* Do not count the invisible track of the last incomplete session */
+       num_tracks--;
+     }
     if(num_tracks > 0) {
       burn_track_get_entry(tracks[num_tracks - 1], &entry);
       if(entry.extensions_valid & 1)
@ -1483,6 +1734,12 @@ struct isoburn_toc_session **isoburn_toc_disc_get_sessions(
 }


+int isoburn_toc_disc_get_incmpl_sess(struct isoburn_toc_disc *disc)
+{
+ return(disc->incomplete_session_count);
+}
+
+
 int isoburn_toc_session_get_sectors(struct isoburn_toc_session *s)
 {
 struct isoburn_toc_entry *t;
@ -1639,7 +1896,7 @@ int isoburn_set_msc1(struct burn_drive *d, int adr_mode, char *adr_value,
 int ret, num_sessions= 0, num_tracks, adr_num, i, j, total_tracks;
 int lba, best_lba, size, re_valid= 0, track_count= 0;
 time_t start_time= 0, last_pacifier= 0, now;
- char volid[33], msg[160];
+ char volid[33], *msg= NULL;
 struct isoburn *o;
 struct isoburn_toc_disc *disc= NULL;
 struct isoburn_toc_session **sessions= NULL;
@ -1648,6 +1905,7 @@ int isoburn_set_msc1(struct burn_drive *d, int adr_mode, char *adr_value,
 static int max_mode_names= 4;
 regex_t re;
 regmatch_t match[1];
+ enum burn_disc_status s;

 ret= isoburn_find_emulator(&o, d, 0);
 if(ret<0)
@ -1655,6 +1913,10 @@ int isoburn_set_msc1(struct burn_drive *d, int adr_mode, char *adr_value,
 if(o==NULL)
   return(-1);

+ msg= calloc(1, 160);
+ if(msg == NULL)
+   {ret= -1; goto ex;}
+
 start_time= last_pacifier= time(NULL);
 adr_num= atoi(adr_value);
 if(adr_mode!=3 || (flag & 2)) {
@ -1708,6 +1970,14 @@ not_found:;

 } else if(adr_mode==3) {
   o->fabricated_msc1= adr_num;
+   s= isoburn_disc_get_status(d);
+   if(o->fabricated_msc1 > 0 && s != BURN_DISC_FULL
+      && s != BURN_DISC_APPENDABLE) {
+     isoburn_msgs_submit(o, 0x00060000,
+                         "Non-zero load offset given with blank input media",
+                         0, "FAILURE", 0);
+     ret= 0; goto ex;
+   }
   if((flag & 1) && o->fabricated_msc1 >= 16) {
     /* adr_num is possibly 16 blocks too high */
     ret= isoburn_read_iso_head(d, o->fabricated_msc1, &size,volid, 1|(1<<14));
@ -1781,6 +2051,8 @@ ex:;
   isoburn_toc_disc_free(disc);
 if((flag & 4) && re_valid)
   regfree(&re);
+ if(msg != NULL)
+   free(msg);
 return(ret);
 }

@ -1836,6 +2108,8 @@ int isoburn_get_mount_params(struct burn_drive *d,

 ex:;
 o->fabricated_msc1= msc1_mem;
+ if(disc != NULL)
+   isoburn_toc_disc_free(disc);
 return(2 - is_iso); 
 }

--- a/libisoburn/data_source.c
+++ b/libisoburn/data_source.c
@ -1,11 +1,15 @@
 /*
  data source for libisoburn.

-  Copyright 2007 - 2010 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+  Copyright 2007 - 2012 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
                    and Thomas Schmitt <scdbackup@gmx.net>
  Provided under GPL version 2 or later.
 */

+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <stdlib.h>
 #include <string.h>

@ -29,17 +33,7 @@
 #include "isoburn.h"


-/* Cached reading of image tree data */
-/* Multi tile:  32 * 64 kB */
-
-/* The size of a single tile.
-   Powers of 2 only ! Less than 16 makes not much sense.
-*/
-#define Libisoburn_tile_blockS 32
-
-/* The number of tiles in the cache
-*/
-#define Libisoburn_cache_tileS 32
+/* Cached reading of image tree data by multiple tiles */


 /* Debugging only: This reports cache loads on stderr.
@ -48,7 +42,7 @@


 struct isoburn_cache_tile {
- char cache_data[Libisoburn_tile_blockS * 2048];
+ char *cache_data;
 uint32_t cache_lba;
 uint32_t last_error_lba;
 uint32_t last_aligned_error_lba;
@ -58,8 +52,24 @@ struct isoburn_cache_tile {

 struct isoburn_cached_drive {
 struct burn_drive *drive;
- struct isoburn_cache_tile tiles[Libisoburn_cache_tileS];
+ struct isoburn_cache_tile **tiles;
+ int num_tiles;
+ int tile_blocks;
 int current_age;
+
+ /**    
+  Offset to be applied to all block addresses to compensate for an
+  eventual displacement of the block addresses relative to the image
+  start block address that was assumed when the image was created.
+  E.g. if track number 2 gets copied into a disk file and shall then
+  be loaded as ISO filesystem.
+  If displacement_sign is 1 then the displacement number will be
+  added to .read_block() addresses, if -1 it will be subtracted.
+  Else it will be ignored.
+ */
+ uint32_t displacement;
+ int      displacement_sign;
+
 };

 #define Libisoburn_max_agE 2000000000
@ -74,7 +84,7 @@ int ds_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
 off_t count;
 uint32_t aligned_lba;
 char msg[80];
- struct isoburn_cache_tile *tiles;
+ struct isoburn_cache_tile **tiles;
 struct isoburn_cached_drive *icd;

 if(src == NULL || buffer == NULL)
@ -99,14 +109,28 @@ int ds_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
   return ISO_ASSERT_FAILURE;
 }

- tiles = (struct isoburn_cache_tile *) icd->tiles;
+ tiles = icd->tiles;

- aligned_lba= lba & ~(Libisoburn_tile_blockS - 1);
+ if(icd->displacement_sign == 1) {
+   if(lba + icd->displacement < lba) {
+address_rollover:;
+      return ISO_DISPLACE_ROLLOVER;
+   } else
+     lba += icd->displacement;
+ } else if(icd->displacement_sign == -1) {
+   if(lba < icd->displacement )
+     goto address_rollover;
+   else
+     lba -= icd->displacement;
+ }

- for(i=0; i<Libisoburn_cache_tileS; i++) {
-   if(aligned_lba == tiles[i].cache_lba && tiles[i].cache_lba != 0xffffffff) {
-     (tiles[i].cache_hits)++;
-     memcpy(buffer, tiles[i].cache_data + (lba - aligned_lba) * 2048, 2048);
+ aligned_lba= lba & ~(icd->tile_blocks - 1);
+
+ for (i = 0; i < icd->num_tiles; i++) {
+   if(aligned_lba == tiles[i]->cache_lba &&
+      tiles[i]->cache_lba != 0xffffffff) {
+     (tiles[i]->cache_hits)++;
+     memcpy(buffer, tiles[i]->cache_data + (lba - aligned_lba) * 2048, 2048);
     count= 2048;
     ds_inc_age(icd, i, 0);
     return 1;
@ -116,73 +140,53 @@ int ds_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
 /* find oldest tile */
 oldest_age= Libisoburn_max_agE;
 oldest= 0;
- for(i= 0; i<Libisoburn_cache_tileS; i++) {
-   if(tiles[i].cache_lba == 0xffffffff) {
+ for(i = 0; i < icd->num_tiles; i++) {
+   if(tiles[i]->cache_lba == 0xffffffff) {
     oldest= i;
 break;
   }
-   if(tiles[i].age<oldest_age) {
-     oldest_age= tiles[i].age;
+   if(tiles[i]->age < oldest_age) {
+     oldest_age= tiles[i]->age;
     oldest= i;
   }
 }

- tiles[oldest].cache_lba= 0xffffffff; /* invalidate cache */
- if(tiles[oldest].last_aligned_error_lba == aligned_lba) {
+ tiles[oldest]->cache_lba= 0xffffffff; /* invalidate cache */
+ if(tiles[oldest]->last_aligned_error_lba == aligned_lba) {
   ret = 0;
 } else {
   ret = burn_read_data(d, (off_t) aligned_lba * (off_t) 2048,
-                        (char *) tiles[oldest].cache_data,
-                        Libisoburn_tile_blockS * 2048, &count, 2);
+                        (char *) tiles[oldest]->cache_data,
+                        icd->tile_blocks * 2048, &count, 2);
 }
 if (ret <= 0 ) {
-   tiles[oldest].last_aligned_error_lba = aligned_lba;
+   tiles[oldest]->last_aligned_error_lba = aligned_lba;

   /* Read-ahead failure ? Try to read 2048 directly. */
-   if(tiles[oldest].last_error_lba == lba)
+   if(tiles[oldest]->last_error_lba == lba)
     ret = 0;
   else
     ret = burn_read_data(d, (off_t) lba * (off_t) 2048, (char *) buffer,
                        2048, &count, 0);
   if (ret > 0)
     return 1;
-   tiles[oldest].last_error_lba = lba;
-
-#ifdef ISO_DATA_SOURCE_MISHAP
-   ret= ISO_DATA_SOURCE_MISHAP;
-#else
-   /* <<< pre libisofs-0.6.7 */
-   /* It is not required by the specs of libisofs but implicitely assumed
-      ...
-      But it is not possible to ignore FAILURE.
-      libisofs insists in original error codes, i.e. libisoburn cannot
-      change severity FAILURE associated with ISO_FILE_READ_ERROR.
-      So ISO_FILE_READ_ERROR is not an option and libisoburn has to
-      misuse ISO_FILE_CANT_WRITE, which is actually for image generation
-      and not for image reading.
-      This is quite wrong, although the error message text is unclear
-      enough to make it appear plausible.
-   */
-   ret= ISO_FILE_CANT_WRITE;
-#endif
-
-   if(ret >= 0)
-     ret = -1;
-   sprintf(msg, "ds_read_block(%lu) returns %d", (unsigned long) lba, ret);
+   tiles[oldest]->last_error_lba = lba;
+   sprintf(msg, "ds_read_block(%lu) returns %lX",
+           (unsigned long) lba, (unsigned long) ret);
   isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "DEBUG", 0);
-   return ret; 
+   return ISO_DATA_SOURCE_MISHAP;
 }

 #ifdef Libisoburn_read_cache_reporT
 fprintf(stderr, "Tile %2.2d : After %3d hits, new load from %8x , count= %d\n",
-         oldest, tiles[oldest].cache_hits, aligned_lba, (int) count);
+         oldest, tiles[oldest]->cache_hits, aligned_lba, (int) count);
 #endif

- tiles[oldest].cache_lba= aligned_lba;
- tiles[oldest].cache_hits= 1;
+ tiles[oldest]->cache_lba= aligned_lba;
+ tiles[oldest]->cache_hits= 1;
 ds_inc_age(icd, oldest, 0);

- memcpy(buffer, tiles[oldest].cache_data + (lba - aligned_lba) * 2048, 2048);
+ memcpy(buffer, tiles[oldest]->cache_data + (lba - aligned_lba) * 2048, 2048);
 count= 2048;

 return 1;
@ -201,11 +205,107 @@ static int ds_close(IsoDataSource *src)
 return 1;
 }

+
+static int isoburn_cache_tile_destroy(struct isoburn_cache_tile **o,
+                                      int flag)
+{
+ if (*o == NULL)
+   return(0);
+ if ((*o)->cache_data != NULL)
+   free((*o)->cache_data);
+ free(*o);
+ *o = NULL;
+ return(1);
+}
+
+
+static int isoburn_cache_tile_new(struct isoburn_cache_tile **o,
+                                  int tile_blocks, int flag)
+{
+ struct isoburn_cache_tile *t;
+
+ *o = t = calloc(1, sizeof(struct isoburn_cache_tile));
+ if (t == NULL)
+   goto fail;
+ t->cache_data = NULL;
+ t->cache_lba = 0xffffffff;
+ t->cache_hits = 0;
+ t->last_error_lba = 0xffffffff;
+ t->last_aligned_error_lba = 0xffffffff;
+ t->age= 0;
+
+ t->cache_data = calloc(1, tile_blocks * 2048);
+ if (t->cache_data == NULL)
+   goto fail;
+
+ return(1);
+fail:;
+ isoburn_cache_tile_destroy(o, 0);
+ return(-1);
+}
+
+
+static int isoburn_cached_drive_destroy(struct isoburn_cached_drive **o,
+                                        int flag)
+{
+ struct isoburn_cached_drive *c;
+ int i;
+
+ if (*o == NULL)
+   return(0);
+ c= *o;
+ if (c->tiles != NULL) {
+   for (i = 0; i < c->num_tiles; i++) 
+     isoburn_cache_tile_destroy(&(c->tiles[i]), 0);
+   free(c->tiles);
+ }
+ free(c);
+ *o= NULL;
+ return(1);
+}
+
+
+static int isoburn_cached_drive_new(struct isoburn_cached_drive **o,
+                                    struct burn_drive *d, int cache_tiles,
+                                    int tile_blocks, int flag)
+{
+ struct isoburn_cached_drive *icd;
+ int i, ret;
+
+ *o = icd = calloc(1,sizeof(struct isoburn_cached_drive));
+ if (*o == NULL)
+   return(-1);
+ icd->drive = d;
+ icd->tiles = NULL;
+ icd->num_tiles = cache_tiles;
+ icd->tile_blocks = tile_blocks;
+ icd->current_age = 0;
+ icd->displacement = 0;
+ icd->displacement_sign = 0;
+
+ icd->tiles = calloc(1, sizeof(struct isoburn_cache_tile *) * icd->num_tiles);
+ if (icd->tiles == NULL)
+   goto fail;
+ for (i = 0; i < icd->num_tiles; i++) {
+   ret = isoburn_cache_tile_new(&(icd->tiles[i]), icd->tile_blocks, 0);
+   if (ret <= 0)
+     goto fail;
+ }
+ return(1);
+fail:;
+ isoburn_cached_drive_destroy(o, 0);
+ return(-1);
+}
+
+
 static void ds_free_data(IsoDataSource *src)
 {
- /* nothing to do */;
- if(src->data != NULL)
-   free(src->data);
+ struct isoburn_cached_drive *icd;
+
+ if(src->data != NULL) {
+   icd= (struct isoburn_cached_drive *) src->data;
+   isoburn_cached_drive_destroy(&icd, 0);
+ }
 src->data= NULL;
 }

@ -222,34 +322,34 @@ int isoburn_data_source_shutdown(IsoDataSource *src, int flag)
 }


-IsoDataSource *isoburn_data_source_new(struct burn_drive *d)
+IsoDataSource *isoburn_data_source_new(struct burn_drive *d,
+                                  uint32_t displacement, int displacement_sign,
+                                  int cache_tiles, int tile_blocks)
 {
- IsoDataSource *ret;
+ IsoDataSource *src;
 struct isoburn_cached_drive *icd= NULL;
- int i;
+ int ret;

 if (d==NULL)
   return NULL;
- ret = malloc(sizeof(IsoDataSource));
- icd = calloc(1,sizeof(struct isoburn_cached_drive));
- if (ret == NULL || icd == NULL)
+ src = malloc(sizeof(IsoDataSource));
+ if (src == NULL)
+   return NULL;
+ ret = isoburn_cached_drive_new(&icd, d, cache_tiles, tile_blocks, 0);
+ if (ret <= 0) {
+   free(src);
   return NULL;
- ret->refcount = 1;
- ret->read_block = ds_read_block;
- ret->open = ds_open;
- ret->close = ds_close;
- ret->free_data = ds_free_data;
- ret->data = icd;
- icd->drive = d;
- icd->current_age= 0;
- for(i= 0; i<Libisoburn_cache_tileS; i++) {
-   icd->tiles[i].cache_lba = 0xffffffff;
-   icd->tiles[i].cache_hits = 0;
-   icd->tiles[i].last_error_lba = 0xffffffff;
-   icd->tiles[i].last_aligned_error_lba = 0xffffffff;
-   icd->tiles[i].age= 0;
 }
- return ret;
+ src->version = 0;
+ src->refcount = 1;
+ src->read_block = ds_read_block;
+ src->open = ds_open;
+ src->close = ds_close;
+ src->free_data = ds_free_data;
+ src->data = icd;
+ icd->displacement = displacement;
+ icd->displacement_sign = displacement_sign;
+ return src;
 }


@ -259,11 +359,11 @@ static int ds_inc_age(struct isoburn_cached_drive *icd, int idx, int flag)

 (icd->current_age)++;
 if(icd->current_age>=Libisoburn_max_agE) { /* reset all ages (allow waste) */
-   for(i= 0; i<Libisoburn_cache_tileS; i++)
-     (icd->tiles)[i].age= 0;
+   for(i = 0; i < icd->num_tiles; i++)
+     (icd->tiles)[i]->age= 0;
   icd->current_age= 1;
 }
- (icd->tiles)[idx].age= icd->current_age;
+ (icd->tiles)[idx]->age= icd->current_age;
 return(1);
 }

--- a/libisoburn/isoburn.c
+++ b/libisoburn/isoburn.c
@ -6,12 +6,16 @@
 /*
  Class core of libisoburn.

-  Copyright 2007 - 2010 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+  Copyright 2007 - 2012 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
                        Thomas Schmitt <scdbackup@gmx.net>

  Provided under GPL version 2 or later.
 */

+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 /* ( derived from stub generated by CgeN on  Sat, 01 Sep 2007 12:04:36 GMT ) */

 #include <sys/types.h>
@ -111,7 +115,7 @@ struct isoburn *isoburn_list_start= NULL;
 int isoburn_new(struct isoburn **objpt, int flag)
 {
 struct isoburn *o;
- int i, ret;
+ int ret;

 *objpt= o= (struct isoburn *) malloc(sizeof(struct isoburn));
 if(o==NULL) {
@ -131,24 +135,37 @@ int isoburn_new(struct isoburn **objpt, int flag)
 o->truncate= 0;
 o->iso_source= NULL;
 o->fabricated_disc_status= BURN_DISC_UNREADY;
+ o->media_read_error= 0;
 o->toc= NULL;
 o->wrote_well= -1;
- for(i=0;i<Libisoburn_target_head_sizE;i++)
-   o->target_iso_head[i]= 0;
+ o->loaded_partition_offset= 0;
+ o->target_iso_head_size= Libisoburn_target_head_sizE;
+ o->target_iso_head= NULL;
 o->image= NULL;
+ o->image_start_lba= -1;
 o->iso_data_source= NULL;
 o->read_pacifier= NULL;
 o->read_pacifier_handle= NULL;
 o->msgs_submit= NULL;
 o->msgs_submit_handle= NULL;
 o->msgs_submit_flag= 0;
+ o->do_tao= 0;
 o->prev= NULL;
 o->next= NULL;
- ret= iso_image_new("ISOIMAGE", &o->image);
- if(ret<0) {
-   isoburn_report_iso_error(ret, "Cannot create image", 0, "FATAL", 0);
+ o->target_iso_head= calloc(1, o->target_iso_head_size);
+ if(o->target_iso_head == NULL) {
+   isoburn_report_iso_error(ISO_OUT_OF_MEM, "Cannot allocate overwrite buffer",
+                            0, "FATAL", 0);
   goto failed;
 }
+ ret= iso_image_new("ISOIMAGE", &o->image);
+ if(ret<0) {
+   isoburn_report_iso_error(ret, "Cannot create image object", 0, "FATAL", 0);
+   goto failed;
+ }
+ ret= isoburn_root_defaults(o->image, 0);
+ if(ret <= 0)
+   goto failed;
 isoburn_link(o, isoburn_list_start, 1);
 return(1);
 failed:;
@ -184,6 +201,8 @@ int isoburn_destroy(struct isoburn **objpt, int flag)
   burn_source_free(o->iso_source);
 if(o->iso_data_source!=NULL)
   iso_data_source_unref(o->iso_data_source);
+ if(o->target_iso_head != NULL)
+   free(o->target_iso_head);
 free((char *) o);
 *objpt= NULL;
 return(1);
@ -342,6 +361,38 @@ int isoburn_msgs_submit(struct isoburn *o, int error_code, char msg_text[],
 }


+/** Check whether the size of target_iso_head matches the given partition 
+    offset. Eventually adjust size.
+*/
+int isoburn_adjust_target_iso_head(struct isoburn *o,
+                                   uint32_t offst, int flag)
+{
+ uint8_t *new_buf;
+ uint32_t new_size;
+
+ if((uint32_t) o->target_iso_head_size ==
+    Libisoburn_target_head_sizE + 2048 * offst)
+   return(1);
+ new_size= Libisoburn_target_head_sizE + 2048 * offst;
+ new_buf= calloc(1, new_size);
+ if(new_buf == NULL) {
+   isoburn_msgs_submit(o, 0x00060000,
+                       "Cannot re-allocate overwrite buffer", 0, "FATAL", 0);
+   return(-1);
+ }
+ memcpy(new_buf, o->target_iso_head,
+        (uint32_t) o->target_iso_head_size < new_size ?
+        (uint32_t) o->target_iso_head_size : new_size);
+ free(o->target_iso_head);
+ o->target_iso_head= new_buf;
+ o->target_iso_head_size= new_size;
+ if(o->nwa == o->zero_nwa)
+   o->nwa= Libisoburn_overwriteable_starT + offst;
+ o->zero_nwa= Libisoburn_overwriteable_starT + offst;
+ return(1);
+}
+
+
 /* @param flag bit0= modifying rather than growing
               bit1= prepare for early release of input drive:
                     wait until input and then disable image data source
@ -357,10 +408,14 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
 struct isoburn *in_o, *out_o;
 IsoWriteOpts *wopts= NULL;
 enum burn_disc_status state;
- int ret, fifo_chunks, lba, nwa, i, new_img, early_indev_release;
+ int ret, fifo_chunks, lba, nwa, i, new_img, early_indev_release, rec_mtime;
 uint32_t data_start= -1;
 size_t buffer_size= 0, buffer_free= 0;
- char msg[160];
+ char *msg= NULL;
+
+ msg= calloc(1, 160);
+ if(msg == NULL)
+   {ret= -1; goto ex;}

 new_img= flag&1;
 early_indev_release= flag&2;
@ -381,6 +436,8 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
   {ret= -4; goto ex;}
 }

+ out_o->do_tao = opts->do_tao;
+
 state = isoburn_disc_get_status(in_d);
 if (state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE &&
     state != BURN_DISC_FULL) {
@ -394,6 +451,12 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
                    0, "FAILURE", 0);
   {ret= -2; goto ex;}
 }
+ if (state != BURN_DISC_BLANK && opts->libjte_handle != NULL) {
+   isoburn_msgs_submit(out_o, 0x00060000,
+                  "Jigdo Template Extraction works only on blank target media",
+                  0, "FAILURE", 0);
+   {ret= -2; goto ex;}
+ }
 
 fifo_chunks= 32;
 if(opts->fifo_size >= 64*1024 && opts->fifo_size <= 1024.0 * 1024.0 * 1024.0){
@ -407,33 +470,46 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
   isoburn_report_iso_error(ret, "Cannot create iso_write_opts", 0, "FATAL",0);
   goto ex;
 }
+ iso_write_opts_set_will_cancel(wopts, opts->will_cancel);
 iso_write_opts_set_iso_level(wopts, opts->level);
 iso_write_opts_set_rockridge(wopts, opts->rockridge);
 iso_write_opts_set_joliet(wopts, opts->joliet);
+ iso_write_opts_set_hfsplus(wopts, opts->hfsplus);
+ iso_write_opts_set_hfsp_block_size(wopts, opts->hfsp_block_size,
+                                           opts->apm_block_size);
+ iso_write_opts_set_fat(wopts, opts->fat);
 iso_write_opts_set_iso1999(wopts, opts->iso1999);
-
- /* <<< #ifdef  shall be removed when libisofs-0.6.20 is released */
-#ifdef Libisofs_hardlink_prooF
-
 iso_write_opts_set_hardlinks(wopts, opts->hardlinks);
 if(opts->hardlinks)
   iso_write_opts_set_rrip_1_10_px_ino(wopts, 1);
-
-#endif
-
 iso_write_opts_set_aaip(wopts, opts->aaip);
+ iso_write_opts_set_old_empty(wopts, !!opts->old_empty);
+ iso_write_opts_set_untranslated_name_len(wopts, opts->untranslated_name_len);
+ iso_write_opts_set_allow_dir_id_ext(wopts, opts->allow_dir_id_ext);
 iso_write_opts_set_omit_version_numbers(wopts, opts->omit_version_numbers);
 iso_write_opts_set_allow_deep_paths(wopts, opts->allow_deep_paths);
+ iso_write_opts_set_rr_reloc(wopts, opts->rr_reloc_dir, opts->rr_reloc_flags);
 iso_write_opts_set_allow_longer_paths(wopts, opts->allow_longer_paths);
 iso_write_opts_set_max_37_char_filenames(wopts, opts->max_37_char_filenames);
 iso_write_opts_set_no_force_dots(wopts, opts->no_force_dots);
 iso_write_opts_set_allow_lowercase(wopts, opts->allow_lowercase);
 iso_write_opts_set_allow_full_ascii(wopts, opts->allow_full_ascii);
+ iso_write_opts_set_allow_7bit_ascii(wopts, opts->allow_7bit_ascii);
 iso_write_opts_set_relaxed_vol_atts(wopts, 1);
 iso_write_opts_set_joliet_longer_paths(wopts, opts->joliet_longer_paths);
+ iso_write_opts_set_joliet_long_names(wopts, opts->joliet_long_names);
 iso_write_opts_set_always_gmt(wopts, opts->always_gmt);
 iso_write_opts_set_rrip_version_1_10(wopts, opts->rrip_version_1_10);
- iso_write_opts_set_dir_rec_mtime(wopts, opts->dir_rec_mtime);
+ rec_mtime= 0;
+ if(opts->dir_rec_mtime)
+   rec_mtime|= 1;
+ else
+   rec_mtime|= (1 << 14);
+ if(opts->joliet_rec_mtime)
+   rec_mtime|= 2;
+ if(opts->iso1999_rec_mtime)
+   rec_mtime|= 4;
+ iso_write_opts_set_dir_rec_mtime(wopts, rec_mtime);
 iso_write_opts_set_aaip_susp_1_10(wopts, opts->aaip_susp_1_10);
 iso_write_opts_set_sort_files(wopts, opts->sort_files);
 iso_write_opts_set_record_md5(wopts, opts->session_md5, opts->file_md5 & 3);
@ -449,19 +525,86 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
 iso_write_opts_set_default_gid(wopts, opts->gid);
 iso_write_opts_set_output_charset(wopts, opts->output_charset);
 iso_write_opts_set_fifo_size(wopts, fifo_chunks);
+ ret = iso_write_opts_set_system_area(wopts, opts->system_area_data,
+                                      opts->system_area_options, 0);
+ if (ret < 0) {
+   isoburn_report_iso_error(ret, "Cannot set content of System Area",
+                            0, "FAILURE", 0);
+   {ret= -1; goto ex;}
+ }
+ iso_write_opts_set_pvd_times(wopts,
+                        opts->vol_creation_time, opts->vol_modification_time,
+                        opts->vol_expiration_time, opts->vol_effective_time,
+                        opts->vol_uuid);
+ iso_write_opts_attach_jte(wopts, opts->libjte_handle);
+ iso_write_opts_set_hfsp_serial_number(wopts, opts->hfsp_serial_number);

+ ret= isoburn_adjust_target_iso_head(out_o, opts->partition_offset, 0);
+ if(ret <= 0)
+   {ret= -1; goto ex;}
+ if(out_o->nwa < out_o->zero_nwa)
+   out_o->zero_nwa= 0;
+ if(opts->no_emul_toc || opts->libjte_handle != NULL) {
+   if(out_o->nwa == out_o->zero_nwa &&
+      out_o->zero_nwa == Libisoburn_overwriteable_starT 
+                         + opts->partition_offset
+      && out_o->emulation_mode == 1) {
+     out_o->nwa= 0;
+     out_o->zero_nwa= 0;
+     out_o->min_start_byte= 0;
+   }
+ }
 ret = isoburn_disc_track_lba_nwa(out_d, NULL, 0, &lba, &nwa);
 opts->effective_lba= nwa;
 ret= isoburn_get_msc2(out_o, NULL, &nwa, 0);
 if (ret != 1) {
   isoburn_msgs_submit(out_o, 0x00060000,
                   "Cannot determine next writeable address", 0, "FAILURE", 0);
+
+   /* >>> NWA_V : If burn_next_track_damaged:
+          ??? Close track and session ?
+	  ??? Issue a hint for a repair command ?
+   */;
+
   {ret= -3; goto ex;}
 }
 iso_write_opts_set_ms_block(wopts, nwa);
 iso_write_opts_set_appendable(wopts, !new_img);
 iso_write_opts_set_overwrite_buf(wopts,
                                  nwa>0 ? out_o->target_iso_head : NULL);
+ iso_write_opts_set_part_offset(wopts, opts->partition_offset,
+                                opts->partition_secs_per_head,
+                                opts->partition_heads_per_cyl);
+ iso_write_opts_set_tail_blocks(wopts, opts->tail_blocks);
+ if(opts->prep_partition != NULL) {
+   ret = iso_write_opts_set_prep_img(wopts, opts->prep_partition, 0);
+   if(ret < 0) {
+     isoburn_report_iso_error(ret, "Cannot set path for PreP partition",
+                              0, "FAILURE", 0);
+     {ret= -1; goto ex;}
+   }
+ }
+ if(opts->efi_boot_partition != NULL) {
+   ret = iso_write_opts_set_efi_bootp(wopts, opts->efi_boot_partition, 0);
+   if(ret < 0) {
+     isoburn_report_iso_error(ret, "Cannot set path for EFI system partition",
+                              0, "FAILURE", 0);
+     {ret= -1; goto ex;}
+   }
+ }
+ for(i= 0; i < Libisoburn_max_appended_partitionS; i++) {
+   if(opts->appended_partitions[i] == NULL)
+ continue;
+   ret= iso_write_opts_set_partition_img(wopts, i + 1,
+                                         opts->appended_part_types[i],
+                                         opts->appended_partitions[i], 0);
+   if(ret < 0) {
+     isoburn_report_iso_error(ret, "Cannot set path for appended partition",
+                              0, "FAILURE", 0);
+     {ret= -1; goto ex;}
+   }
+ }
+ iso_write_opts_set_disc_label(wopts, opts->ascii_disc_label);

 ret = iso_image_create_burn_source(in_o->image, wopts, &wsrc);
 if (ret < 0) {
@ -518,6 +661,8 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
 ex:
 if(wopts!=NULL)
   {iso_write_opts_free(wopts); wopts= NULL;}
+ if(msg != NULL)
+   free(msg);
 return ret;
 }

@ -559,6 +704,7 @@ int isoburn_prepare_blind_grow(struct burn_drive *d, struct burn_disc **disc,
   o->nwa= o->zero_nwa= 0;
 else
   o->zero_nwa= 0;
+ o->min_start_byte= 0;
 ret= isoburn_prepare_disc_aux(d, out_drive, disc, opts, 2);
 if (ret<=0)
   return ret;
@ -655,6 +801,8 @@ int isoburn_ropt_new(struct isoburn_read_opts **new_o, int flag)
                     "Cannot allocate memory for read options", 0, "FATAL", 0);
   return(-1);
 }
+ o->cache_tiles= Libisoburn_default_cache_tileS;
+ o->cache_tile_blocks= Libisoburn_default_tile_blockS;
 o->norock= 0;
 o->nojoliet= 0;
 o->noiso1999= 1;
@ -675,6 +823,8 @@ int isoburn_ropt_new(struct isoburn_read_opts **new_o, int flag)
 o->hasElTorito= 0;
 o->size= 0;
 o->pretend_blank= 1;
+ o->displacement= 0;
+ o->displacement_sign= 0;
 return(1);
 }

@ -689,6 +839,59 @@ int isoburn_ropt_destroy(struct isoburn_read_opts **o, int flag)
 }


+int isoburn_ropt_set_data_cache(struct isoburn_read_opts *o,
+                                int cache_tiles, int tile_blocks, int flag)
+{
+ int i;
+ char msg[80];
+
+ if(cache_tiles < 1) {
+   isoburn_msgs_submit(NULL, 0x00060000,
+                     "Requested number of data cache tiles is too small (< 1)",
+                     0, "SORRY", 0);
+   return(0);
+ }  
+ if(((double) cache_tiles) * ((double) tile_blocks)
+     > (double) Libisoburn_cache_max_sizE) {
+   sprintf(msg, "Requested size of data cache exceeds limit of %.f blocks",
+           (double) Libisoburn_cache_max_sizE);
+   isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "SORRY", 0);
+   return(0);
+ }
+ for(i = 1; i <= Libisoburn_cache_max_sizE; i = i << 1)
+   if(i == tile_blocks)
+ break;
+ if(i > Libisoburn_cache_max_sizE) {
+   isoburn_msgs_submit(NULL, 0x00060000, 
+         "Requested number of blocks per data cache tiles is not a power of 2",
+         0, "SORRY", 0);
+   return(0);
+ }
+ if(o != NULL) {
+   o->cache_tiles= cache_tiles;
+   o->cache_tile_blocks= tile_blocks;
+ }
+ return(1);
+} 
+
+
+int isoburn_ropt_get_data_cache(struct isoburn_read_opts *o,
+                                 int *cache_tiles, int *tile_blocks,
+                                 int *set_flag, int flag)
+{
+ if((flag & 1) || o == NULL) {
+   *cache_tiles= Libisoburn_default_cache_tileS;
+   *tile_blocks= Libisoburn_default_tile_blockS;
+   *set_flag= 0;
+   return(1);
+ }
+ *cache_tiles= o->cache_tiles;
+ *tile_blocks= o->cache_tile_blocks;
+ *set_flag= 0;
+ return(1);
+}
+
+
 int isoburn_ropt_set_extensions(struct isoburn_read_opts *o, int ext)
 {
 o->norock= !!(ext&1);
@ -700,7 +903,7 @@ int isoburn_ropt_set_extensions(struct isoburn_read_opts *o, int ext)
 o->noacl= !!(ext & 64);
 o->noea= !!(ext & 128);
 o->noino= !!(ext & 256);
- o->nomd5= !!(ext & 512);
+ o->nomd5= (ext >> 9) & 3;
 return(1);
 }

@ -710,7 +913,7 @@ int isoburn_ropt_get_extensions(struct isoburn_read_opts *o, int *ext)
 *ext= (!!o->norock) | ((!!o->nojoliet)<<1) | ((!!o->noiso1999)<<2) |
       ((!!o->preferjoliet)<<3) | ((!!o->pretend_blank)<<4) |
       ((!!o->noaaip) << 5) | ((!!o->noacl) << 6) | ((!!o->noea) << 7) |
-       ((!!o->noino) << 8) | ((!!o->nomd5) << 9);
+       ((!!o->noino) << 8) | ((o->nomd5 & 3) << 9);
 return(1);
 }

@ -791,6 +994,24 @@ int isoburn_ropt_get_auto_incharset(struct isoburn_read_opts *o, int *mode)
 }


+int isoburn_ropt_set_displacement(struct isoburn_read_opts *o,
+                               uint32_t displacement, int displacement_sign)
+{
+ o->displacement= displacement;
+ o->displacement_sign= displacement_sign;
+ return(1);
+}
+
+
+int isoburn_ropt_get_displacement(struct isoburn_read_opts *o,
+                               uint32_t *displacement, int *displacement_sign)
+{
+ *displacement= o->displacement;
+ *displacement_sign= o->displacement_sign;
+ return(1);
+}
+
+
 int isoburn_ropt_get_size_what(struct isoburn_read_opts *o,
                               uint32_t *size, int *has_what)
 {
@ -811,6 +1032,7 @@ int isoburn_ropt_get_size_what(struct isoburn_read_opts *o,
 int isoburn_igopt_new(struct isoburn_imgen_opts **new_o, int flag)
 {
 struct isoburn_imgen_opts *o;
+ int i;

 o= (*new_o)= calloc(1, sizeof(struct isoburn_imgen_opts));
 if(o==NULL) {
@ -825,14 +1047,24 @@ int isoburn_igopt_new(struct isoburn_imgen_opts **new_o, int flag)
 o->iso1999= 0;
 o->hardlinks= 0;
 o->aaip = 0;
+ o->session_md5= 0;
+ o->file_md5= 0;
+ o->no_emul_toc= 0;
+ o->old_empty= 0;
+ o->untranslated_name_len = 0;
+ o->allow_dir_id_ext = 0;
 o->omit_version_numbers= 0;
 o->allow_deep_paths= 1;
+ o->rr_reloc_dir= NULL;
+ o->rr_reloc_flags= 0;
 o->allow_longer_paths= 0;
 o->max_37_char_filenames= 0;
 o->no_force_dots= 0;
 o->allow_lowercase= 0;
 o->allow_full_ascii= 0;
+ o->allow_7bit_ascii= 0;
 o->joliet_longer_paths= 0;
+ o->joliet_long_names= 0;
 o->always_gmt= 0;
 o->rrip_version_1_10= 0;
 o->dir_rec_mtime= 0;
@ -850,14 +1082,48 @@ int isoburn_igopt_new(struct isoburn_imgen_opts **new_o, int flag)
 o->fifo_size= 4*1024*1024;
 o->effective_lba= -1;
 o->data_start_lba= -1;
+ o->system_area_data= NULL;
+ o->system_area_options= 0;
+ o->partition_offset= 0;
+ o->partition_secs_per_head= 0;
+ o->partition_heads_per_cyl= 0;
+ o->vol_creation_time= 0;
+ o->vol_modification_time= 0;
+ o->vol_expiration_time= 0;
+ o->vol_effective_time= 0;
+ o->libjte_handle= NULL;
+ o->tail_blocks= 0;
+ o->prep_partition= NULL;
+ o->efi_boot_partition= NULL;
+ for(i= 0; i < Libisoburn_max_appended_partitionS; i++) {
+   o->appended_partitions[i]= NULL;
+   o->appended_part_types[i]= 0;
+ }
+ memset(o->hfsp_serial_number, 0, 8);
+ o->hfsp_block_size= 0;
+ o->apm_block_size= 0;
+ o->do_tao= 0;
 return(1);
 }


 int isoburn_igopt_destroy(struct isoburn_imgen_opts **o, int flag)
 {
+ int i;
+
 if(*o==NULL)
   return(0);
+ if((*o)->rr_reloc_dir != NULL)
+   free((*o)->rr_reloc_dir);
+ if((*o)->prep_partition != NULL)
+   free((*o)->prep_partition);
+ if((*o)->efi_boot_partition != NULL)
+   free((*o)->efi_boot_partition);
+ for(i= 0; i < Libisoburn_max_appended_partitionS; i++)
+   if((*o)->appended_partitions[i] != NULL)
+     free((*o)->appended_partitions[i]);
+ if ((*o)->system_area_data != NULL)
+     free((*o)->system_area_data);
 free(*o);
 *o= NULL;
 return(1);
@ -887,6 +1153,11 @@ int isoburn_igopt_set_extensions(struct isoburn_imgen_opts *o, int ext)
 o->aaip= !!(ext & 32);
 o->session_md5= !!(ext & 64);
 o->file_md5= (ext & (128 | 256)) >> 7;
+ o->no_emul_toc= !!(ext & 512);
+ o->will_cancel= !!(ext & 1024);
+ o->old_empty= !!(ext & 2048);
+ o->hfsplus= !!(ext & 4096);
+ o->fat= !!(ext & 8192);
 return(1);
 }

@ -895,18 +1166,23 @@ int isoburn_igopt_get_extensions(struct isoburn_imgen_opts *o, int *ext)
 {
 *ext= (!!o->rockridge) | ((!!o->joliet)<<1) | ((!!o->iso1999)<<2) |
       ((!!o->hardlinks) << 3) | ((!!o->aaip) << 5) |
-       ((!!o->session_md5) << 6) | ((o->file_md5 & 3) << 7);
+       ((!!o->session_md5) << 6) | ((o->file_md5 & 3) << 7) |
+       ((!!o->no_emul_toc) << 9) | ((o->will_cancel) << 10) |
+       ((!!o->old_empty) << 11) | ((!!o->hfsplus) << 12) |
+       ((!!o->fat) << 13);
 return(1);
 }


 int isoburn_igopt_set_relaxed(struct isoburn_imgen_opts *o, int relax)
 {
- o->omit_version_numbers= !!(relax&1);
+ o->omit_version_numbers= (!!(relax&1)) |
+                          (2 * !!(relax & isoburn_igopt_only_iso_versions));
 o->allow_deep_paths= !!(relax&2);
 o->allow_longer_paths= !!(relax&4);
 o->max_37_char_filenames= !!(relax&8);
- o->no_force_dots= !!(relax&16);
+ o->no_force_dots= (!!(relax&16)) |
+                   (2 * !!(relax & isoburn_igopt_no_j_force_dots));
 o->allow_lowercase= !!(relax&32);
 o->allow_full_ascii= !!(relax&64);
 o->joliet_longer_paths= !!(relax&128);
@ -914,6 +1190,11 @@ int isoburn_igopt_set_relaxed(struct isoburn_imgen_opts *o, int relax)
 o->rrip_version_1_10= !!(relax & isoburn_igopt_rrip_version_1_10);
 o->dir_rec_mtime= !!(relax & isoburn_igopt_dir_rec_mtime);
 o->aaip_susp_1_10= !!(relax & isoburn_igopt_aaip_susp_1_10);
+ o->allow_dir_id_ext= !!(relax & isoburn_igopt_allow_dir_id_ext);
+ o->joliet_long_names= !!(relax & isoburn_igopt_joliet_long_names);
+ o->joliet_rec_mtime= !!(relax & isoburn_igopt_joliet_rec_mtime);
+ o->iso1999_rec_mtime= !!(relax & isoburn_igopt_iso1999_rec_mtime);
+ o->allow_7bit_ascii= !!(relax & isoburn_igopt_allow_7bit_ascii);
 return(1);
 }

@ -922,10 +1203,93 @@ int isoburn_igopt_get_relaxed(struct isoburn_imgen_opts *o, int *relax)
 {
 *relax= (!!o->omit_version_numbers)    | ((!!o->allow_deep_paths)<<1) |
         ((!!o->allow_longer_paths)<<2) | ((!!o->max_37_char_filenames)<<3) |
-         ((!!o->no_force_dots)<<4)      | ((!!o->allow_lowercase)<<5) |
+         ((!!(o->no_force_dots & 1))<<4)| ((!!o->allow_lowercase)<<5) |
         ((!!o->allow_full_ascii)<<6)   | ((!!o->joliet_longer_paths)<<7) |
         ((!!o->always_gmt)<<8)         | ((!!o->rrip_version_1_10)<<9) |
-         ((!!o->dir_rec_mtime)<<10)     | ((!!o->aaip_susp_1_10)<<11);
+         ((!!o->dir_rec_mtime)<<10)     | ((!!o->aaip_susp_1_10)<<11) |
+         ((!!(o->omit_version_numbers & 2))<<12) |
+         ((!!(o->no_force_dots & 2))<<13) |
+         ((!!o->allow_dir_id_ext) << 14) |
+         ((!!o->joliet_long_names) << 15) |
+         ((!!o->joliet_rec_mtime) << 16) |
+         ((!!o->iso1999_rec_mtime) << 17) |
+         ((!!o->allow_full_ascii) << 18);
+ return(1);
+}
+
+
+int isoburn_igopt_set_rr_reloc(struct isoburn_imgen_opts *o, char *name,
+                               int flags)
+{
+ if(o->rr_reloc_dir != name) {
+   if(o->rr_reloc_dir != NULL)
+     free(o->rr_reloc_dir);
+   o->rr_reloc_dir= NULL;
+   if(name != NULL) {
+     o->rr_reloc_dir= strdup(name);
+     if(o->rr_reloc_dir == NULL) {
+       isoburn_msgs_submit(NULL, 0x00060000,
+                         "Cannot allocate memory for image generation options",
+                          0, "FATAL", 0);
+       return(-1);
+     }
+   }
+ }
+ o->rr_reloc_flags = flags & 1;
+ return 1;
+}
+
+
+int isoburn_igopt_get_rr_reloc(struct isoburn_imgen_opts *o, char **name,
+                               int *flags)
+{
+ *name= o->rr_reloc_dir;
+ *flags= o->rr_reloc_flags;
+ return(1);
+}
+
+
+int isoburn_igopt_set_untranslated_name_len(struct isoburn_imgen_opts *o,
+                                            int len)
+{
+ int ret;
+ IsoWriteOpts *opts = NULL;
+ char *msg= NULL;
+
+ msg= calloc(1, 160);
+ if(msg == NULL)
+   {ret= -1; goto ex;}
+
+ ret= iso_write_opts_new(&opts, 0);
+ if(ret < 0) {
+   isoburn_msgs_submit(NULL, 0x00060000,
+                 "Cannot create libisofs write options object", 0, "FATAL", 0);
+   {ret= 0; goto ex;}
+ }
+ ret= iso_write_opts_set_untranslated_name_len(opts, len);
+ if(ret < 0) {
+   ret= iso_write_opts_set_untranslated_name_len(opts, -1);
+   sprintf(msg,
+  "Improper value for maximum length of untranslated names (%d <-> -1 ... %d)",
+           len, ret);
+   isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "FAILURE", 0);
+   iso_write_opts_free(opts);
+   {ret= 0; goto ex;}
+ }
+ o->untranslated_name_len= ret; /* Normalized len value */
+ iso_write_opts_free(opts);
+ ret= 1;
+ex:;
+ if(msg != NULL)
+   free(msg);
+ return(ret);
+}
+
+
+int isoburn_igopt_get_untranslated_name_len(struct isoburn_imgen_opts *o,
+                                            int *len)
+{
+ *len = o->untranslated_name_len;
 return(1);
 }

@ -1061,3 +1425,301 @@ int isoburn_igopt_get_scdbackup_tag(struct isoburn_imgen_opts *o,
 return(1);
 }

+
+int isoburn_igopt_set_system_area(struct isoburn_imgen_opts *opts,
+                                  char data[32768], int options)
+{
+ if (data == NULL) { /* Disable */
+   if (opts->system_area_data != NULL)
+     free(opts->system_area_data);
+   opts->system_area_data = NULL;
+ } else {
+   if (opts->system_area_data == NULL) {
+     opts->system_area_data = calloc(32768, 1);
+     if (opts->system_area_data == NULL)
+       return(-1);
+   }
+   memcpy(opts->system_area_data, data, 32768);
+ }
+ opts->system_area_options = options & 0x3fff;
+ return(1);
+}
+
+
+int isoburn_igopt_get_system_area(struct isoburn_imgen_opts *opts, 
+                                  char data[32768], int *options)
+{
+ *options= opts->system_area_options;
+ if(opts->system_area_data == NULL)
+   return(0);
+ memcpy(data, opts->system_area_data, 32768);
+ return(1);
+}
+
+
+int isoburn_igopt_set_pvd_times(struct isoburn_imgen_opts *opts,
+                        time_t vol_creation_time, time_t vol_modification_time,
+                        time_t vol_expiration_time, time_t vol_effective_time,
+                        char *vol_uuid)
+{
+ opts->vol_creation_time = vol_creation_time;
+ opts->vol_modification_time = vol_modification_time;
+ opts->vol_expiration_time = vol_expiration_time;
+ opts->vol_effective_time = vol_effective_time;
+ strncpy(opts->vol_uuid, vol_uuid, 16);
+ opts->vol_uuid[16] = 0;
+ return(1);
+}
+
+
+int isoburn_igopt_get_pvd_times(struct isoburn_imgen_opts *opts,
+                      time_t *vol_creation_time, time_t *vol_modification_time,
+                      time_t *vol_expiration_time, time_t *vol_effective_time,
+                      char vol_uuid[17])
+{
+ *vol_creation_time = opts->vol_creation_time;
+ *vol_modification_time = opts->vol_modification_time;
+ *vol_expiration_time = opts->vol_expiration_time;
+ *vol_effective_time = opts->vol_effective_time;
+ strcpy(vol_uuid, opts->vol_uuid);
+ return(1);
+}
+
+
+int isoburn_igopt_set_part_offset(struct isoburn_imgen_opts *opts,
+                                  uint32_t block_offset_2k,
+                                  int secs_512_per_head, int heads_per_cyl)
+{
+ if (block_offset_2k > 0 && block_offset_2k < 16)
+   return(0);
+ opts->partition_offset = block_offset_2k;
+ opts->partition_secs_per_head = secs_512_per_head;
+ opts->partition_heads_per_cyl = heads_per_cyl;
+ return(1);
+}
+
+
+int isoburn_igopt_get_part_offset(struct isoburn_imgen_opts *opts,
+                                  uint32_t *block_offset_2k,
+                                  int *secs_512_per_head, int *heads_per_cyl)
+{
+ *block_offset_2k = opts->partition_offset;
+ *secs_512_per_head = opts->partition_secs_per_head;
+ *heads_per_cyl = opts->partition_heads_per_cyl;
+ return 1;
+}
+
+
+int isoburn_igopt_attach_jte(struct isoburn_imgen_opts *opts,
+                             void *libjte_handle)
+{
+ opts->libjte_handle = libjte_handle;
+ return 1;
+}
+
+
+int isoburn_igopt_detach_jte(struct isoburn_imgen_opts *opts,
+                             void **libjte_handle)
+{
+ if(libjte_handle != NULL)
+   *libjte_handle = opts->libjte_handle;
+ opts->libjte_handle = NULL;
+ return 1;
+}
+
+
+int isoburn_igopt_set_tail_blocks(struct isoburn_imgen_opts *opts,
+                                  uint32_t num_blocks)
+{
+  opts->tail_blocks = num_blocks;
+  return 1;
+}
+
+int isoburn_igopt_get_tail_blocks(struct isoburn_imgen_opts *opts,
+                                  uint32_t *num_blocks)
+{
+  *num_blocks = opts->tail_blocks;
+  return 1;
+}
+
+
+int isoburn_igopt_set_prep_partition(struct isoburn_imgen_opts *o,
+                                     char *path, int flag)
+{
+ if(o->prep_partition != NULL)
+   free(o->prep_partition);
+ o->prep_partition= NULL;
+ if(path != NULL) {
+   o->prep_partition= strdup(path);
+   if(o->prep_partition == NULL) {
+     isoburn_report_iso_error(ISO_OUT_OF_MEM, "Out of memory", 0, "FATAL", 0);
+     return(-1);
+   }
+ }
+ return(1);
+}
+
+
+int isoburn_igopt_get_prep_partition(struct isoburn_imgen_opts *opts,
+                                     char **path, int flag)
+{
+ *path= opts->prep_partition;
+ return(1);
+}
+
+
+int isoburn_igopt_set_efi_bootp(struct isoburn_imgen_opts *o,
+                                char *path, int flag)
+{
+ if(o->efi_boot_partition != NULL)
+   free(o->efi_boot_partition);
+ o->efi_boot_partition= NULL;
+ if(path != NULL) {
+   o->efi_boot_partition= strdup(path);
+   if(o->efi_boot_partition == NULL) {
+     isoburn_report_iso_error(ISO_OUT_OF_MEM, "Out of memory", 0, "FATAL", 0);
+     return(-1);
+   }
+ }
+ return(1);
+}
+
+
+int isoburn_igopt_get_efi_bootp(struct isoburn_imgen_opts *opts,
+                                char **path, int flag)
+{
+ *path= opts->efi_boot_partition;
+ return(1);
+}
+
+
+int isoburn_igopt_set_partition_img(struct isoburn_imgen_opts *opts,
+                                  int partition_number, uint8_t partition_type,
+                                  char *image_path)
+{
+ char msg[80];
+
+ if (partition_number < 1 ||
+     partition_number > Libisoburn_max_appended_partitionS) {
+   sprintf(msg, "Partition number is out of range (1 ... %d)",
+           Libisoburn_max_appended_partitionS);
+   isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "FAILURE", 0);
+   return(0);
+ }
+ if (opts->appended_partitions[partition_number - 1] != NULL)
+   free(opts->appended_partitions[partition_number - 1]);
+ opts->appended_partitions[partition_number - 1] = strdup(image_path);
+ if (opts->appended_partitions[partition_number - 1] == NULL)
+   return(-1);
+ opts->appended_part_types[partition_number - 1] = partition_type;
+ return(1);
+}
+
+
+int isoburn_igopt_get_partition_img(struct isoburn_imgen_opts *opts,
+                                    int num_entries,
+                                    uint8_t partition_types[],
+                                    char *image_paths[])
+{
+ int i, max_entry= 0;
+
+ for(i= 0; i < num_entries; i++)
+   image_paths[i]= NULL;
+ for(i= 0; i < Libisoburn_max_appended_partitionS; i++) {
+   if(opts->appended_partitions[i] == NULL)
+ continue;
+   if(i < num_entries) {
+     image_paths[i]= opts->appended_partitions[i];
+     partition_types[i]= opts->appended_part_types[i];
+   }
+   max_entry= i + 1;
+ }
+ return(max_entry);
+}
+
+
+int isoburn_igopt_set_disc_label(struct isoburn_imgen_opts *opts, char *label)
+{
+    strncpy(opts->ascii_disc_label, label, Libisoburn_disc_label_sizE - 1);
+    opts->ascii_disc_label[Libisoburn_disc_label_sizE - 1] = 0;
+    return(1);
+}
+
+
+int isoburn_igopt_get_disc_label(struct isoburn_imgen_opts *opts, char **label)
+{
+    *label= opts->ascii_disc_label;
+    return(1);
+}
+
+
+int isoburn_igopt_set_hfsp_serial_number(struct isoburn_imgen_opts *opts,
+                                         uint8_t serial_number[8])
+{
+ memcpy(opts->hfsp_serial_number, serial_number, 8);
+ return(1);
+}
+
+
+int isoburn_igopt_get_hfsp_serial_number(struct isoburn_imgen_opts *opts,
+                                         uint8_t serial_number[8])
+{
+ memcpy(serial_number, opts->hfsp_serial_number, 8);
+ return(1);
+}
+
+
+int isoburn_igopt_set_hfsp_block_size(struct isoburn_imgen_opts *opts,
+                                      int hfsp_block_size, int apm_block_size)
+{
+ char msg[80];
+
+ msg[0]= 0;
+ if(hfsp_block_size != -1) {
+   if(hfsp_block_size != 0 && hfsp_block_size != 512 &&
+       hfsp_block_size != 2048) {
+     sprintf(msg, "Not a supported HFS+ size (%d <-> 0, 512, 2048)",
+                  hfsp_block_size);
+     isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "FAILURE", 0);
+   }
+   opts->hfsp_block_size = hfsp_block_size;
+ }
+ if(apm_block_size != -1) {
+   if(apm_block_size != 0 && apm_block_size != 512 && apm_block_size != 2048) {
+     sprintf(msg, "Not a supported APM block size (%d <-> 0, 512, 2048)",
+                  apm_block_size);
+     isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "FAILURE", 0);
+   }
+   opts->apm_block_size = apm_block_size;
+ }
+ if(msg[0])
+   return(0);
+ return(1);
+}
+
+
+int isoburn_igopt_get_hfsp_block_size(struct isoburn_imgen_opts *opts,
+                                     int *hfsp_block_size, int *apm_block_size)
+{
+ *hfsp_block_size= opts->hfsp_block_size;
+ *apm_block_size= opts->apm_block_size;
+ return(1);
+}
+
+
+int isoburn_igopt_set_write_type(struct isoburn_imgen_opts *opts, int do_tao)
+{
+ if(do_tao < -1 || do_tao > 1)
+   return(0);
+ opts->do_tao= do_tao;
+ return(1);
+}
+
+
+int isoburn_igopt_get_write_type(struct isoburn_imgen_opts *opts, int *do_tao)
+{
+ *do_tao= opts->do_tao;
+ return(1);
+}
+
+
--- a/libisoburn/isoburn.h
+++ b/libisoburn/isoburn.h
@ -2,7 +2,7 @@
 /*
  Class struct of libisoburn.

-  Copyright 2007 - 2010 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+  Copyright 2007 - 2012 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
                    and Thomas Schmitt <scdbackup@gmx.net>
  Provided under GPL version 2 or later.
 */
@ -12,7 +12,13 @@


 /* for uint8_t */
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif

 /* For emulated TOC of overwriteable media.
   Provides minimal info for faking a struct burn_toc_entry.
@ -22,7 +28,6 @@ struct isoburn_toc_entry {
 int track_no; /* point */
 int start_lba;
 int track_blocks;
-
 char *volid; /* For caching a volume id from emulated toc on overwriteables */

 struct isoburn_toc_entry *next;
@ -36,11 +41,26 @@ int isoburn_toc_entry_new(struct isoburn_toc_entry **objpt,
 int isoburn_toc_entry_destroy(struct isoburn_toc_entry **o, int flag);


-/* Size of target_iso_head which is to be written during
-   isoburn_activate_session()
+/* Minimal size of target_iso_head which is to be written during
+   isoburn_activate_session().
+   Within this size there is everything that is needed for image access with
+   no partition offset. The actual target_iso_head buffer must be larger by
+   the evential partition offset.
 */
 #define Libisoburn_target_head_sizE (32*2048)

+
+/* Maximum number of appended partitions. Effectively usable number depends
+   on system area type.
+*/
+#define Libisoburn_max_appended_partitionS 8
+
+/*
+  Maximum length of a disc label text plus 1.
+*/
+#define Libisoburn_disc_label_sizE 129
+
+
 struct isoburn {


@ -48,9 +68,9 @@ struct isoburn {
    Most isoburn calls will use a burn_drive as object handle */
 struct burn_drive *drive;

- /* -1= inappropriate media state detected
-    0= libburn multi-session media, resp. undecided yet
-    1= random access media */
+ /* -1= inappropriate medium state detected
+    0= libburn multi-session medium, resp. undecided yet
+    1= random access medium */
 int emulation_mode;

 /* Although rarely used, libburn can operate on several
@ -92,6 +112,10 @@ struct isoburn {
 */
 enum burn_disc_status fabricated_disc_status;

+ /* To be set if read errors occured during media evaluation.
+ */
+ int media_read_error;
+
 /* Eventual emulated table of content read from the chain of ISO headers
    on overwriteable media.
 */ 
@ -104,13 +128,21 @@ struct isoburn {
 int wrote_well;

 
- /* Buffered ISO head from media (should that become part of
-    ecma119_read_opts ?) */
- uint8_t target_iso_head[Libisoburn_target_head_sizE];
+ /* ISO head buffer to be filled by write run */
+ int target_iso_head_size;
+ uint8_t *target_iso_head;
+
+ /* The 2k offset which was read from a loaded image.
+ */
+ uint32_t loaded_partition_offset;
+ 

 /* Libisofs image context */
 IsoImage *image;

+ /* The start LBA of the image */
+ int image_start_lba;
+
 /* The block data source from which the existing image is read.
 */
 IsoDataSource *iso_data_source;
@ -132,6 +164,9 @@ struct isoburn {
 void *msgs_submit_handle;  /* specific to application method */
 int msgs_submit_flag;      /* specific to application method */

+ /* Forwarding an image generation option to the burn wrapper */
+ int do_tao;
+ 
 };


@ -185,7 +220,7 @@ int isoburn_invalidate_iso(struct isoburn *o, int flag);
                 with no emulation activated by isoburn.
    @param drive The drive to be searched for
    @param flag  unused yet
-    @return -1 unsuitable media, 0 generic media, 1 emulated media.
+    @return -1 unsuitable medium, 0 generic medium, 1 emulated medium.
 */
 int isoburn_find_emulator(struct isoburn **pt,
                          struct burn_drive *drive, int flag);
@ -197,7 +232,7 @@ int isoburn_msgs_submit(struct isoburn *o, int error_code, char msg_text[],
                        int os_errno, char severity[], int flag);

 /** Set the start address for an emulated add-on session. The value will
-    be rounded up to the alignment necessary for the media. The aligned
+    be rounded up to the alignment necessary for the medium. The aligned
    value will be divided by 2048 and then put into  o->nwa .
    @param o     The isoburn object to be programmed.
    @param value The start address in bytes
@ -222,12 +257,27 @@ int isoburn_get_msc2(struct isoburn *o,
 /** Get a data source suitable for read from a drive using burn_read_data()
    function.
    @param d drive to read from. Must be grabbed.
+    @param displacement will be added or subtracted to any block address
+    @param displacement_sign  +1 = add , -1= subtract , else keep unaltered
    @return the data source, NULL on error. Must be freed with libisofs
            iso_data_source_unref() function. Note: this doesn't release
            the drive.
 */
 IsoDataSource *
-isoburn_data_source_new(struct burn_drive *d);
+isoburn_data_source_new(struct burn_drive *d,
+                         uint32_t displacement, int displacement_sign,
+                         int cache_tiles, int tile_blocks);
+
+/** Default settings for above cache_tiles, tile_blocks in newly created
+    struct isoburn_read_opts.
+*/
+#define Libisoburn_default_cache_tileS 32
+#define Libisoburn_default_tile_blockS 32
+
+/** Maximum size of the cache in 2 kB blocks (1 GB)
+*/
+#define Libisoburn_cache_max_sizE (1024 * 512)
+

 /** Disable read capabilities of a data source which was originally created
    by isoburn_data_source_new(). After this any attempt to read will yield
@ -243,6 +293,18 @@ isoburn_data_source_new(struct burn_drive *d);
 int isoburn_data_source_shutdown(IsoDataSource *src, int flag);


+/** Check whether the size of target_iso_head matches the given partition
+    offset. Eventually adjust size.
+*/
+int isoburn_adjust_target_iso_head(struct isoburn *o,
+                                   uint32_t offst, int flag);
+
+
+/** Initialize the root directory attributes of a freshly created image.
+*/
+int isoburn_root_defaults(IsoImage *image, int flag);
+
+
 /**
 * Options for image reading.
   (Comments here may be outdated. API getter/setter function descriptions
@ -250,6 +312,9 @@ int isoburn_data_source_shutdown(IsoDataSource *src, int flag);
    minor correction only.)
 */
 struct isoburn_read_opts {
+    int cache_tiles; /* number of cache tiles */
+    int cache_tile_blocks;
+
    unsigned int norock:1; /*< Do not read Rock Ridge extensions */
    unsigned int nojoliet:1; /*< Do not read Joliet extensions */
    unsigned int noiso1999:1; /*< Do not read ISO 9660:1999 enhanced tree */
@ -263,7 +328,7 @@ struct isoburn_read_opts {
    unsigned int noino:1;    /* Discard eventual PX inode numbers */

    /* ts A90810 */
-    unsigned int nomd5:1;    /* Do not read eventual MD5 array */
+    unsigned int nomd5:2;    /* Do not read eventual MD5 array */

    unsigned int preferjoliet:1; 
                /*< When both Joliet and RR extensions are present, the RR
@ -306,6 +371,9 @@ struct isoburn_read_opts {
    uint32_t size; /**< Will be filled with the size (in 2048 byte block) of 
                    *   the image, as reported in the PVM. */
    unsigned int pretend_blank:1; /* always create empty image */
+
+    uint32_t displacement;
+    int displacement_sign;
 };


@ -319,12 +387,16 @@ struct isoburn_imgen_opts {

    /* Options for image generation */

+    int will_cancel :1;
+
    int level;  /**< ISO level to write at. */
    
    /** Which extensions to support. */
    unsigned int rockridge :1;
    unsigned int joliet :1;
    unsigned int iso1999 :1;
+    unsigned int hfsplus :1;
+    unsigned int fat :1;

    /* Whether to mark suitable IsoNode as hardlinks in RRIP PX */
    unsigned int hardlinks :1;
@ -336,10 +408,22 @@ struct isoburn_imgen_opts {
    unsigned int session_md5 :1;

    /* Produce and write MD5 checksums for each single IsoFile.
-       See parameter files of iso_write_opts_set_record_md5().
+       See parameter "files" of iso_write_opts_set_record_md5().
     */
    unsigned int file_md5 :2;

+    /* On overwriteable media or random access files do not write the first
+       session to LBA 32, but rather to LBA 0 directly.
+     */
+    unsigned int no_emul_toc :1;
+
+    /* For empty files, symbolic links, and devices use the old ECMA-119 block
+       addresses in the range [0,31] rather than the address of the dedicated
+       empty block.
+    */
+    unsigned int old_empty :1;
+
+
    /* relaxed constraints */

    /*
@ -347,17 +431,52 @@ struct isoburn_imgen_opts {
     * but it is supposed to work on most moderns systems. Use with caution.
     */

+    /*
+     * Extra Caution: This option breaks any assumptions about names that
+     *                are supported by ECMA-119 specifications.
+     * Omit any translation which would make a file name compliant to the
+     * ECMA-119 rules. This includes and exceeds omit_version_numbers,
+     * max_37_char_filenames, no_force_dots bit0, allow_lowercase.
+     */
+    unsigned int untranslated_name_len;
+
+    /*
+     * Convert directory names for ECMA-119 similar to other file names, but do
+     * not force a dot or add a version number.
+     * This violates ECMA-119 by allowing one "." and especially ISO level 1
+     * by allowing DOS style 8.3 names rather than only 8 characters.
+     * (mkisofs and its clones seem to do this violation.)
+     */
+    unsigned int allow_dir_id_ext :1;
+
    /**
     * Omit the version number (";1") at the end of the ISO-9660 identifiers.
     * Version numbers are usually not used.
+     *      bit0= omit version number with ECMA-119 and Joliet
+     *      bit1= omit version number with Joliet alone
     */
-    unsigned int omit_version_numbers :1;
+    unsigned int omit_version_numbers :2;

    /**
     * Allow ISO-9660 directory hierarchy to be deeper than 8 levels.
     */
    unsigned int allow_deep_paths :1;

+    /**
+     * If not allow_deep_paths is in effect, then it may become
+     * necessary to relocate directories so that no ECMA-119 file path
+     * has more than 8 components. These directories are grafted into either
+     * the root directory of the ISO image or into a dedicated relocation
+     * directory. For details see libisofs.h, iso_write_opts_set_rr_reloc().
+     */
+    char *rr_reloc_dir;       /* IsoNode name in root directory. NULL or
+                                 empty text means root itself. */
+    int rr_reloc_flags;       /* bit0= mark auto-created rr_reloc_dir by RE
+                                 bit1= not settable via API (used internally)
+                              */
+
+
+
    /**
     * Allow path in the ISO-9660 tree to have more than 255 characters.
     */
@ -375,8 +494,10 @@ struct isoburn_imgen_opts {
     * ISO-9660 forces filenames to have a ".", that separates file name from
     * extension. libisofs adds it if original filename doesn't has one. Set
     * this to 1 to prevent this behavior
+     *      bit0= no forced dot with ECMA-119
+     *      bit1= no forced dot with Joliet
     */
-    unsigned int no_force_dots :1;
+    unsigned int no_force_dots :2;

    /**
     * Allow lowercase characters in ISO-9660 filenames. By default, only
@ -390,11 +511,24 @@ struct isoburn_imgen_opts {
     */
    unsigned int allow_full_ascii :1;

+    /**
+     * Like allow_full_ascii, but only allowing 7-bit characters.
+     * Lowercase letters get mapped to uppercase if not allow_lowercase is set.
+     * Gets overridden if allow_full_ascii is enabled.
+     */
+    unsigned int allow_7bit_ascii :1;
+
    /**
     * Allow paths in the Joliet tree to have more than 240 characters.
     */
    unsigned int joliet_longer_paths :1;

+    /**
+     * Allow leaf names in the Joliet tree to have up to 103 characters
+     * rather than 64.
+     */
+    unsigned int joliet_long_names :1;
+
    /**
     * Store timestamps as GMT rather than in local time.
     */
@ -410,8 +544,11 @@ struct isoburn_imgen_opts {
    /**
     * Store as ECMA-119 Directory Record timestamp the mtime
     * of the source rather than the image creation time.
+     * The same can be ordered for Joliet and ISO 9660:1999
     */
    unsigned int dir_rec_mtime :1;
+    unsigned int joliet_rec_mtime :1;
+    unsigned int iso1999_rec_mtime :1;

    /**
     * Write AAIP as extension according to SUSP 1.10 rather than SUSP 1.12.
@ -459,7 +596,7 @@ struct isoburn_imgen_opts {
    int fifo_size;


-    /** Output value: Block address of session start as evaluated from media
+    /** Output value: Block address of session start as evaluated from medium
                      and other options by libisoburn and libburn.
        If <0 : Invalid
        If >=0: Valid block number. Block size is always 2 KiB.
@ -488,6 +625,81 @@ struct isoburn_imgen_opts {
    char scdbackup_tag_time[19];
    char *scdbackup_tag_written;

+
+    /* Content of an embedded boot image. Valid if not NULL.
+     * In that case it must point to a memory buffer at least 32 kB.
+     */
+    char *system_area_data;
+    /*
+     * bit0= make bytes 446 - 512 of the system area a partition
+     *       table which reserves partition 1 from byte 63*512 to the
+     *       end of the ISO image. Assumed are 63 secs/hed, 255 head/cyl.
+     *       (GRUB protective msdos label.)
+     *       This works with and without system_area_data.
+     */
+    int system_area_options;
+
+    /* User settable PVD time stamps */
+    time_t vol_creation_time;
+    time_t vol_modification_time;
+    time_t vol_expiration_time;
+    time_t vol_effective_time;
+    /* To eventually override vol_modification_time by unconverted string
+       and timezone 0 */
+    char vol_uuid[17];
+
+    /* The number of unclaimed 2K blocks before start of partition 1 as of
+       the MBR in system area. If not 0 this will cause double volume
+       descriptor sets and double tree.
+    */
+    uint32_t partition_offset;
+    /* Partition table parameter: 1 to 63, 0= disabled/default */
+    int partition_secs_per_head; 
+    /* 1 to 255, 0= disabled/default */
+    int partition_heads_per_cyl;
+
+    /* Parameters and state of Jigdo Template Export environment.
+    */
+    void *libjte_handle;
+
+    /* A trailing padding of zero bytes which belongs to the image
+    */
+    uint32_t tail_blocks;
+
+    /* Disk file paths of content of PreP partition and EFI system partition */
+    char *prep_partition;
+    char *efi_boot_partition;
+
+    /* Eventual disk file paths of prepared images which shall be appended
+       after the ISO image and described by partiton table entries in a MBR.
+    */
+    char *appended_partitions[Libisoburn_max_appended_partitionS];
+    uint8_t appended_part_types[Libisoburn_max_appended_partitionS];
+
+    /* Eventual name of the non-ISO aspect of the image. E.g. SUN ASCII label.
+     */
+    char ascii_disc_label[Libisoburn_disc_label_sizE];
+
+    /* HFS+ image serial number.
+     * 00...00 means that it shall be generated by libisofs.
+     */
+    uint8_t hfsp_serial_number[8];
+
+    /* Allocation block size of HFS+ : 0= auto , 512, or 2048
+     */
+    int hfsp_block_size;
+
+    /* Block size of and in APM : 0= auto , 512, or 2048
+     */
+    int apm_block_size;
+
+    /* Write mode for optical media:
+     *   0 = auto
+     *   1 = TAO, Incremental, no RESERVE TRACK
+     *  -1 = SAO, DAO, RESERVE TRACK
+     */
+    int do_tao;
+
 };


@ -518,11 +730,14 @@ struct isoburn_imgen_opts {
   Libisoburn_nwa_alignemenT it should be possible to predict the start
   of the next session header.
   The LBA 0 header is written by isoburn_activate_session() already
-   with the first session. So the media is mountable.
+   with the first session. So the medium is mountable.
   A problem arises with DVD-RW in Intermediate State. They cannot be
   written by random access before they were written sequentially.
   In this case, no copy of the session  1 header is maintained and no TOC
   will be possible. Thus writing begins sequentially at LBA 0.
+
+   IMPORTANT: This macro gives the minimal size of an image header. 
+              It has to be enlarged by the eventual partition offset.
 */
 #define Libisoburn_overwriteable_starT \
                                   ((off_t) (Libisoburn_target_head_sizE/2048))
@ -552,6 +767,7 @@ struct isoburn_toc_disc {
 struct isoburn_toc_track *tracks;               /* storage array */
 struct isoburn_toc_track **track_pointers;      /* storage array */
 int session_count;
+ int incomplete_session_count;
 int track_count;
 struct isoburn_toc_entry *toc;
 };
--- a/libisoburn/isofs_wrap.c
+++ b/libisoburn/isofs_wrap.c
@ -6,11 +6,15 @@
 /*
  libisofs related functions of libisoburn.

-  Copyright 2007 - 2010  Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+  Copyright 2007 - 2011  Vreixo Formoso Lopes <metalpain2002@yahoo.es>
                         Thomas Schmitt <scdbackup@gmx.net>
  Provided under GPL version 2 or later.
 */

+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
@ -28,8 +32,8 @@

 #endif /* Xorriso_standalonE */

-#include "isoburn.h"
 #include "libisoburn.h"
+#include "isoburn.h"

 #define BP(a,b) [(b) - (a) + 1]

@ -101,12 +105,38 @@ IsoImage *isoburn_get_attached_image(struct burn_drive *d)
 }


+/* API */
+int isoburn_get_attached_start_lba(struct burn_drive *d)
+{
+ int ret;
+ struct isoburn *o= NULL;
+
+ ret = isoburn_find_emulator(&o, d, 0);
+ if (ret < 0 || o == NULL)
+   return -1;
+ if(o->image == NULL)
+   return -1;
+ return o->image_start_lba;
+}
+
+
 static void isoburn_idle_free_function(void *ignored)
 {
 return;
 }


+int isoburn_root_defaults(IsoImage *image, int flag)
+{
+ IsoNode *root_node;
+ mode_t root_mode= 0755;
+
+ root_node= (IsoNode *) iso_image_get_root(image);
+ iso_node_set_permissions(root_node, root_mode);
+ return(1);
+}
+
+
 /* API function. See libisoburn.h
 */
 int isoburn_read_image(struct burn_drive *d,
@ -117,22 +147,25 @@ int isoburn_read_image(struct burn_drive *d,
 IsoReadOpts *ropts= NULL;
 IsoReadImageFeatures *features= NULL;
 uint32_t ms_block;
- char msg[160];
+ char *msg= NULL;
 enum burn_disc_status status= BURN_DISC_BLANK;
 IsoDataSource *ds= NULL;
 struct isoburn *o= NULL;

+ msg= calloc(1, 160);
+
 if(d != NULL) {
   ret = isoburn_find_emulator(&o, d, 0);
   if (ret < 0 || o == NULL)
-     return 0;
+     {ret= 0; goto ex;}
   status = isoburn_disc_get_status(d);
+   o->image_start_lba= -1;
 }
 if(read_opts==NULL) {
   isoburn_msgs_submit(o, 0x00060000,
                       "Program error: isoburn_read_image: read_opts==NULL",
                       0, "FATAL", 0);
-   return(-1);
+   {ret= -1; goto ex;}
 }
 if (d == NULL || status == BURN_DISC_BLANK || read_opts->pretend_blank) {
 create_blank_image:;
@ -146,45 +179,51 @@ create_blank_image:;
       isoburn_msgs_submit(o, 0x00060000,
                           "Program error: isoburn_read_image: image==NULL",
                           0, "FATAL", 0);
-       return -1;
+       {ret= -1; goto ex;}
     }
     /* create a new image */
     ret = iso_image_new("ISOIMAGE", image);
     if (ret < 0) {
       isoburn_report_iso_error(ret, "Cannot create image", 0, "FATAL", 0);
-       return ret;
+       goto ex;
     }
+     iso_image_set_ignore_aclea(*image,
+                         (!!(read_opts->noacl)) | ((!!read_opts->noea) << 1) );
   } else {
     /* Blank new image for the drive */
     iso_image_unref(o->image);
     ret = iso_image_new("ISOIMAGE", &o->image);
     if (ret < 0) {
       isoburn_report_iso_error(ret, "Cannot create image", 0, "FATAL", 0);
-       return ret;
+       goto ex;
     }
-     if (image) {
+     if (image != NULL) {
       *image = o->image;
       iso_image_ref(*image); /*protects object from premature free*/
     }
-   }
-   iso_image_set_ignore_aclea(*image,
+     iso_image_set_ignore_aclea(o->image,
                         (!!(read_opts->noacl)) | ((!!read_opts->noea) << 1) );
-   return 1;
+
+     ret= isoburn_root_defaults(o->image, 0);
+     if(ret <= 0)
+       goto ex;
+   }
+   {ret= 1; goto ex;}
 }
 
 if (status != BURN_DISC_APPENDABLE && status != BURN_DISC_FULL) {
   isoburn_msgs_submit(o, 0x00060000,
                    "Program error: isoburn_read_image: incorrect disc status",
                    0, "FATAL", 0);
-   return -4;	
+   {ret= -4; goto ex;}
 }
 
- memset((char *) &ropts, 0, sizeof(ropts));
-
 ret = isoburn_disc_get_msc1(d, &int_num);
 if (ret <= 0)
-   return -2;
+   {ret= -2; goto ex;}
 ms_block= int_num;
+ if (o != NULL)
+   o->image_start_lba= ms_block;
 ret = isoburn_read_iso_head(d, int_num, &dummy, NULL, 0);
 if (ret <= 0) {
   sprintf(msg, "No ISO 9660 image at LBA %d. Creating blank image.", int_num);
@ -192,18 +231,43 @@ create_blank_image:;
   goto create_blank_image;
 }

+ if(read_opts->displacement != 0 && abs(read_opts->displacement_sign) == 1) {
+   /* Apply reverse displacement to session start */
+   if(read_opts->displacement_sign == -1) {
+     if(ms_block+ read_opts->displacement < ms_block) {
+displacement_rollover:;
+       sprintf(msg, "Displacement offset leads outside 32 bit range.");
+       isoburn_msgs_submit(o, 0x00060000, msg, 0, "FAILURE", 0);
+       {ret= 0; goto ex;}
+     }
+     ms_block+= read_opts->displacement;
+   } else {
+     if(ms_block < read_opts->displacement)
+       goto displacement_rollover;
+     ms_block-= read_opts->displacement;
+   }
+ }
+
+
 /* create the data source */
 ret = iso_read_opts_new(&ropts, 0);
 if (ret < 0) {
   isoburn_report_iso_error(ret, "Cannot create write opts", 0, "FATAL", 0);
-   return ret;
+   goto ex;
 }
+
 /* Important: do not return until iso_read_opts_free() */
+
 iso_read_opts_set_start_block(ropts, ms_block);
 iso_read_opts_set_no_rockridge(ropts, read_opts->norock);
 iso_read_opts_set_no_aaip(ropts, read_opts->noaaip);
- iso_read_opts_set_no_md5(ropts, read_opts->nomd5);
-
+ if(read_opts->nomd5 == 2)
+   int_num= 2;
+ else if(read_opts->nomd5 == 1)
+   int_num= 1;
+ else
+   int_num= 0;
+ iso_read_opts_set_no_md5(ropts, int_num);
 iso_read_opts_set_new_inos(ropts, read_opts->noino);

 iso_read_opts_set_no_joliet(ropts, read_opts->nojoliet);
@ -215,8 +279,16 @@ create_blank_image:;
 iso_read_opts_set_default_gid(ropts, read_opts->gid);
 iso_read_opts_set_input_charset(ropts, read_opts->input_charset);
 iso_read_opts_auto_input_charset(ropts, read_opts->auto_input_charset);
+ iso_read_opts_load_system_area(ropts, 1);

- ds = isoburn_data_source_new(d);
+ ds = isoburn_data_source_new(d, read_opts->displacement,
+                         read_opts->displacement_sign,
+                         read_opts->cache_tiles, read_opts->cache_tile_blocks);
+ if (ds == NULL) {
+   isoburn_report_iso_error(ret, "Cannot create IsoDataSource object", 0,
+                            "FATAL", 0);
+   ret= -1; goto ex;
+ }
 if(o->iso_data_source!=NULL)
   iso_data_source_unref(o->iso_data_source);
 o->iso_data_source= ds;
@ -229,10 +301,11 @@ create_blank_image:;
 ret = iso_image_import(o->image, ds, ropts, &features);
 iso_tree_set_report_callback(o->image, NULL);
 iso_read_opts_free(ropts);
+ ropts= NULL;

 if (ret < 0) {
   isoburn_report_iso_error(ret, "Cannot import image", 0, "FAILURE", 0);
-   return ret;
+   goto ex;
 }
 /* Important: do not return until free(features) */
 if (image!=NULL) {
@ -244,8 +317,15 @@ create_blank_image:;
 read_opts->hasIso1999 = iso_read_image_features_has_iso1999(features);
 read_opts->hasElTorito = iso_read_image_features_has_eltorito(features);
 read_opts->size = iso_read_image_features_get_size(features);
- iso_read_image_features_destroy(features);
- return 1;
+ ret= 1;
+ex:;
+ if(msg != NULL)
+   free(msg);
+ if(ropts != NULL)
+   iso_read_opts_free(ropts);
+ if(features != NULL)
+    iso_read_image_features_destroy(features);
+ return(ret);
 }


@ -268,10 +348,29 @@ int isoburn_attach_image(struct burn_drive *d, IsoImage *image)
 if(o->image != NULL)
   iso_image_unref(o->image);
 o->image = image;
+ o->image_start_lba = -1;
 return(1);
 }


+/* API */
+int isoburn_attach_start_lba(struct burn_drive *d, int lba, int flag)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret = isoburn_find_emulator(&o, d, 0);
+ if(ret < 0)
+   return ret;
+ if(o == NULL)
+   return 0;
+ if(o->image == NULL)
+   return 0;
+ o->image_start_lba = lba;
+ return 1;
+}
+
+
 /* API function. See libisoburn.h
 */
 int isoburn_activate_session(struct burn_drive *drive)
@ -294,34 +393,153 @@ int isoburn_activate_session(struct burn_drive *drive)
   return 1;
 
 ret = burn_random_access_write(drive, (off_t) 0, (char*)o->target_iso_head, 
-                                Libisoburn_target_head_sizE, 1);
+                                o->target_iso_head_size, 1);

 return ret;
 }


+/** API @since 0.6.2
+*/
+int isoburn_get_img_partition_offset(struct burn_drive *drive,
+                                     uint32_t *block_offset_2k)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret = isoburn_find_emulator(&o, drive, 0);
+ if(ret < 0 || o == NULL)
+   return -1;
+ *block_offset_2k= o->loaded_partition_offset;
+ if(o->loaded_partition_offset == 0)
+   return(0);
+ if(o->target_iso_head_size == (off_t) Libisoburn_target_head_sizE
+                           + (off_t) 2048 * (off_t) o->loaded_partition_offset)
+   return(1);
+ return(2);
+}
+
+
+/* Check for MBR signature and a first partition that starts at a 2k block 
+   and ends where the image ends.
+   If not too large or too small, accept its start as partition offset.
+*/
+static int isoburn_inspect_partition(struct isoburn *o, uint32_t img_size,
+                                     int flag)
+{
+ uint8_t *mbr, *part, *buf= NULL;
+ uint32_t offst, numsec;
+ struct ecma119_pri_vol_desc *pvm;
+ off_t data_count;
+ int ret;
+ char *msg= NULL;
+ static int max_offst= 512 - 32;
+
+ buf= (uint8_t *) calloc(1, 2048);
+ msg= calloc(1, 160);
+ if(buf == NULL || msg == NULL)
+   {ret= -1; goto ex;}
+
+ mbr= o->target_iso_head;
+ part= mbr + 446;
+ if(mbr[510] != 0x55 || mbr[511] != 0xAA)
+   {ret= 2; goto ex;} /* not an MBR */
+
+ /* Does the first partition entry look credible ? */
+ if(part[0] != 0x80 && part[0] != 0x00)
+   {ret= 2; goto ex;} /* Invalid partition status */
+ if(part[1] == 0 && part[2] == 0 && part[3] == 0)
+   {ret= 2; goto ex;} /* Zero C/H/S start address */
+
+ /* Does it match the normal ISO image ? */
+ offst= iso_read_lsb(part + 8, 4);
+ numsec= iso_read_lsb(part + 12, 4);
+ if(offst < 64)
+   {ret= 2; goto ex;} /* Zero or unusably small partition start */
+ if((offst % 4) || (numsec % 4))
+   {ret= 2; goto ex;} /* Not aligned to 2k */
+ if(numsec < 72)
+   {ret= 2; goto ex;} /* No room for volume descriptors */
+ offst/= 4;
+ numsec/= 4;
+ if(offst + numsec != img_size)
+   {ret= 2; goto ex;} /* Partition end does not match image end */
+
+ /* Is there a PVD at the partition start ? */
+ ret = burn_read_data(o->drive, (off_t) (offst + 16) * (off_t) 2048,
+                      (char*) buf, 2048, &data_count, 2);
+ if(ret <= 0)
+   {ret= 2; goto ex;}
+ pvm = (struct ecma119_pri_vol_desc *) buf;
+ if (strncmp((char*) pvm->std_identifier, "CD001", 5) != 0)
+   {ret= 2; goto ex;} /* not a PVD */
+ if (pvm->vol_desc_type[0] != 1 || pvm->vol_desc_version[0] != 1 
+     || pvm->file_structure_version[0] != 1 )
+   {ret= 2; goto ex;} /* failed sanity check */
+
+ if(iso_read_lsb(pvm->vol_space_size, 4) + offst != img_size)
+   {ret= 2; goto ex;} /* Image ends do not match */
+
+ /* Now it is credible. Not yet clear is whether it is acceptable. */
+ o->loaded_partition_offset= offst;
+
+ /* If the partition start is too large: Report but do not accept. */
+ if(offst > (uint32_t) max_offst) {/* Not more than 1 MB of .target_iso_head */
+   sprintf(msg,
+      "Detected partition offset of %.f blocks. Maximum for load buffer is %d",
+      (double) offst, max_offst);
+   isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "WARNING", 0);
+   {ret= 3; goto ex;}
+ }
+
+ /* Accept partition start and adjust buffer size */
+ ret= isoburn_adjust_target_iso_head(o, offst, 0);
+ if(ret <= 0)
+   goto ex;
+
+ ret= 1;
+ex:;
+ if(buf != NULL)
+   free(buf);
+ if(msg != NULL)
+   free(msg);
+ return(ret);
+}
+
+
 /** Initialize the emulation of multi-session on random access media.
    The need for emulation is confirmed already.
    @param o A freshly created isoburn object. isoburn_create_data_source() was
             already called, nevertheless.
+    @param flag bit0= read-only
    @return <=0 error , 1 = success
 */
 int isoburn_start_emulation(struct isoburn *o, int flag)
 {
- int ret, i, capacity = -1, role;
+ int ret, i, capacity = -1, role, dummy;
 off_t data_count, to_read;
 struct burn_drive *drive;
 struct ecma119_pri_vol_desc *pvm;
- 
+ enum burn_disc_status s;
+ char *path= NULL, *msg= NULL;
+
+ path= calloc(1, BURN_DRIVE_ADR_LEN);
+ msg= calloc(1, 2 * BURN_DRIVE_ADR_LEN);
+ if(path == NULL || msg == NULL)
+   {ret= -1; goto ex;} 
+
 if(o==NULL) {
   isoburn_msgs_submit(NULL, 0x00060000,
                       "Program error: isoburn_start_emulation: o==NULL",
                       0, "FATAL", 0);
-   return -1;
+   {ret= -1; goto ex;}
 }

 drive= o->drive;

+ if(flag & 1)
+   o->fabricated_disc_status= BURN_DISC_FULL;
+
 /* We can assume 0 as start block for image.
    The data there point to the most recent session.
 */
@ -329,27 +547,42 @@ int isoburn_start_emulation(struct isoburn *o, int flag)
 ret = burn_get_read_capacity(drive, &capacity, 0);
 if (ret <= 0)
   capacity = -1;
- if (capacity > 0 || role == 2) {
+ if (role == 5) { /* random access write-only medium */
+   s = burn_disc_get_status(drive);
+   o->fabricated_disc_status= s;
+   burn_disc_track_lba_nwa(drive, NULL, 0, &dummy, &(o->nwa));
+   if(o->nwa < o->zero_nwa)
+     o->zero_nwa= 0;
+   {ret= 1; goto ex;}
+ } else if (capacity > 0 || role == 2 || role == 4) {
   /* Might be a block device on a system where libburn cannot determine its
      size.  Try to read anyway. */
-   memset(o->target_iso_head, 0, Libisoburn_target_head_sizE);
-   to_read = Libisoburn_target_head_sizE;
+   to_read = o->target_iso_head_size;
+   memset(o->target_iso_head, 0, to_read);
   if(capacity > 0 && (off_t) capacity * (off_t) 2048 < to_read)
     to_read = (off_t) capacity * (off_t) 2048;
   ret = burn_read_data(drive, (off_t) 0, (char*)o->target_iso_head, 
-                        to_read, &data_count, 2);
+                        to_read, &data_count, 2 | 8);
   if (ret <= 0) {
     /* an error means a disc with no ISO image */
-     if (capacity > 0)
+     o->media_read_error= 1;
+     if (ret == -2) {
+       path[0]= 0;
+       burn_drive_d_get_adr(drive, path);
+       sprintf(msg, "Pseudo drive '%s' does not allow reading", path);
+       isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "NOTE", 0);
+       o->fabricated_disc_status= BURN_DISC_BLANK;
+     } else if (capacity > 0)
       o->fabricated_disc_status= BURN_DISC_FULL;
-     else
-        o->fabricated_disc_status= BURN_DISC_BLANK;
-     return 1;
+     else if(!(flag & 1))
+       o->fabricated_disc_status= BURN_DISC_BLANK;
+     {ret= 1; goto ex;}
   }
 } else {
-   /* No read capacity means blank media */
-   o->fabricated_disc_status= BURN_DISC_BLANK;
-   return 1;
+   /* No read capacity means blank medium */
+   if(!(flag & 1))
+     o->fabricated_disc_status= BURN_DISC_BLANK;
+   {ret= 1; goto ex;}
 }

 /* check first 64K. If 0's, the disc is treated as a blank disc, and thus
@ -359,13 +592,14 @@ int isoburn_start_emulation(struct isoburn *o, int flag)
   --i;

 if (!i) {
-   o->fabricated_disc_status= BURN_DISC_BLANK;
-   return 1;
+   if(!(flag & 1))
+     o->fabricated_disc_status= BURN_DISC_BLANK;
+   {ret= 1; goto ex;}
 }

 pvm = (struct ecma119_pri_vol_desc *)(o->target_iso_head + 16 * 2048);

- if (!strncmp((char*)pvm->std_identifier, "CD001", 5)) {
+ if (strncmp((char*)pvm->std_identifier, "CD001", 5) == 0) {
   off_t size;

   /* sanity check */
@ -373,30 +607,44 @@ int isoburn_start_emulation(struct isoburn *o, int flag)
       || pvm->file_structure_version[0] != 1 ) {
     /* TODO for now I treat this as a full disc */
     o->fabricated_disc_status= BURN_DISC_FULL;
-     return 1;
+     {ret= 1; goto ex;}
   }

   /* ok, PVM found, set size */
   size = (off_t) iso_read_lsb(pvm->vol_space_size, 4);
+   ret= isoburn_inspect_partition(o, (uint32_t) size, 0);
+   if (ret <= 0)
+     goto ex;
   size *= (off_t) 2048; /* block size in bytes */
   isoburn_set_start_byte(o, size, 0);
-   o->fabricated_disc_status= BURN_DISC_APPENDABLE;
- } else if (!strncmp((char*)pvm->std_identifier, "CDXX1", 5)) {
+   if(!(flag & 1))
+     o->fabricated_disc_status= BURN_DISC_APPENDABLE;
+ } else if (strncmp((char*)pvm->std_identifier, "CDXX1", 5) == 0 ||
+            (strncmp((char*)pvm->std_identifier, "CDxx1", 5) == 0 &&
+             pvm->vol_desc_type[0] == 'x')) {

   /* empty image */
   isoburn_set_start_byte(o, o->zero_nwa * 2048, 0);
-   o->fabricated_disc_status= BURN_DISC_BLANK;
+   if(!(flag & 1))
+     o->fabricated_disc_status= BURN_DISC_BLANK;
 } else {
   /* treat any disc in an unknown format as full */
   o->fabricated_disc_status= BURN_DISC_FULL;
 }
- return 1;
+
+ ret= 1;
+ex:;
+ if(path != NULL)
+   free(path);
+ if(msg != NULL)
+   free(msg);
+ return(ret);
 }


-/** Alters and writes the first 64 kB of a "media" to invalidate
+/** Alters and writes the first 64 kB of a "medium" to invalidate
    an ISO image. (It shall stay restorable by skilled humans, though).
-    The result shall especially keep libisoburn from accepting the media
+    The result shall especially keep libisoburn from accepting the medium
    image as ISO filesystem.
    @param o A fully activated isoburn object. isoburn_start_emulation()
             was already called.
--- a/libisoburn/libisoburn.h
+++ b/libisoburn/libisoburn.h
--- a/libisoburn/libisoburn.ver
+++ b/libisoburn/libisoburn.ver
@ -0,0 +1,322 @@
+LIBISOBURN1 {
+global:
+isoburn_activate_session;
+isoburn_attach_image;
+isoburn_attach_start_lba;
+isoburn_cancel_prepared_write;
+isoburn_disc_available_space;
+isoburn_disc_erasable;
+isoburn_disc_erase;
+isoburn_disc_get_msc1;
+isoburn_disc_get_status;
+isoburn_disc_track_lba_nwa;
+isoburn_disc_write;
+isoburn_drive_aquire;
+isoburn_drive_grab;
+isoburn_drive_release;
+isoburn_drive_scan_and_grab;
+isoburn_drive_set_msgs_submit;
+isoburn_drive_wrote_well;
+isoburn_finish;
+isoburn_get_attached_image;
+isoburn_get_attached_start_lba;
+isoburn_get_fifo_status;
+isoburn_get_min_start_byte;
+isoburn_get_mount_params;
+isoburn_igopt_attach_jte;
+isoburn_igopt_destroy;
+isoburn_igopt_detach_jte;
+isoburn_igopt_get_data_start;
+isoburn_igopt_get_disc_label;
+isoburn_igopt_get_effective_lba;
+isoburn_igopt_get_efi_bootp;
+isoburn_igopt_get_extensions;
+isoburn_igopt_get_fifo_size;
+isoburn_igopt_get_hfsp_block_size;
+isoburn_igopt_get_hfsp_serial_number;
+isoburn_igopt_get_level;
+isoburn_igopt_get_out_charset;
+isoburn_igopt_get_over_mode;
+isoburn_igopt_get_over_ugid;
+isoburn_igopt_get_partition_img;
+isoburn_igopt_get_prep_partition;
+isoburn_igopt_get_pvd_times;
+isoburn_igopt_get_relaxed;
+isoburn_igopt_get_rr_reloc;
+isoburn_igopt_get_scdbackup_tag;
+isoburn_igopt_get_sort_files;
+isoburn_igopt_get_system_area;
+isoburn_igopt_get_tail_blocks;
+isoburn_igopt_get_untranslated_name_len;
+isoburn_igopt_get_write_type;
+isoburn_igopt_new;
+isoburn_igopt_set_disc_label;
+isoburn_igopt_set_efi_bootp;
+isoburn_igopt_set_extensions;
+isoburn_igopt_set_fifo_size;
+isoburn_igopt_set_hfsp_block_size;
+isoburn_igopt_set_hfsp_serial_number;
+isoburn_igopt_set_level;
+isoburn_igopt_set_out_charset;
+isoburn_igopt_set_over_mode;
+isoburn_igopt_set_over_ugid;
+isoburn_igopt_set_partition_img;
+isoburn_igopt_set_prep_partition;
+isoburn_igopt_set_pvd_times;
+isoburn_igopt_set_relaxed;
+isoburn_igopt_set_rr_reloc;
+isoburn_igopt_set_scdbackup_tag;
+isoburn_igopt_set_sort_files;
+isoburn_igopt_set_system_area;
+isoburn_igopt_set_tail_blocks;
+isoburn_igopt_set_untranslated_name_len;
+isoburn_igopt_set_write_type;
+isoburn_initialize;
+isoburn_is_compatible;
+isoburn_libburn_req;
+isoburn_libisofs_req;
+isoburn_libjte_req;
+isoburn_needs_emulation;
+isoburn_prepare_blind_grow;
+isoburn_prepare_disc;
+isoburn_prepare_new_image;
+isoburn_read_image;
+isoburn_read_iso_head;
+isoburn_ropt_destroy;
+isoburn_ropt_get_auto_incharset;
+isoburn_ropt_get_data_cache;
+isoburn_ropt_get_default_dirperms;
+isoburn_ropt_get_default_perms;
+isoburn_ropt_get_displacement;
+isoburn_ropt_get_extensions;
+isoburn_ropt_get_input_charset;
+isoburn_ropt_get_size_what;
+isoburn_ropt_new;
+isoburn_ropt_set_auto_incharset;
+isoburn_ropt_set_data_cache;
+isoburn_ropt_set_default_dirperms;
+isoburn_ropt_set_default_perms;
+isoburn_ropt_set_displacement;
+isoburn_ropt_set_extensions;
+isoburn_ropt_set_input_charset;
+isoburn_set_msc1;
+isoburn_set_msgs_submit;
+isoburn_set_read_pacifier;
+isoburn_set_truncate;
+isoburn_sync_after_write;
+isoburn_toc_disc_free;
+isoburn_toc_disc_get_incmpl_sess;
+isoburn_toc_disc_get_sectors;
+isoburn_toc_disc_get_sessions;
+isoburn_toc_drive_get_disc;
+isoburn_toc_session_get_leadout_entry;
+isoburn_toc_session_get_sectors;
+isoburn_toc_session_get_tracks;
+isoburn_toc_track_get_emul;
+isoburn_toc_track_get_entry;
+isoburn_version;
+Xorriso__dispose_words;
+Xorriso__get_patch_level_text;
+Xorriso__is_compatible;
+Xorriso__preset_signal_behavior;
+Xorriso__severity_cmp;
+Xorriso__severity_list;
+Xorriso__version;
+Xorriso_change_is_pending;
+Xorriso_destroy;
+Xorriso_dialog;
+Xorriso_eval_problem_status;
+Xorriso_execute_option;
+Xorriso_fetch_outlists;
+Xorriso_get_problem_status;
+Xorriso_interpreter;
+Xorriso_lst_destroy_all;
+Xorriso_lst_get_next;
+Xorriso_lst_get_prev;
+Xorriso_lst_get_text;
+Xorriso_make_return_value;
+Xorriso_msgs_submit;
+Xorriso_msgs_submit_void;
+Xorriso_new;
+Xorriso_option_abort_on;
+Xorriso_option_abstract_file;
+Xorriso_option_acl;
+Xorriso_option_add;
+Xorriso_option_add_plainly;
+Xorriso_option_alter_date;
+Xorriso_option_append_partition;
+Xorriso_option_application_id;
+Xorriso_option_as;
+Xorriso_option_assert_volid;
+Xorriso_option_auto_charset;
+Xorriso_option_backslash_codes;
+Xorriso_option_ban_stdio_write;
+Xorriso_option_biblio_file;
+Xorriso_option_blank;
+Xorriso_option_boot_image;
+Xorriso_option_calm_drive;
+Xorriso_option_cdi;
+Xorriso_option_cdx;
+Xorriso_option_changes_pending;
+Xorriso_option_charset;
+Xorriso_option_check_md5;
+Xorriso_option_check_media;
+Xorriso_option_check_media_defaults;
+Xorriso_option_chgrpi;
+Xorriso_option_chmodi;
+Xorriso_option_chowni;
+Xorriso_option_clone;
+Xorriso_option_close;
+Xorriso_option_close_damaged;
+Xorriso_option_close_filter_list;
+Xorriso_option_commit;
+Xorriso_option_commit_eject;
+Xorriso_option_compare;
+Xorriso_option_compliance;
+Xorriso_option_copyright_file;
+Xorriso_option_cp_clone;
+Xorriso_option_cpri;
+Xorriso_option_cpx;
+Xorriso_option_cut_out;
+Xorriso_option_data_cache_size;
+Xorriso_option_dev;
+Xorriso_option_devices;
+Xorriso_option_dialog;
+Xorriso_option_disk_dev_ino;
+Xorriso_option_disk_pattern;
+Xorriso_option_displacement;
+Xorriso_option_drive_class;
+Xorriso_option_dummy;
+Xorriso_option_dvd_obs;
+Xorriso_option_early_drive_test;
+Xorriso_option_eject;
+Xorriso_option_end;
+Xorriso_option_errfile_log;
+Xorriso_option_error_behavior;
+Xorriso_option_external_filter;
+Xorriso_option_extract;
+Xorriso_option_extract_cut;
+Xorriso_option_file_size_limit;
+Xorriso_option_find;
+Xorriso_option_follow;
+Xorriso_option_fs;
+Xorriso_option_getfacli;
+Xorriso_option_gid;
+Xorriso_option_grow_blindly;
+Xorriso_option_hardlinks;
+Xorriso_option_help;
+Xorriso_option_hfsplus;
+Xorriso_option_hide;
+Xorriso_option_history;
+Xorriso_option_iso_rr_pattern;
+Xorriso_option_jigdo;
+Xorriso_option_joliet;
+Xorriso_option_launch_frontend;
+Xorriso_option_list_arg_sorting;
+Xorriso_option_list_delimiter;
+Xorriso_option_list_extras;
+Xorriso_option_list_formats;
+Xorriso_option_list_profiles;
+Xorriso_option_list_speeds;
+Xorriso_option_lnsi;
+Xorriso_option_load;
+Xorriso_option_logfile;
+Xorriso_option_lsi;
+Xorriso_option_lsx;
+Xorriso_option_map;
+Xorriso_option_map_l;
+Xorriso_option_mark;
+Xorriso_option_md5;
+Xorriso_option_mkdiri;
+Xorriso_option_mount;
+Xorriso_option_mount_opts;
+Xorriso_option_move;
+Xorriso_option_msg_op;
+Xorriso_option_mvi;
+Xorriso_option_no_rc;
+Xorriso_option_not_leaf;
+Xorriso_option_not_list;
+Xorriso_option_not_mgt;
+Xorriso_option_not_paths;
+Xorriso_option_options_from_file;
+Xorriso_option_osirrox;
+Xorriso_option_overwrite;
+Xorriso_option_pacifier;
+Xorriso_option_padding;
+Xorriso_option_page;
+Xorriso_option_paste_in;
+Xorriso_option_path_list;
+Xorriso_option_pathspecs;
+Xorriso_option_pkt_output;
+Xorriso_option_preparer_id;
+Xorriso_option_print;
+Xorriso_option_print_size;
+Xorriso_option_prog;
+Xorriso_option_prog_help;
+Xorriso_option_prompt;
+Xorriso_option_publisher;
+Xorriso_option_pvd_info;
+Xorriso_option_pwdi;
+Xorriso_option_pwdx;
+Xorriso_option_read_mkisofsrc;
+Xorriso_option_reassure;
+Xorriso_option_report_about;
+Xorriso_option_return_with;
+Xorriso_option_rmi;
+Xorriso_option_rockridge;
+Xorriso_option_rollback;
+Xorriso_option_rom_toc_scan;
+Xorriso_option_rr_reloc_dir;
+Xorriso_option_scdbackup_tag;
+Xorriso_option_scsi_log;
+Xorriso_option_session_log;
+Xorriso_option_setfacli;
+Xorriso_option_setfacl_listi;
+Xorriso_option_setfattri;
+Xorriso_option_setfattr_listi;
+Xorriso_option_set_filter;
+Xorriso_option_signal_handling;
+Xorriso_option_sleep;
+Xorriso_option_speed;
+Xorriso_option_split_size;
+Xorriso_option_status;
+Xorriso_option_status_history_max;
+Xorriso_option_stdio_sync;
+Xorriso_option_stream_recording;
+Xorriso_option_system_id;
+Xorriso_option_tell_media_space;
+Xorriso_option_temp_mem_limit;
+Xorriso_option_toc;
+Xorriso_option_toc_of;
+Xorriso_option_uid;
+Xorriso_option_unregister_filter;
+Xorriso_option_update;
+Xorriso_option_use_readline;
+Xorriso_option_version;
+Xorriso_option_volid;
+Xorriso_option_volset_id;
+Xorriso_option_volume_date;
+Xorriso_option_write_type;
+Xorriso_option_xattr;
+Xorriso_option_zisofs;
+Xorriso_parse_line;
+Xorriso_peek_outlists;
+Xorriso_prescan_args;
+Xorriso_process_errfile;
+Xorriso_process_msg_queues;
+Xorriso_program_arg_bsl;
+Xorriso_pull_outlists;
+Xorriso_push_outlists;
+Xorriso_read_rc;
+Xorriso_set_problem_status;
+Xorriso_sieve_add_filter;
+Xorriso_sieve_big;
+Xorriso_sieve_clear_results;
+Xorriso_sieve_dispose;
+Xorriso_sieve_get_result;
+Xorriso_start_msg_watcher;
+Xorriso_startup_libraries;
+Xorriso_stop_msg_watcher;
+local: *;
+};
+
--- a/releng/CHECKLIST
+++ b/releng/CHECKLIST
@ -0,0 +1,27 @@
+------------------------------------------------------------------------------
+                         http:libburnia-project.org
+------------------------------------------------------------------------------
+
+                         Release Engineering Check List
+
+ TEST: releng 
+       auto_* tests could be run altogether by ./run_all_auto
+       manual_* tests are to be run individually and manually
+ LOGS: http://people.debian.org/~danchev/libburnia/logs/releng/
+
+ TEST: cppcheck - static code checker
+ LOGS: http://people.debian.org/~danchev/libburnia/logs/cppcheck/
+
+ TEST: medistimator - checks the dialog mode of xorriso, size estimation
+       facility, and its ability of processing large trees. Running this
+       requires some specific knowledge of how the tool works, in order to
+       interpret the results and compare them with these from any previous
+       runs. The source is heavily commented.
+ FILE: http://anonscm.debian.org/gitweb/?p=users/danchev/medistimator.git;a=summary
+ LOGS: http://people.debian.org/~danchev/libburnia/logs/medistimator/
+
+ TEST: Debian ISO image builder logs
+ LOGS: http://cdbuilder.debian.org/cdimage-log/
+
+ TEST: Debian build daemon logs - several hardware architectures and kernels
+ LOGS: http://buildd.debian.org
--- a/releng/README
+++ b/releng/README
@ -0,0 +1,297 @@
+------------------------------------------------------------------------------
+                         http:libburnia-project.org
+------------------------------------------------------------------------------
+libisoburn/releng. By George Danchev <danchev@spnet.net>
+                  and Thomas Schmitt <scdbackup@gmx.net>
+
+Test suite for xorriso and libburnia libraries.
+Copyright (C) 2011 - 2012 George Danchev, Thomas Schmitt
+Provided under GPL version 2 or later.
+------------------------------------------------------------------------------
+
+The impatient tester will build libisoburn according to its README and then do
+
+  cd ./releng
+  ./run_all_auto -x ../xorriso/xorriso
+
+More patient testers will first read the following description.
+
+Those who simply lack the interpreter /bin/bash, may do
+  ./change_shell_to_use
+and then retry.
+
+
+                            The test suite
+
+Directory ./releng of libisoburn contains a collection of test scripts and
+auxiliary data. They exercise some typical use cases of building libisoburn
+applications and running the ISO 9660 filesystem manipulation and CD/DVD/BD
+burn program xorriso. 
+
+It is assumed that libburn and libisofs are installed, so that libisoburn
+can be configured and built. It is not mandatory that libisoburn is already
+installed. The tests may use an installed xorriso program as well as a
+freshly built one.
+
+The test scripts explicitely demand /bin/bash as interpreter, although they
+would run on certain other shells too. If you get an error message like
+  ./run_all_auto: not found
+then consider to install /bin/bash.
+If you decide against that, see below "Alternative Shells".
+
+
+There are two groups of test scripts:
+
+  auto_*    gets started and watched by script run_all_auto.
+            These tests have a moderate resource consumption and do
+            not cause mechanical movements of drive trays.
+
+  manual_*  gets started by the user if desired.
+            Manual tests may create larger sets of temporary files,
+            may download test data from the internet, may need
+            system privileges beyond the reach of a sandbox user,
+            and operate the mechanics of a CD drive.
+
+
+                       Running automated tests
+
+The test scripts expect to get run while the working directory is
+  ./releng
+of a libisoburn source tree. E.g.: libisoburn-1.1.4/releng
+They create all their temporary files underneath
+  ./releng/releng_generated_data 
+Some of these files are persistent between tests.
+Nevertheless it is safe to empty ./releng/releng_generated_data after
+tests are done. The directory itself must be kept.
+
+To run the unobtrusive automatic tests, build libisoburn and xorriso,
+go to directory ./releng, and execute
+
+  ./run_all_auto -x ../xorriso/xorriso
+
+or if you want to use an installed xorriso program:
+
+  ./run_all_auto -x $(which xorriso)
+resp.
+  ./run_all_auto -x $(type -p xorriso)
+
+There are several options which work with run_all_auto and any single test.
+  -x  absolute or relative path to xorriso binary to be run.
+  -k  keep self-generated data.
+  -c  cleanup temporary data kept from previous run and exit.
+  -f  simulate failure.
+  -h  print this help text.
+  --  end of general options, begin of test specific options.
+After option "--", there may be given options which are specific to
+particular manually executable test scripts. 
+
+
+                        Manually executable tests
+                 
+Currently there are the following tests which should have the attention of
+the user or require sysadmin considerations before they are run:
+
+./manual_devices -x ../xorriso/xorriso [-- [--dev device_file_to_use]
+                                        [--priv_cmd 'command [arg [arg ...]]']]
+  Exercises listing of all accessible optical drives and the examination of
+  a one of these drives. The user needs the permission to operate the CD
+  drives. This might involve the need for superuser authority.
+  The media tray of the examined drive will get loaded if it is not already.
+  If no option --dev is given, then the user gets asked which of the listed
+  drives to examine more closely.
+  If a privilege command and optional arguments are given with --priv_cmd,
+  then this command and arguments are used to launch the xorriso runs.
+  Command and arguments must be single words and be submitted altogether
+  as one single argument. On Solaris use: --priv_cmd pfexec
+
+./manual_burn -x ../xorriso/xorriso [-- [--dev device_file_to_use]
+                                        [--priv_cmd 'command [arg [arg ...]]']
+                                        [--what ...directory...] [--any_media]]
+  Burns the content of the directory given with --what onto re-usable
+  media: CD-RW, DVD-RW, DVD-RAM, DVD+RW, BD-RE.
+  Other media types get refused, unless option --any_media is given.
+  Data, which are possibly present on the media, get overwritten.
+  The result gets check read and compared with the state of the input
+  directory. MD5 mismatch causes a test failure. Differences to the directory
+  state are reported but still regarded as success.
+  If a privilege command and optional arguments are given with --priv_cmd,
+  then this command and arguments are used to launch the xorriso runs.
+  Command and arguments must be single words and be submitted altogether
+  as one single argument. On Solaris use:
+    --priv_cmd pfexec
+
+./manual_isojigdo -x ../xorriso/xorriso
+  Exercises the production of a bootable Debian GNU/Linux image and its Jigdo
+  files. This test downloads a Debian daily image for i386 of about 270 MB,
+  extracts its content and composes a new image. Thus it needs about 850 MB
+  of disk space in releng/releng_generated_data when unpacked. Adding the daily
+  image size itself, the total space used would peak at about 1.2 GB.
+  This test will only work with GNU xorriso or if libjte was installed already
+  when libisofs was built. Further it needs the program jigit-mkimage. Both
+  are part of package jigit, version >= 1.18, available at:
+    http://www.einval.com/~steve/software/JTE/
+  Currently jigit builds only in GNU environments.
+
+
+Any auto_* script can be run on its own. Some of them demand option -x.
+All general options are accepted.
+
+./auto_cxx
+  Not included in GNU xorriso.
+  Exercises inclusion of xorriso/xorriso.h and libisoburn/libisoburn.h
+  in C++ programs and linking of the libraries. It might be necessary
+  to set compiler options by shell variable CFLAGS before running the test.
+  It might be necessary to hand over the install directory of libburn and
+  libisofs in shell variable LD_LIBRARY_PATH.
+  E.g. if on FreeBSD the include headers libisofs.h , libburn.h are not found:
+    export CFLAGS="-I/usr/local/include"
+  E.g. on GNU/Hurd, where libburn and libisofs are not found by the linker:
+    export LD_LIBRARY_PATH="/usr/local/lib"
+
+./auto_isocontent -x ../xorriso/xorriso
+  Tests whether xorriso is able to record and restore two familes of
+  hard links.
+
+./auto_printsize -x ../xorriso/xorriso
+  Tests how long xorriso needs to compose a medium sized directory tree.
+  If programs mkisofs and/or genisomage are availaible, then the same test
+  is done with them.
+
+
+----------------------------------------------------------------------------
+
+                       What to do with FAIL results
+
+The text output of the automatic tests is recorded in file
+   releng_generated_data/log.run_all_auto
+
+Script ./run_all_auto will detect failure of particular tests and report
+lines from the log file which contain problem indicating keywords:
+  NEVER,ABORT,FATAL,FAILURE,MISHAP,SORRY,WARNING,HINT,FAIL,ERROR,WRONG
+
+If the program messages in log.run_all_auto do not explain the failure,
+please contact mailing list libburn-hackers@pykix.org .
+
+
+----------------------------------------------------------------------------
+
+                          Alternative Shells
+
+If you decided against installing /bin/bash, you may try to use your
+current $SHELL by running
+  ./change_shell_to_use
+which will modify the test scripts named run_all_auto , auto_* ,manual_*.
+
+Known to be suitable are the following shells
+  GNU/Linux: /bin/bash
+  FreeBSD 8: /bin/sh
+  Solaris:   /bin/bash , /bin/i86/ksh93
+In general, the shell should have Bourne shell ancestry.
+
+The script does not choose an interpreter explicitely and is safe to be run
+inline:
+  . ./change_shell_to_use
+One may set any interpreter path by running a sub shell and changing its
+variable SHELL. E.g. by:
+  ( SHELL=/bin/my_shell" ; . ./change_shell_to_use )
+
+
+----------------------------------------------------------------------------
+
+                          Creating a new test script
+
+If you want to provide an own test, manual or auto, then first invent a name
+for it
+  test_name="releng/manual_"...some.name...
+or
+  test_name="releng/auto_"...some.name...
+Then copy file releng/template_new to $test_name.
+Edit $test_name and process any line that begins by "# === TEMPLATE:".
+Do what the line prescribes and then remove it from the script. You are
+not done as long as such a line remains.
+
+Your test must not start if no file
+   ./inc/releng_getopts.inc
+exists, i.e. if the current working directory is not ./releng.
+If your test creates own files on disk, then it must do this underneath
+directory
+   ./releng_generated_data/$test_name (resp. $GEN_DATA_DIR, see below).
+
+In case of failure, issue a line to stdout that begins by the word "FAIL",
+followed by " : " and the name of the test (e.g. $SELF, see below).
+Make sure that the test script finally returns a non-zero exit value.
+This value should be between 1 and 28. Each type of failure should have its
+own exit value.
+Predefined are:
+  31 = Unknown option or unusable argument with known option
+  30 = Unexpected state of own directory for self generated files
+  29 = Not in ./releng directory or missing essential parts of ./releng
+
+When exiting prematurely, make sure to call function cleanup.
+
+
+               Variables, general options, helper functions
+
+The master script run_all_auto sets this variable:
+
+  RELENG_SCRIPT_RUN_BY_RUN_ALL_AUTO
+                    1=supervised, the script is run by run_all_auto script
+                    else=standalone, the script is run in standalone mode 
+
+The code piece inc/releng_getopts.inc should get executed inline at the
+start of a test script. It initializes the following variables and sets
+some of them according to the general options of the test suite:
+
+  SELF              basename $0
+
+  GEN_DATA_DIR      releng_generated_data/${SELF}
+
+  RELENG_XORRISO    Path to xorriso binary. "" or "0" means no xorriso.
+                    Default "0". Adjustable by option -x.
+
+  SIMULATE_FAILURE  0=normal operation, 1=test script shall simulate a failure.
+                    Default 0. Setable to 1 by option -f.
+
+  CLEANUP           0=do not cleanup temporary data, 1=normal operation
+                    Default 1. Setable to 0 by option -k.
+
+  SPECIFIC_HELP     0=normal operation, 1=print help text of script and exit 0
+                    Default 0. Setable to 1 by option -h.
+
+The code piece inc/releng_getopts.inc defines the following functions
+for use by the single tests:
+
+  standalone_or_supervised This is internally called routine to print out
+                           the running mode of the scripts - standalone,
+                           supervised by run_all_auto.
+			   No need to call it from the scripts themselves.
+
+  print_help        Prints the help text for general options.
+
+  check_for_xorriso [-x]
+                    Will exit with value 31 if no path to a xorriso binary
+                    was defined by option -x of ./run_all_auto or a single
+                    test.
+                    Option -x of check_for_xorriso additionally tests whether
+                    the given path leads to an executable program.
+
+  cleanup           Removes the directory tree GEN_DATA_DIR after making
+                    some safety checks.
+
+  boldify           Try to set the terminal mode for future output to a more
+                    noticable style of writing.
+  unboldify         Reset terminal mode to normal style of writing.
+
+
+                             Specific options
+
+Options which are specific to the test should begin with a double dash.
+They may have further arguments.
+Implement them in the prepared interpreter loop which begins after line
+  next_is=ignore
+
+Specific options shall only be interpreted by tests which get run manually.
+If you plan to introduce a specific option, look at the description of
+existing tests whether one of them would match your needs. In that case,
+please re-use the name of that existing option.
+
--- a/releng/TODO
+++ b/releng/TODO
@ -0,0 +1,42 @@
+
+* Manpage examples turned into tests
+  Convert most examples from xorriso(1) manpage into tests.
+
+* Enhance 'auto_isocontent'
+  Extend it to use some more demanding directory tree.
+  MD5s should be checked.
+  All file types as of stat(2) should be tested.
+  Test various comparisons:
+  xorriso provides built-in means for comparison: 
+  xorriso -compare_r disk_path iso_rr_path
+  xorriso -indev my.iso -find /   vs. find input_dir
+  bsdtar -xf my.iso               vs. input_dir
+
+* Test for wrong CD sizes would need a new test and probably an
+  automatic CD changer.
+
+* Library unit tests - investigate the possibility to write some
+  cunit-based tests (http://cunit.sourceforge.net) for both
+  xorriso.h and libisoburn.h API's. The code samples could be put into
+  codesamples/ directory and run by auto_cxx or a separate auto_ script.
+
+* ??? Still to decide:
+  Delete debian-testing-i386-businesscard.iso with ./run_all_auto -c
+  Contra: Currently remaining large files (like downloaded ISO images) are
+  simply left behind to be re-used and a boldified info message is shown
+  so the users can decide for themselves what to remove or leave as well.
+  Pro: Leaving 70 MB of image is quite obtrusive. Option -c is not run
+  under normal circumstances. So it could well be used for total cleanup.
+  Alternative: Specific option --remove_image.
+
+* ??? Still to decide:
+  Have a script ./run_all_manual
+  Contra argument: if a releng sctipt is suitable to be run under a master
+  script run_all*, then this releng script should be put into auto_*
+  namespace , otherwise it is manual_*.
+  Pro: Tests may be manual because they demand lots of resources, not
+  because they need manual attention. In general the run_all_manual script
+  shall spare the user the plight to read the documentation. Instead it
+  shall present the manual tests, give an opportunity to skip the test,
+  and ask for parameters,
+
--- a/releng/auto_cxx
+++ b/releng/auto_cxx
@ -0,0 +1,86 @@
+#!/bin/bash
+
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Licensed under GNU GPL version 2 or later
+
+set -e
+
+not_in_releng_exit() {
+  printf "\nPlease execute the tests from releng directory.\n\n"
+  exit 1
+}
+
+. inc/releng_getopts.inc || not_in_releng_exit
+
+print_specific_help() {
+cat << HLP
+Specific options:
+       none yet.
+Overview:
+ Tests both xorriso/xorriso.h and libisoburn/libisoburn.h
+ APIs for C++ cleanness.
+HLP
+}
+
+if test "$SPECIFIC_HELP" = 1; then
+  print_specific_help
+  exit 0
+fi
+
+# xorriso binary is not needed for that particular test
+SAMPLE_CODE_DIR=codesamples
+CC=g++
+
+# check compiler
+if ! which "${CC}" >/dev/null 2>&1; then
+    printf "\n${SELF}: Not found: ${CC}. Install ${CC}.\n"
+    cleanup
+    exit 5
+fi
+
+# check data dir
+if [ -d "${GEN_DATA_DIR}" ]; then
+ printf "\n${SELF}: directory %s exists!" ${GEN_DATA_DIR}
+ printf "\n${SELF}: use '${SELF} -c' to remove.\n"
+ exit 6
+else
+ mkdir "${GEN_DATA_DIR}"
+fi
+
+# process sample code tests
+ for SMPL in `ls "${SAMPLE_CODE_DIR}"/*.cpp`; do
+   # CMD_CPL="${CC} -I../ -L ../libisoburn/.libs/ ${CFLAGS} -lisoburn -o ${SMPL}.obj ${SMPL}"
+   CMD_CPL="${CC} -c -I../ -I../../libburn -I../../libisofs ${CFLAGS} -o ${SMPL}.obj ${SMPL}"
+   printf "${SELF}: ${CMD_CPL}"
+   set +e
+   ${CMD_CPL}
+   RET_CPL="$?"
+   if [ ${RET_CPL} = 0 -a -f ${SMPL}.obj ]; then
+      mv ${SMPL}.obj ${GEN_DATA_DIR}
+      printf "...ok\n"
+   else
+      printf "\nFAIL : ${SELF}: Compilation of ${SMPL}\n"
+      cleanup
+      exit 7
+   fi
+#   BASE=$(basename ${SMPL}.obj)
+#   printf "${SELF}: Running LD_LIBRARY_PATH=../libisoburn/.libs/:${LD_LIBRARY_PATH} ${GEN_DATA_DIR}/${BASE}"
+#   LD_LIBRARY_PATH=../libisoburn/.libs/:${LD_LIBRARY_PATH} ${GEN_DATA_DIR}/${BASE}
+#   RET_SMPL="$?"
+#   case ${RET_SMPL} in
+#    0)
+#     printf "...ok\n"
+#    ;;
+#    *)
+#     printf "exit code: ${RET_SMPL}\n"
+#     cleanup
+#     exit 8
+#    ;;
+#   esac
+   set -e
+ done
+
+# clean
+cleanup
+
+exit 0
--- a/releng/auto_isocontent
+++ b/releng/auto_isocontent
@ -0,0 +1,400 @@
+#!/bin/bash
+
+# Copyright 2011 Thomas Schmitt <scdbackup@gmx.net>
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Licensed under GNU GPL version 2 or later
+
+# Test the correct handling of hardlinks by xorriso options
+# -update_r , -hardlinks perform_update , and -extract
+# If there is support for ACLs or xattr in xorriso and on the local system,
+# then test recording and restoring of these features.
+
+not_in_releng_exit() {
+  printf "\nPlease execute the tests from releng directory.\n\n"
+  exit 1
+}
+
+. inc/releng_getopts.inc || not_in_releng_exit
+
+print_specific_help() {
+cat << HLP
+Specific options:
+       none yet.
+Overview:
+       Tests ISO image contents by performing various
+       image generation, extractions and comparisons.
+HLP
+}
+
+if test "$SPECIFIC_HELP" = 1; then
+  print_specific_help
+  exit 0
+fi
+
+if [ ! -x $RELENG_XORRISO ]; then
+ print_help
+ printf "\n${SELF}: -x  absolute or relative path to binary to be run.\n\n"
+ exit 31
+fi
+
+# check data dir, if any and after checking -x xorriso
+if [ -d "${GEN_DATA_DIR}" ]; then
+ printf "\n${SELF}: directory %s exists!" ${GEN_DATA_DIR}
+ printf "\n${SELF}: use '${SELF} -c' to remove.\n"
+ exit 8
+else
+ mkdir "${GEN_DATA_DIR}"
+fi
+
+export xorriso=${RELENG_XORRISO}
+export workdir=${GEN_DATA_DIR}
+export image_file="$workdir"/xorriso_hardlinks.iso
+export on_disk="$workdir"/xorriso_hardlinks_test_dir
+export in_iso=""
+export copy_on_disk="$workdir"/xorriso_hardlinks_copy_dir
+export failure=0
+export simulate_failure=${SIMULATE_FAILURE}
+export next_is_xorriso=0
+export next_is_rc=0
+export bad=0
+export report_about="-report_about UPDATE"
+
+test -z "$in_iso" && in_iso="$on_disk"
+
+# mkdir "$workdir" || bad=1
+mkdir "$on_disk" || bad=1
+if test "$bad" = 1
+then
+  echo -e "\nFAIL : ${SELF} : Test environment error : Cannot make directories"
+  exit 3
+fi
+
+
+# All must be set at this point
+printf "\n${SELF}: Setting up $on_disk with several hardlinks\n" >&2
+echo test_content >"$on_disk"/file_1 || exit 1
+echo test_content >"$on_disk"/file_2 || exit 1
+ln "$on_disk"/file_1 "$on_disk"/file_1_link_a || exit 1
+ln "$on_disk"/file_1 "$on_disk"/file_1_link_b || exit 1
+ln "$on_disk"/file_2 "$on_disk"/file_2_link_a || exit 1
+
+# trivial ISO 9660 image validation routine
+is_valid_iso9660() {
+ ISOfile="$1"
+ if ! which file >/dev/null 2>&1; then
+   printf "\nFAIL : ${SELF}: Not found: file. Please install the file(1) utility.\n"
+   failure=1
+   return
+ fi
+ if [ ! -f ${ISOfile} ]; then
+   failure=1
+   printf "\nFAIL : ${SELF} : Not found: ${ISOfile}\n"
+   return
+ fi
+
+ file ${ISOfile}
+ if file ${ISOfile} | grep  "ISO *9660" >/dev/null 2>&1; then
+   printf "\n${SELF}: Resulting ${ISOfile} OK. Looks like ISO 9660 filesystem.\n"
+ else
+   failure=1
+   printf "\nFAIL : ${SELF} : ${ISOfile} DOES NOT look like ISO 9660 filesystem data.\n"
+ fi
+}
+
+# Retrieve and evaluate return value of command run under return_wrapper
+check_xorriso_return() {
+ ret=$(cat "$return_value_file")
+ rm "$return_value_file"
+ if test "$ret" = 0
+ then
+   return 0
+ fi
+ failure=1
+ echo
+ echo "FAIL : ${SELF} : xorriso run exited with value $ret"
+ return 1
+}
+
+# Create test file and find out whether ACLs and/or xattr are available.
+#
+# Users known on GNU/Linux and FreeBSD: root games daemon man
+# Groups                              : daemon games bin sshd sys
+# On both systems, ACLs are manipulated by setfacl/getfacl
+#
+acl_xattr_test_file="$on_disk"/acl_xattr_test_file
+acl_xattr_copy_file="$copy_on_disk"/acl_xattr_test_file
+acl_xattr_test_dir="$on_disk"/acl_xattr_test_dir
+acl_xattr_iso_dir="$in_iso"/acl_xattr_test_dir
+acl_xattr_copy_dir="$copy_on_disk"/acl_xattr_test_dir
+mkdir "$acl_xattr_test_dir"
+echo echo hello world >"$acl_xattr_test_file" || exit 1
+sys=$(uname -s)
+acls=no
+default_acls=no
+setfacl_opts=""
+if ( setfacl -m u::rwx,g::r-x,o::---,u:root:rwx,g:sys:rwx,u:daemon:r--,mask::rwx \
+             "$acl_xattr_test_file" ) >/dev/null 2>&1
+then
+  if ( getfacl "$acl_xattr_test_file" ) >/dev/null 2>&1
+  then
+    if ( setfacl -m u::rwx,g::r-x,o::---,u:root:rwx,g:sys:rwx,u:daemon:r--,mask::rwx \
+                 "$acl_xattr_test_dir" ) >/dev/null 2>&1
+    then
+      acls=yes
+      # Setting of "default" ACLs will fail on FreeBSD. It will nevertheless be
+      # done in the image by a xorriso command. Restoring is supposed to skip
+      # "default" ACLs if none could be recorded. 
+      if setfacl -m u::rwx,g::r-x,o::---,u:root:rwx,g:sys:rwx,u:daemon:r--,mask::rwx,d:u::rwx,d:g::r-x,d:o::---,d:u:root:rwx,d:g:sys:rwx,d:u:daemon:r--,d:mask::rwx "$acl_xattr_iso_dir" 2>/dev/null
+      then
+        default_acls=yes
+      fi
+      setfacl_opts="-setfacl u::rwx,g::r-x,o::---,u:root:rwx,g:sys:rwx,u:daemon:r--,mask::rwx,d:u::rwx,d:g::r-x,d:o::---,d:u:root:rwx,d:g:sys:rwx,d:u:daemon:r--,d:mask::rwx $acl_xattr_iso_dir --"
+    fi
+  fi
+fi
+
+# GNU/Linux and FreeBSD have different tools for Extended Attributes
+xattrs=no
+extattrs=no
+# Try GNU/Linux style setattr/getattr
+if ( setfattr -n user.test_xattr -v test_value "$acl_xattr_test_file" ) \
+   >/dev/null 2>&1
+then
+  if ( getfattr -d "$acl_xattr_test_file" ) >/dev/null 2>&1
+  then
+    xattrs=yes
+    setfattr -n user.long_data -v 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 "$acl_xattr_test_file"
+    setfattr -n user.more_data -v 01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 "$acl_xattr_test_file"
+  fi
+fi
+if test "$xattrs" = no
+then
+  # Try FreeBSD style setextattr
+  if ( setextattr user test_xattr test_value "$acl_xattr_test_file" ) \
+     >/dev/null 2>&1
+  then
+    if ( getextattr user test_xattr "$acl_xattr_test_file" ) >/dev/null 2>&1
+    then
+      setextattr user long_data 0123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 "$acl_xattr_test_file"
+      setextattr user more_data 01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789 "$acl_xattr_test_file"
+      if ( lsextattr user "$acl_xattr_test_file" ) >/dev/null 2>&1
+      then
+        extattrs=yes
+      fi
+    fi
+  fi
+fi
+
+echo
+echo "${SELF}: Detected sys='$sys' , acls=$acls , d_acls=$default_acls , xattrs=$xattrs , extattrs=$extattrs"
+
+# Examine capabilities of xorriso 
+xorriso_acls=no
+xorriso_xattrs=no
+extras=$("$xorriso" -list_extras all 2>/dev/null)
+if test "$?" = 0
+then
+  if echo "$extras" | fgrep 'Local ACL    : yes' >/dev/null 2>&1
+  then
+    xorriso_acls=yes
+  fi
+  if echo "$extras" | fgrep 'Local xattr  : yes' >/dev/null 2>&1
+  then
+    xorriso_xattrs=yes
+  fi
+fi
+if test "$xorriso_acls" = no
+then
+  acls=no
+  setfacl_opts=
+fi
+if test "$xorriso_xattrs" = no
+then
+  xattrs=no
+  extattrs=no
+fi
+  
+echo "${SELF}: Detected xorriso_acls=$xorriso_acls , xorriso_xattrs=$xorriso_xattrs"
+echo
+ls -l "$on_disk"/*
+
+echo -e "\n${SELF}: Producing simple image via -o" >&2
+"$xorriso" -as mkisofs "$on_disk" -o "$workdir"/image_minus_o.iso
+is_valid_iso9660                          "$workdir"/image_minus_o.iso
+
+echo -e "\n${SELF}: Producing simple image via redirect" >&2
+"$xorriso" -as mkisofs "$on_disk" >       "$workdir"/image_redirected.iso
+is_valid_iso9660                          "$workdir"/image_redirected.iso
+
+echo -e "\n${SELF}: Producing simple image via pipe" >&2
+return_wrapper "$xorriso" -as mkisofs "$on_disk" | \
+               cat > "$workdir"/image_piped.iso
+check_xorriso_return
+is_valid_iso9660                          "$workdir"/image_piped.iso
+
+echo -e "\n${SELF}: Producing simple image with for_backup/update_r/hardlinks" >&2
+"$xorriso" \
+  $report_about \
+  -version \
+  -for_backup \
+  -padding 0 \
+  -outdev "$image_file" \
+  -volid TEST_AUTO_ISOCONTENT \
+  -update_r "$on_disk" "$in_iso" \
+  $setfacl_opts \
+  -hardlinks perform_update
+ret=$?
+
+if test "$ret" -gt 0 -a "$ret" -lt 32
+then
+  printf "\nFAIL : ${SELF} : xorriso write run failed\n\n"
+  cleanup
+  exit 1
+fi
+is_valid_iso9660                         "$image_file"
+
+
+# It must refuse to load and go on with -assert_volid and non-matching pattern.
+msg=$(\
+"$xorriso" \
+ -abort_on FATAL \
+ -return_with FAILURE 32 \
+ -assert_volid 'NON_MATCHING*' FATAL \
+ -indev "$image_file" \
+ 2>&1
+)
+ret=$?
+if test "$ret" -gt 0 -a "$ret" -lt 32
+then
+  printf "\n${SELF}: Ok. -assert_volid snapped.\n"
+elif test "$ret" -ne 0
+then
+  failure=1
+  echo >&2
+  echo "$msg" >&2
+  printf "\nFAIL : ${SELF} : -assert_volid test not properly performed\n\n"
+else
+  failure=1
+  printf "\nFAIL : ${SELF} : -assert_volid did not snap\n\n" >&2
+fi
+
+echo -e "\n${SELF}: Copying from image to temporary disk tree" >&2
+"$xorriso" \
+  $report_about \
+  -for_backup \
+  -assert_volid 'TEST_AUTO_ISOCONT*' FATAL \
+  -indev "$image_file" \
+  -osirrox on \
+  -find "$in_iso" -exec lsdl -- \
+  -extract "$in_iso" "$copy_on_disk"
+ret=$?
+if test "$ret" -gt 0 -a "$ret" -lt 32
+then
+  printf "\nFAIL : ${SELF} : xorriso file extraction run failed\n\n"
+  cleanup
+  exit 1
+fi
+
+if test "$simulate_failure" = 1
+then
+  echo -e "\n${SELF}: SIMULATING FAILURE BY REMOVING AN EXTRACTED FILE" >&2
+  echo -e "\nFAIL : ${SELF} : Simulated failure caused by option -fail"
+  rm "$copy_on_disk"/file_1_link_b
+fi
+
+
+printf "\n${SELF}: Comparing original disk tree and temporary one..." >&2
+diff -r "$on_disk" "$copy_on_disk"
+if test "$?" -ne 0
+then
+  echo -e "\nFAIL : ${SELF} : diff -r $on_disk $copy_on_disk   reports differences" >&2
+  echo -e "\nFAIL : ${SELF} : diff -r reports differences"
+  failure=1
+else
+  printf "OK" >&2
+fi
+
+printf "\n${SELF}: Checking for hardlinks being siblings...\n"
+ls -l "$copy_on_disk"/*
+x=$(echo $(ls -ld "$copy_on_disk"/*file* | awk '{print $2}'))
+expected="1 3 3 3 2 2"
+if test x"$x" = x"$expected"
+then
+  printf "${SELF}: Checking for hardlinks being siblings done: ok.\n" >&2
+else
+  printf "\nFAIL : ${SELF} : Link count of extracted files is not as expected." >&2
+  printf "\n${SELF}: Expected:  $expected" >&2
+  printf "\n${SELF}: Got     :  $x\n" >&2
+  failure=1
+fi
+
+if test "$acls" = yes
+then
+  printf "\n${SELF}: Checking ACLs ...\n" >&2
+  acl_on_disk=$(getfacl "$acl_xattr_test_file" | grep -v '^# file:' | sort)
+  acl_in_copy=$(getfacl "$acl_xattr_copy_file" | grep -v '^# file:' | sort)
+  if test "$acl_on_disk" = "$acl_in_copy"
+  then
+    printf "${SELF}: Checking ACLs done: ok.\n" >&2
+  else
+    printf "\nFAIL : ${SELF} : ACL mismatch between original and extracted copy\n"
+    printf "\nOriginal:\n${acl_on_disk}\n"
+    printf "\nCopy:\n${acl_in_copy}\n"
+    failure=1
+  fi
+fi
+
+if test "$xattrs" = yes
+then
+  printf "\n${SELF}: Checking xattr via getfattr ...\n" >&2
+  xattr_on_disk=$(getfattr "$acl_xattr_test_file" | \
+                  grep -v '^# file:' | grep -v '^$' | \sort)
+  xattr_in_copy=$(getfattr "$acl_xattr_copy_file" | 
+                  grep -v '^# file:' | grep -v '^$' | sort)
+  if test "$xattr_on_disk" = "$xattr_in_copy"
+  then
+    num_xattr=$(echo "$xattr_on_disk" | wc -l)
+    printf "${SELF}: Checking xattr done: $num_xattr attributes, ok.\n" >&2
+  else
+    printf "\nFAIL : ${SELF} : xattr mismatch between original and extracted copy\n"
+    printf "\nOriginal:\n${xattr_on_disk}\n"
+    printf "\nCopy:\n${xattr_in_copy}\n"
+    failure=1
+  fi
+elif test "$extattrs" = yes
+then
+  printf "\n${SELF}: Checking xattr via lsextattr and getextattr ...\n" >&2
+  lsext_on_disk=$(lsextattr -q user "$acl_xattr_test_file")
+  xattr_on_disk=$(for i in $lsext_on_disk ; do echo $i $(getextattr -q user $i "$acl_xattr_test_file"); done | sort)
+  lsext_in_copy=$(lsextattr -q user "$acl_xattr_copy_file")
+  xattr_in_copy=$(for i in $lsext_in_copy ; do echo $i $(getextattr -q user $i "$acl_xattr_copy_file"); done | sort)
+  if test "$xattr_on_disk" = "$xattr_in_copy"
+  then
+    num_xattr=$(echo "$xattr_on_disk" | wc -l)
+    printf "${SELF}: Checking xattr done: $num_xattr attributes, ok.\n" >&2
+  else
+    printf "\nFAIL : ${SELF} : xattr mismatch between original and extracted copy\n"
+    printf "\nOriginal:\n${xattr_on_disk}\n"
+    printf "\nCopy:\n${xattr_in_copy}\n"
+    failure=1
+  fi
+
+fi
+
+#
+echo
+cleanup
+
+# Report result
+echo 
+if test "$failure" = 1
+then
+  printf "${SELF}: FAILED"
+  echo 
+  exit 1
+else
+  printf "${SELF}: Passed"
+  echo 
+fi
+
+exit 0
--- a/releng/auto_printsize
+++ b/releng/auto_printsize
@ -0,0 +1,149 @@
+#!/bin/bash
+
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Licensed under GNU GPL version 2 or later
+
+set -e
+
+not_in_releng_exit() {
+  printf "\nPlease execute the tests from releng directory.\n\n"
+  exit 1
+}
+
+# Include common bits
+. inc/releng_getopts.inc || not_in_releng_exit
+
+print_specific_help() {
+cat << HLP
+Specific options:
+       none yet.
+Overview:
+       Test performance of print_size against various input tree.
+       Optionally compare with genisoimage and mkisofs.
+HLP
+}
+
+if test "$SPECIFIC_HELP" = 1; then
+  print_specific_help
+  exit 0
+fi
+
+# Each test should decide whether or not it needs
+# a xorriso binary to test, since some do compilations only.
+if [ ! -x $RELENG_XORRISO ]; then
+ print_help
+ printf "\n${SELF}: -x  absolute or relative path to binary to be run.\n\n"
+ exit 31
+fi
+
+# check data dir, if any and after checking -x xorriso
+if [ -d "${GEN_DATA_DIR}" ]; then
+ printf "\n${SELF}: directory %s exists!" ${GEN_DATA_DIR}
+ printf "\n${SELF}: use '${SELF} -c' to remove.\n"
+ exit 8
+else
+ mkdir "${GEN_DATA_DIR}"
+fi
+
+#
+DIR_UPPER=32
+FILE_UPPER=10
+
+# All must be set at this point
+# TODO: work out a smarter way to quickly generate different
+# types of trees (long, deep, etc)
+printf "\n${SELF}: Generating sample tree in ${GEN_DATA_DIR} :\n"
+count=0
+date
+
+# Hopefully the for-loops are much faster than while-loops with arithmetics
+# This needs 7/4*DIR_UPPER+FILE_UPPER (= 66) while-iterations
+#
+i1_list= 
+i1=0
+o1=$(expr ${DIR_UPPER} / 4)
+while test $i1 -lt $o1
+do
+  i1_list="$i1_list $i1"
+  i1=$(expr $i1 + 1)
+done
+i2_list= 
+i2=0
+o2=$(expr ${DIR_UPPER} / 2)
+while test $i2 -lt $o2
+do
+  i2_list="$i2_list $i2"
+  i2=$(expr $i2 + 1)
+done
+i3_list= 
+i3=0
+while test $i3 -lt ${DIR_UPPER}
+do
+  i3_list="$i3_list $i3"
+  i3=$(expr $i3 + 1)
+done
+i_file_list= 
+i_file=0
+while test $i_file -lt ${FILE_UPPER}
+do
+  i_file_list="$i_file_list $i_file"
+  i_file=$(expr $i_file + 1)
+done
+#
+# plus 1/8*DIR_UPPER*DIR_UPPER*DIR_UPPER*FILE_UPPER (= 40960) for-iterations
+#
+for i1 in $i1_list
+do
+  for i2 in $i2_list
+  do
+    for i3 in $i3_list
+    do
+      mkdir -p ${GEN_DATA_DIR}/DirOne$i1/DirTwo$i2/DirThree$i3
+      for i_file in $i_file_list
+      do
+        echo -n \
+             > ${GEN_DATA_DIR}/DirOne$i1/DirTwo$i2/DirThree$i3/File_${i_file}
+        count=$((count + 1))
+      done
+    done
+  done
+  echo "  ${count} files created ..."
+done
+
+printf "done.\n"
+date
+du -s "${GEN_DATA_DIR}"
+
+printf "\n${SELF}: Performing several print size runs to neutralize possible disk cache impact.\n"
+
+# run xorriso
+if [ -x ${RELENG_XORRISO} ]; then
+  for run in 1 2 3; do
+      printf "\n${SELF}: Running ${RELENG_XORRISO} -as mkisofs -quiet -print-size ${GEN_DATA_DIR}. Trial: ${run}.\n"
+      time ${RELENG_XORRISO} -as mkisofs -quiet -print-size ${GEN_DATA_DIR}
+  done
+fi
+
+# try to run genisoimage
+if which genisoimage >/dev/null 2>&1; then
+  RELENG_GENISOIMAGE=`which genisoimage`
+  for run in 1 2 3; do
+      printf "\n${SELF}: Running ${RELENG_GENISOIMAGE} -quiet -print-size ${GEN_DATA_DIR}. Trial: ${run}.\n"
+      time ${RELENG_GENISOIMAGE}         -quiet -print-size ${GEN_DATA_DIR}
+  done
+fi
+
+# try to run mkisofs
+if which mkisofs >/dev/null 2>&1; then
+  RELENG_MKISOFS=`which mkisofs`
+  for run in 1 2 3; do
+      printf "\n${SELF}: Running ${RELENG_MKISOFS} -quiet -print-size ${GEN_DATA_DIR}. Trial: ${run}.\n"
+      time ${RELENG_MKISOFS}             -quiet -print-size ${GEN_DATA_DIR}
+  done
+fi
+
+#
+cleanup
+
+#
+exit 0
--- a/releng/change_shell_to_use
+++ b/releng/change_shell_to_use
@ -0,0 +1,39 @@
+
+# check whether we are in releng and create dir
+mkdir_ret=29
+if test -d releng_generated_data
+then
+  if test -d releng_generated_data/change_shell_to_use
+  then
+    mkdir_ret=0
+  else
+    mkdir releng_generated_data/change_shell_to_use
+    mkdir_ret=$?
+  fi
+fi
+
+if test "$mkdir_ret" = 0
+then
+  for i in run_all_auto auto_* manual_*
+  do
+    temp=releng_generated_data/change_shell_to_use/temp_file
+    c=$(wc -l "$i" | awk '{print $1}')
+    line=$(head -n 1 "$i")
+
+    if echo x"$line" | grep '^x#!' >/dev/null 2>&1
+    then
+      cp "$i" "$temp"
+      echo '#!'"$SHELL" > "$temp"
+      tail -n "$(expr $c - 1)" "$i" >> "$temp"
+      mv "$temp" "$i"
+      echo "Changed to #!$SHELL : $i"
+    fi
+  done
+  rmdir releng_generated_data/change_shell_to_use
+else
+  echo "change_shell_to_use: Missing directory ./releng_generated_data" >&2
+  echo "or cannot create directory ./releng_generated_data/change_shell_to_use" >&2
+  echo "change_shell_to_use: Run aborted"
+  test 1 = 0
+fi
+
--- a/releng/codesamples/api_3lib.cpp
+++ b/releng/codesamples/api_3lib.cpp
@ -0,0 +1,34 @@
+// Just to ensure we are C++-clean. This should not spit too much noise
+
+/* Copyright 2011 George Danchev <danchev@spnet.net>
+ * Released into the public domain
+ */
+
+#if __WORDSIZE == 32
+#define _LARGEFILE_SOURCE 1
+#define _FILE_OFFSET_BITS 64
+#endif
+
+#include <iostream>
+#include <inttypes.h>
+
+//extern "C" {
+#include "libburn/libburn.h"
+#include "libisofs/libisofs.h"
+// using namespace burn;
+// (this was needed to before rev.4062 of libisoburn)
+#include "libisoburn/libisoburn.h"
+//}
+
+int main() {
+   int major=-1, minor=-1, micro=-1;
+   isoburn_version(&major, &minor, &micro);
+   if (major<0 || minor<0 || micro<0)
+     return -1;
+   std::cout 
+          << " major:" << major
+          << " minor:" << minor
+          << " micro:" << micro
+   ;
+   return 0;
+}
--- a/releng/codesamples/api_xorriso.cpp
+++ b/releng/codesamples/api_xorriso.cpp
@ -0,0 +1,30 @@
+// Just to ensure we are C++-clean. This should not spit too much noise
+
+/* Copyright 2011 George Danchev <danchev@spnet.net>
+ * Released into the public domain
+ */
+
+#if __WORDSIZE == 32
+#define _LARGEFILE_SOURCE 1
+#define _FILE_OFFSET_BITS 64
+#endif
+
+#include <iostream>
+#include <inttypes.h>
+
+//extern "C" {
+#include "xorriso/xorriso.h"
+//}
+
+int main() {
+   int major=-1, minor=-1, micro=-1;
+   Xorriso__version(&major, &minor, &micro);
+   if (major<0 || minor<0 || micro<0)
+          return -1;
+   std::cout 
+               << " major:" << major
+               << " minor:" << minor
+               << " micro:" << micro
+   ;
+   return 0;
+}
--- a/releng/inc/releng_getopts.inc
+++ b/releng/inc/releng_getopts.inc
@ -0,0 +1,198 @@
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Copyright 2011 Thomas Schmitt <scdbackup@gmx.net>
+# Licensed under GNU GPL version 2 or later
+
+SELF=$(basename $0)
+RELENG_XORRISO=0
+SIMULATE_FAILURE=0
+CLEANUP=1
+SPECIFIC_HELP=0
+START_DIR_DONT_CHANGE=`pwd`
+GEN_DATA_DIR=releng_generated_data/${SELF}
+
+#############################################
+standalone_or_supervised() {
+ case "${RELENG_SCRIPT_RUN_BY_RUN_ALL_AUTO}" in
+  1)
+     echo "${SELF}: Running in Supervised mode"
+  ;;
+  *)
+     echo "${SELF}: Running in Standalone mode"
+  ;;
+ esac
+}
+
+# Unconditionally shout out the invocation mode - standalone or supervised
+standalone_or_supervised
+
+#############################################
+print_help() {
+cat << EOF
+
+Usage: $SELF -x path/to/xorriso [-k] [-f] [-c] [-h] 
+                                              [-- ...test specific options...]
+General options:
+       -x  absolute or relative path to xorriso binary to be run.
+       -k  keep self-generated data.
+       -c  cleanup self-generated data kept from previous run and exit.
+       -f  simulate failure.
+       -h  print this help text
+       --  end of general options, begin of test specific options.
+EOF
+}
+
+#############################################
+boldify() {
+ if which tput >/dev/null 2>&1; then tput smso; fi
+}
+
+#############################################
+unboldify() {
+ if which tput >/dev/null 2>&1; then tput rmso; fi
+}
+
+#############################################
+cleanup() {
+ if [ ${CLEANUP} -eq 1 ]; then
+   # safety net, just in case -> we want to be in the starting
+   # directory before removing whatever self-generated stuff
+   if [ -d "${GEN_DATA_DIR}" ]; then
+       cd "${START_DIR_DONT_CHANGE}" || exit 2
+       
+       # Verify once again we are in the releng_generated_data directory
+       # Check for both returned code of grep and returned matching string
+       # There is no "readlink -e" on FreeBSD
+       READ_CANON_EXISTS=`cd "${GEN_DATA_DIR}" 2>/dev/null && pwd`
+       DIR_NAME_GEN_DATA=`dirname "${READ_CANON_EXISTS}"`
+       set +e
+       # There is no "grep -P" on FreeBSD
+       RET_NON_EMPTY_STRING=`echo "${DIR_NAME_GEN_DATA}" | grep "[a-zA-Z0-9_][a-zA-Z0-9_]*/releng_generated_data$"`
+       GREP_RET_GEN_DATA="$?"
+       case "${GREP_RET_GEN_DATA}" in
+            0)
+	      if [ x"${RET_NON_EMPTY_STRING}" != x"" ]; then
+                 # now call the nastiness
+                 chmod -R +w ${GEN_DATA_DIR}
+                 rm -rf ${GEN_DATA_DIR}
+#		 boldify
+                 printf "${SELF}: Removed (self-generated) %s\n" ${GEN_DATA_DIR}
+#		 unboldify
+	      else
+                 printf "FAIL : ${SELF} : Safety check for being in releng_generated_data directory.\n"
+                 printf "FAIL : ${SELF} : GREP returned empty string: ${RET_NON_EMPTY_STRING}.\n"
+                 printf "FAIL : ${SELF} : Skipped trying to remove ${GEN_DATA_DIR} directory. Exiting.\n"
+	      fi
+            ;;
+	    *)
+              printf "FAIL : ${SELF} : Safety check for being in releng_generated_data directory.\n"
+              printf "FAIL : ${SELF} : GREP returned code: ${GREP_RET_GEN_DATA}.\n"
+              printf "FAIL : ${SELF} : Skipped trying to remove ${GEN_DATA_DIR} directory. Exiting.\n"
+	      exit 30
+	    ;;
+       esac
+   else
+       printf "${SELF}: ${GEN_DATA_DIR} does not exist. Nothing to clean.\n"
+   fi
+ else
+#   boldify
+   printf "${SELF}: Leaving (self-generated) %s\n" ${GEN_DATA_DIR}
+#   unboldify
+ fi 
+}
+
+#############################################
+check_for_xorriso() {
+ # $1: if "-x" then check executability
+
+ if test -z "$RELENG_XORRISO" -o "$RELENG_XORRISO" = "0"
+ then
+   print_help
+#  print_specific_help
+   echo
+   echo "${SELF}: Need -x  absolute or relative path to xorriso binary."
+   echo
+   exit 31
+ fi
+ if [ x"$1" = x"-x" -a ! -x "$RELENG_XORRISO" ]
+ then
+   print_help
+#  print_specific_help
+   echo
+   echo "${SELF}: Path given by option -x does not lead to an executable file."
+   echo "Given is: '$RELENG_XORRISO'"
+   if test "$RELENG_XORRISO" = "xorriso"
+   then
+     xorriso=$(type -p xorriso)
+     if test -n "xorriso"
+     then
+       echo "Hint: Try '$xorriso'"
+     fi
+   fi
+   echo
+   exit 31
+ fi
+}
+
+
+#############################################
+
+# To catch the exit value of a command in a pipe
+return_value_file="$GEN_DATA_DIR"/wrapper_"$$"_return_value
+return_wrapper()
+{
+ cmd="$1"
+ shift 1
+ "$cmd" "$@"
+ RET="$?"
+ echo "$RET" >"$return_value_file"
+ return "$RET"
+}
+
+#############################################
+
+next_is=
+for i in "$@"
+do
+  if test "$next_is" = "ignore"
+  then :
+  elif test "$next_is" = "x"
+  then
+       RELENG_XORRISO="$i"
+       next_is=
+  elif test x"$i" = x"-x"
+  then
+       next_is="x"
+  elif test x"$i" = x"-k"
+  then
+       CLEANUP=0
+  elif test x"$i" = x"-c"
+  then
+       CLEANUP=1
+       cleanup
+       exit 0
+  elif test x"$i" = x"-f"
+  then
+       SIMULATE_FAILURE=1
+  elif test x"$i" = x"-h"
+  then
+       print_help
+       SPECIFIC_HELP=1
+  elif test x"$i" = x"--"
+  then 
+       # Begin of private arguments for caller
+       next_is="ignore"
+  else
+       echo >&2
+       echo "Unknown general option: $i" >&2
+       print_help
+       exit 31
+  fi
+done
+
+if test "$next_is" = x
+then
+       echo >&2
+       echo "Option -x expects an argument (the path to the xorriso program)" >&2
+       print_help
+       exit 31
+fi
--- a/releng/inc/test_releng_getopt
+++ b/releng/inc/test_releng_getopt
@ -0,0 +1,20 @@
+#!/bin/bash
+
+set -e
+
+. releng_getopts.inc
+
+boldify
+printf "\ntesting boldify and unboldify..."
+unboldify
+
+printf "\nSELF                  =${SELF}"
+printf "\nRELENG_XORRISO        =${RELENG_XORRISO}"
+printf "\nSIMULATE_FAILURE      =${SIMULATE_FAILURE}"
+printf "\nCLEANUP               =${CLEANUP}"
+printf "\nSPECIFIC_HELP         =${SPECIFIC_HELP}"
+printf "\nSTART_DIR_DONT_CHANGE =${START_DIR_DONT_CHANGE}"
+printf "\nGEN_DATA_DIR          =${GEN_DATA_DIR}"
+printf "\n"
+
+exit 0
--- a/releng/jigdo-gen-md5-list
+++ b/releng/jigdo-gen-md5-list
@ -0,0 +1,175 @@
+#!/bin/sh
+
+# Copyright (c) 2010, 2011 George Danchev <danchev@spnet.net>
+# Copyright (c) 2010, 2011 Thomas Schmitt <scdbackup@gmx.net>
+# This script is distributed according to the terms of the GNU GPL v2.
+# This should be better rewritten in C at some future point. Ref: pwd code.
+
+# Create a list of MD5sums encoded in hexidecimal format and print to standard output
+
+# Format Description
+# A line in the emerging file is to be composed as follows:
+#
+# The MD5 checksum of the file content must be encoded in 32 hex digits
+# [0-9afAF]
+#
+# Next come two blanks.
+#
+# The byte size of the file content must be encoded in 12 decimal digits
+# or blanks.
+#
+# Next come two blanks.
+#
+# The rest of the line up to the newline character is a semi-literal file
+# address. Its basename has to be the same as the basename of the data file
+# when it is used as one of the input files for the jigdo file generator.
+
+# The semi-literal address and the address mapping define what will be
+# listed as file address in the jigdo file.
+# The address may bear at its start a literal text that shall be recognized by
+# the address mapping (e.g. -jigdo-map) of the jigdo file generator.
+# The rest of the address must be usable as file address in both situations:
+# When the jigdo file gets generated, and when the jigdo file gets read
+# to inflate the template file into the original payload image.
+# The address mappings at both occasions can be used to adapt to a change
+# of the absolute location of the listed files.
+# Between both mappings, the parent directory is represented by a symbolic
+# text, like "Debian:".
+
+# A simple strategy to cope with this is to write absolute paths into the
+# .md5 file, and to use matching absolute paths in the -jigdo-map
+# directives. Keep in mind that mapping is purely literal. Symbolic links
+# are neither resolved nor can they confuse the mapping.
+
+set -e
+
+SELF=jigdo-gen-md5-list
+VER=0.2
+
+OPT_ABSOLUTE=1
+
+# On FreeBSD there is "md5" rather than "md5sum".
+# Furthermore, the FreeBSD shell reports missing commands to inherited stderr,
+# regardless that the attempt itself has redirected stderr. Thus a sub shell
+# is needed to hide the protest.
+if ( md5sum --help ) >/dev/null 2>&1 
+then
+	md5_cmd=md5sum
+elif ( md5 -s test ) >/dev/null 2>&1
+then
+	md5_cmd=md5
+else
+	echo "$0 : Programs md5sum and md5 failed to work" >&2
+	exit 2
+fi
+
+usage() {
+	cat << USAGE
+usage: $SELF [option] DIR FILE ...
+ -a, --make-absolute    make absolute paths, avoiding any symlinks (default)
+ -l, --keep-literal     leave paths untouched, literally as supplied
+ -v, --version          print version
+ -h, --help             print help
+ -e, --examples         print examples
+USAGE
+}
+
+examples() {
+	cat << EXAMPLES
+examples:
+ $SELF datadir datafile
+ $SELF --keep-literal datadir datafile
+ find . -type f | xargs $SELF
+ find . -exec $SELF '{}' ';'
+EXAMPLES
+}
+
+md5list() {
+	item="$1"
+	if test $OPT_ABSOLUTE -eq 1; then
+        	dn=`dirname "$item"`  # dirname
+		fn=`basename "$item"` # filename
+		od=`pwd -P`           # old dir
+		cd "$dn" || exit 1
+		item=`pwd -P`/"$fn"   # absolute physical file path, avoiding all symlinks
+		cd "$od" || exit 1
+	fi
+	if test "$md5_cmd" = "md5sum"
+	then
+		MD5=`md5sum "$item" | awk '{print $1}'`
+	elif test "$md5_cmd" = "md5"
+	then
+		MD5=`md5 -q "$item"`
+	else
+		echo "$0 : No MD5 program found" >&2
+		exit 2
+	fi
+	SIZ=`ls -ld "$item" | awk '{print $5}'`
+	printf '%32s  %12s  %s\n' "$MD5" "$SIZ" "$item"
+}
+
+walkdir() {
+	DR="$1"
+	for item in `find "$DR" -type f`
+	do
+		md5list "$item"
+	done
+}
+
+
+# main()
+if test "$1" = "" ; then
+	usage
+	exit 1
+fi
+
+case "$1" in
+	--make-absolute|-a)
+		OPT_ABSOLUTE=1;
+		shift;
+		;;
+	--keep-literal|-l)
+		OPT_ABSOLUTE=0;
+		shift;
+		;;
+	--version|-v)
+		printf '%s %s\n' "$SELF" "$VER"
+		exit 0
+		;;
+	--help|-h)
+		usage
+		exit 0
+		;;
+	--examples|-e)
+		examples
+		exit 0
+#	*)
+#		usage
+#		exit 1
+#		;;
+esac
+
+for i in "$@"
+do
+
+	if test -d "$i" ; then
+		DR="$i"
+                if test $OPT_ABSOLUTE -eq 1; then
+			od=`pwd -P`           # old dir
+			cd "$DR" || exit 1
+			DR=`pwd -P`           # absolute physical dir path, avoiding all symlinks
+			cd "$od" || exit 1
+		fi
+		walkdir "$DR"
+	elif test -f "$i" ; then
+		FL="$i"
+		md5list "$FL"
+	else
+		usage
+		exit 1
+	fi;
+
+done
+
+exit 0
+
--- a/releng/jigdo-gen-md5-list.1
+++ b/releng/jigdo-gen-md5-list.1
@ -0,0 +1,30 @@
+.\" DO NOT MODIFY THIS FILE!  It was generated by help2man 1.38.2.
+.TH JIGDO-GEN-MD5-LIST "1" "October 2010" "jigdo-gen-md5-list 0.1" "User Commands"
+.SH NAME
+jigdo-gen-md5-list \- create a list of MD5sums encoded in hexidecimal format and print to standard output
+.SH DESCRIPTION
+usage: jigdo\-gen\-md5\-list [option] DIR FILE ...
+.TP
+\fB\-a\fR, \fB\-\-make\-absolute\fR
+make absolute paths, avoiding any symlinks (default)
+.TP
+\fB\-l\fR, \fB\-\-keep\-literal\fR
+leave paths untouched, literally as supplied
+.TP
+\fB\-v\fR, \fB\-\-version\fR
+print version
+.TP
+\fB\-h\fR, \fB\-\-help\fR
+print help
+.TP
+\fB\-e\fR, \fB\-\-examples\fR
+print examples
+.SH FORMAT
+
+File format is described in the beginning of the script itself.
+
+.SH "SEE ALSO"
+xorriso(1), jigdo-lite(1), jigit-mkimage(1)
+
+.SH AUTHOR
+Written by George Danchev <danchev@spnet.net> and Thomas Schmitt <scdbackup@gmx.net>
--- a/releng/manual_burn
+++ b/releng/manual_burn
@ -0,0 +1,256 @@
+#!/bin/bash
+
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Copyright 2011 Thomas Schmitt <scdbackup@gmx.net>
+#
+# Licensed under GNU GPL version 2 or later
+
+set -e
+# set -x
+
+print_specific_help() {
+cat << HLP
+Specific options: 
+       --dev path  use path as drive address. Default: /dev/cdrw
+       --what path use path as address of the directory which shall
+                   be copied into an ISO 9660 filesystem on media.
+       --any_media allow non re-usable MMC media, like CD-R or DVD+R.
+                   Allow paths to non-existing files, but disallow paths
+                   to existing regular files.
+       --priv_cmd 'command [arg [arg ...]]'
+                   With drive operations execute xorriso as argument
+                   of the given command (e.g. pfexec, sudo) with the
+                   optionally given arguments: command arg arg xorriso ...
+                   Command and arguments must be single words.
+Overview:
+       Test burning to re-usable media CD-RW, DVD-RW, DVD-RAM, DVD+RW, BD-RE.
+       By default, one-time usable media will be rejected deliberately.
+HLP
+}
+
+wait_for_dev () {
+# $1 = device address
+  timeout=30
+  counter=0
+
+  while test "$counter" -lt "$timeout"
+  do
+    if test -e "$1"
+    then
+      echo
+      return 0
+    fi
+    if test "$counter" = 0
+    then
+      echo
+      echo "Not existing: $dev"
+      echo "Will wait up to $timeout seconds for it to appear."
+    fi
+    counter=$(expr $counter + 1)
+    echo -n "$counter " 
+    sleep 1
+  done
+  echo
+  return 1
+}
+
+getopts_inc=inc/releng_getopts.inc
+if test -e "$getopts_inc"
+then
+  . "$getopts_inc"
+  if test "$SPECIFIC_HELP" = 1
+  then
+       print_specific_help
+       exit 0
+  fi
+else
+  echo >&2
+  echo "File not found: $getopts_inc" >&2
+  echo "Are we in the ./releng directory of a libisoburn SVN checkout ?" >&2
+  echo "(Please execute the tests from that ./releng directory.)" >&2
+  echo >&2
+  exit 29  
+fi
+
+# Set default values for specific option variables.
+dev=/dev/cdrw
+what=../xorriso
+any_media=0
+priv_cmd=
+# Interpret specific options, they begin after the first --.
+next_is=ignore
+for i in "$@"
+do
+  if test "$next_is" = "ignore"
+  then
+       if test "$i" = "--"
+       then
+            next_is=""
+       fi
+  elif test "$next_is" = "dev"
+  then
+       dev="$i"
+       next_is=""
+  elif test "$next_is" = "what"
+  then
+       what="$i"
+       next_is=""
+  elif test "$next_is" = "priv_cmd"
+  then
+       priv_cmd="$i"
+       next_is=""
+  elif test "$i" = "--dev"
+  then
+       next_is="dev"
+  elif test "$i" = "--what"
+  then
+       next_is="what"
+  elif test "$i" = "--any_media"
+  then
+       any_media=1
+  elif test "$i" = "--priv_cmd"
+  then
+       next_is="priv_cmd"
+  else
+       echo >&2
+       echo "Unknown test specific option: $i" >&2
+       print_help
+       print_specific_help
+       exit 31
+  fi
+done
+
+
+check_for_xorriso -x
+
+
+# check data dir, if any and after checking -x xorriso
+if [ -d "${GEN_DATA_DIR}" ]; then
+ printf "\n${SELF}: directory %s exists!" ${GEN_DATA_DIR}
+ printf "\n${SELF}: use '${SELF} -c' to remove.\n"
+ exit 30
+else
+ mkdir "${GEN_DATA_DIR}"
+fi
+
+
+#####################################################################
+
+# Inspect drive address
+if test -e "$dev"
+then
+  if test "$any_media" = 1 -a -f "$dev"
+  then
+    echo "FAIL : ${SELF} : --dev $dev leads to an existing regular file"
+    echo
+    cleanup
+    exit 31
+  fi
+else
+  if test "$any_media" = "0"
+  then
+    echo "FAIL : ${SELF} : --dev $dev does not lead to an existing file"
+    echo
+    cleanup
+    exit 31
+  fi
+fi
+
+# Inspect media
+set +e
+wait_for_dev "$dev"
+res=$(${priv_cmd} "$RELENG_XORRISO" -outdev "$dev" 2>&1)
+ret=$?
+set -e
+if test "$ret" -ne 0
+then
+  echo "$res" >&2
+  echo "FAIL : ${SELF} : Non-zero exit value $ret with: ${priv_cmd} $RELENG_XORRISO -outdev $dev"
+  echo
+  cleanup
+  exit 1
+elif echo "$res" | grep '^Media current:' >/dev/null 2>&1
+then
+  media=$(echo "$res" | grep '^Media current:' | \
+          sed -e 's/^Media current: //')
+  echo "Detected media: '$media'"
+  if test "$media" = "CD-RW" -o "$media" = "DVD-RW sequential recording" -o \
+          "$media" = "DVD-RW restricted overwrite" -o "$media" = "DVD-RAM" -o \
+          "$media" = "DVD+RW" -o "$media" = "BD-RE"
+  then
+    echo "Recognized as re-usable."
+  elif test "$media" = "is not recognizable"
+  then
+    echo "FAIL : ${SELF} : No recognizable media detected in: '$dev'"
+    echo
+    cleanup
+    exit 2
+  elif test "$any_media" = 1
+  then
+    echo "Accepted media only because of option --any_media : '$media'"
+  else
+    echo "FAIL : ${SELF} : No re-usable media detected, but: '$media'"
+    echo
+    cleanup
+    exit 2
+  fi
+fi
+
+# Perform burn run
+echo ${priv_cmd} "$RELENG_XORRISO" -for_backup -outdev "$dev" -blank as_needed -map "$what" /test
+set +e
+wait_for_dev "$dev"
+${priv_cmd} "$RELENG_XORRISO" \
+    -for_backup \
+    -outdev "$dev" \
+    -blank as_needed \
+    -map "$what" /test
+ret=$?
+set -e
+if test "$ret" -ne 0
+then
+  echo "FAIL : ${SELF} : Non-zero exit value with burn run: $ret"
+  echo
+  cleanup
+  exit 1
+fi
+
+if test "$SIMULATE_FAILURE" = 1
+then
+  echo "FAIL : ${SELF} : Simulated failure caused by option -f" 
+  if test -f "$dev"
+  then
+    # Alter image 
+    dd if=/dev/urandom bs=2K count=1 \
+       of="$dev" conv=notrunc seek=400
+  else
+    cleanup
+    exit 1
+  fi
+fi
+
+# Check read
+echo ${priv_cmd} "$RELENG_XORRISO" -for_backup -indev "$dev" \
+     -check_media event=FATAL -- \ -check_md5_r FATAL / --
+set +e
+wait_for_dev "$dev"
+${priv_cmd} "$RELENG_XORRISO" \
+    -for_backup \
+    -indev "$dev" \
+    -print '---check_media:'  -check_media event=FATAL -- \
+    -print '---check_md5_r:'  -check_md5_r FATAL / -- \
+    -print '---compare_r:'    -md5 off -compare_r "$what" /test
+ret=$?
+set -e
+if test "$ret" -ne 0
+then
+  echo "FAIL : ${SELF} : Non-zero exit value with checkread run: $ret"
+  echo
+  cleanup
+  exit 1
+fi
+
+echo "Ok. Burn test passed."
+echo
+cleanup
+exit 0
--- a/releng/manual_devices
+++ b/releng/manual_devices
@ -0,0 +1,188 @@
+#!/bin/bash
+
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Copyright 2011 Thomas Schmitt <scdbackup@gmx.net>
+# Licensed under GNU GPL version 2 or later
+
+# set -e
+
+print_specific_help() {
+cat << HLP
+Specific options:
+       --dev path  Suppress dialog and use path as drive address.
+       --priv_cmd 'command [arg [arg ...]]'
+                   With drive operations execute xorriso as argument
+                   of the given command (e.g. pfexec, sudo) with the
+                   optionally given arguments: command arg arg xorriso ...
+                   Command and arguments must be single words.
+Overview:
+       Test device scanning and list of speeds.
+HLP
+}
+
+# Include common bits and interpret general options
+getopts_inc=inc/releng_getopts.inc
+if test -e "$getopts_inc"
+then
+  . "$getopts_inc"
+
+  if test "$SPECIFIC_HELP" = 1
+  then
+       print_specific_help
+       exit 0
+  fi
+else
+  echo >&2
+  echo "File not found: $getopts_inc" >&2
+  echo "Are we in the ./releng directory of a libisoburn SVN checkout ?" >&2
+  echo "(Please execute the tests from that ./releng directory.)" >&2
+  echo >&2
+  exit 2
+fi
+
+# Interpret private options, they begin after the first --.
+dev=
+priv_cmd=
+next_is=ignore
+for i in "$@"
+do
+  if test "$next_is" = "ignore"
+  then
+       if test "$i" = "--"
+       then
+            next_is=""
+       fi
+  elif test "$next_is" = "dev"
+  then
+       dev="$i"
+       next_is=""
+  elif test "$next_is" = "priv_cmd"
+  then
+       priv_cmd="$i"
+       next_is=""
+  elif test "$i" = "--dev"
+  then
+       next_is="dev"
+  elif test "$i" = "--priv_cmd"
+  then
+       next_is="priv_cmd"
+  else
+       echo >&2
+       echo "Unknown test specific option: $i" >&2
+       print_help
+       print_specific_help
+       exit 31
+  fi
+done
+
+# Insist in having a xorriso 
+check_for_xorriso -x
+
+has_device_links=$("$RELENG_XORRISO" -help 2>/dev/null | fgrep ' -device_links')
+if test -n "$has_device_links"
+then
+  devices_opt="-device_links"
+else
+  devices_opt="-devices"
+fi
+
+#
+get_speeds() {
+  echo -e "\n${SELF}: Running:  ${priv_cmd} ${RELENG_XORRISO} -report_about WARNING -outdev ${1} -toc -list_formats -list_profiles out -list_speeds"
+   ${priv_cmd} "$RELENG_XORRISO" -report_about WARNING -outdev "$1" \
+                    -print '---toc :'            -toc \
+                    -print '---list_formats :'   -list_formats \
+                    -print '---list_profiles :'  -list_profiles out \
+                    -print '---list_speeds :'    -list_speeds
+}
+
+cat_var() {
+# $1 = variable to put out with line feeds
+cat <<+
+$1
+
+}
+
+get_devices() {
+  # $1 = if not empty: device lines from xorriso -devices or -device_links
+  # $2 = if not empty: suppress dialog and use $2 as input
+
+  if test -n "$1"
+  then
+       DEVICES="$1"
+  else
+       DEVICES=$( ${priv_cmd} "$RELENG_XORRISO" $devices_opt 2>/dev/null | grep "\-dev")
+  fi
+  NUM_DEV=$(cat_var "$DEVICES" | wc -l)
+  case "${NUM_DEV}" in
+       0)
+          echo -e "\n${SELF}: No drives found."
+	  exit 1
+       ;;
+       1)
+          echo -e "\n${SELF}: 1 drive found:\n"
+       ;;
+       *)
+          echo -e "\n${SELF}: ${NUM_DEV} drives found:\n"
+       ;;
+  esac
+  echo =================================================================
+  echo "$DEVICES"
+  echo =================================================================
+
+  OUTDEV=$( cat_var "$DEVICES" | head -1 | \
+            sed -e "s/[0-9]  *-dev '\//\//"  -e "s/'.*$//" )
+  if test -n "$2"
+  then
+       x="$2"
+  else
+       echo >&2
+       echo "WARNING: The following tests might pull in the drive tray." >&2
+       echo "         Best is if you now put in a suitable media and" >&2
+       echo "         load it manually, so nobody gets surprised. :))" >&2
+       echo >&2
+       echo "Which drive to examine ? (Empty input = ${OUTDEV})" >&2
+       read x
+  fi
+  if test -n "$x"
+  then
+       OUTDEV="$x"
+  fi
+
+  get_speeds "$OUTDEV"
+}
+
+# main
+"$RELENG_XORRISO"  -version
+echo -e "\n${SELF}: Running: $RELENG_XORRISO $devices_opt ..."
+devices=$( ${priv_cmd} "$RELENG_XORRISO" -report_about WARNING $devices_opt | grep "\-dev")
+RET="$?"
+if test "$SIMULATE_FAILURE" = 1
+then
+     echo "===" >&2
+     echo "=== SIMULATING FAILURE BY OVERRIDING EXIT VALUE OF XORRISO" >&2
+     echo "===" >&2
+     echo "FAIL : ${SELF} : Simulated failure caused by option -f"
+     RET=1
+fi
+case ${RET} in
+     0)
+      get_devices "$devices" "$dev"
+      RET="$?"
+      if test "$RET" = 0
+      then :
+      else
+           echo "FAIL : ${SELF} : Device scan or single drive listing failed"
+           exit "$RET"
+      fi
+     ;;
+     *)
+      boldify
+      echo -ne "\n${SELF}: ${priv_cmd} ${RELENG_XORRISO} $devices_opt returned ${RET}."
+      unboldify
+      echo -e  "\n${SELF}: Already mounted?"
+      df -kh
+      exit 1
+esac
+
+exit 0
--- a/releng/manual_isojigdo
+++ b/releng/manual_isojigdo
@ -0,0 +1,288 @@
+#!/bin/bash
+
+# Copyright 2011 Thomas Schmitt <scdbackup@gmx.net>
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Licensed under GNU GPL version 2 or later
+
+set -e
+
+not_in_releng_exit() {
+  printf "\nPlease execute the tests from releng directory.\n\n"
+  exit 1
+}
+
+. inc/releng_getopts.inc || not_in_releng_exit
+
+print_specific_help() {
+cat << HLP
+Specific options:
+       none yet.
+Overview:
+       Match the resulting ISO image representation
+       against the jigdo representation.
+HLP
+}
+
+if test "$SPECIFIC_HELP" = 1; then
+  print_specific_help
+  exit 0
+fi
+
+if [ ! -x $RELENG_XORRISO ]; then
+ print_help
+ printf "\n${SELF}: -x  absolute or relative path to binary to be run.\n\n"
+ exit 30
+fi
+
+# check data dir, if any and after checking -x xorriso
+if [ -d "${GEN_DATA_DIR}" ]; then
+ printf "\n${SELF}: directory %s exists!" ${GEN_DATA_DIR}
+ printf "\n${SELF}: use './${SELF} -c' to remove.\n"
+ exit 1
+else
+ mkdir "${GEN_DATA_DIR}"
+fi
+
+TMP_DATA_DIR=releng_generated_data
+IMG_EXTRACT_DIR=${GEN_DATA_DIR}/${SELF}_extracted_tree
+RELENG_DIR="${IMG_EXTRACT_DIR}"
+RELENG_ISOLINUX_BIN="isolinux/isolinux.bin"
+RELENG_BOOT_CAT="isolinux/boot.cat"
+RELENG_IMG=t1
+RES=""
+REMOTE_URL="http://cdimage.debian.org/cdimage/daily-builds/daily/arch-latest/i386/iso-cd"
+REMOTE_IMG="debian-testing-i386-netinst.iso"
+
+# check for required items
+if [ "${RELENG_XORRISO}" = "" -o "${RELENG_DIR}" = "" -o "${RELENG_IMG}" = "" ]; then
+ echo -e "\n${SELF}: xorriso_cmd IN_dir and OUT_image are required\n"
+ exit 2
+fi
+
+# All must be set at this point
+printf "${SELF}: Config items:"
+printf "\n\txorriso_cmd=${RELENG_XORRISO}\n\tIN_dir=${RELENG_DIR}\n\tOUT_image=${RELENG_IMG}.iso"
+printf "\n\tIN_isolinux=${RELENG_ISOLINUX_BIN}\n\tOUT_bootcat=${RELENG_BOOT_CAT}\n"
+RES="${RELENG_IMG}.iso ${RELENG_IMG}.new ${RELENG_IMG}.md5 ${RELENG_IMG}.jigdo ${RELENG_IMG}.template"
+
+# xorriso version details, incl. underlying libraries
+# "${RELENG_XORRISO}" -version
+
+# check whether the binary support JTE
+set +e
+RETSTR_VER_JTE=`"${RELENG_XORRISO}" --version 2>/dev/null | grep "libjte * in use"`
+RETCODE_VER_JTE="$?"
+set -e
+case ${RETCODE_VER_JTE} in
+     0)
+       printf "\n${SELF}: Found JTE support with ${RELENG_XORRISO} : ${RETSTR_VER_JTE}"
+       ;;
+     *)
+       printf "\nFAIL : ${SELF} : Not found JTE support in ${RELENG_XORRISO}. Quit."
+       printf "\n${SELF}: JTE not supported with this xorriso build. Install jigit >=1.18 and rebuild."
+       printf "\n${SELF}: http://www.einval.com/~steve/software/JTE/\n"
+       cleanup
+       exit 4
+       ;;
+esac
+
+# grab remote ISO image, to decompose
+if [ ! -f "${TMP_DATA_DIR}"/"${REMOTE_IMG}" ]; then
+ printf "\n${SELF}: Downloading ${REMOTE_URL}/${REMOTE_IMG}\n"
+ if wget -V >/dev/null 2>&1
+ then
+   set +e
+   wget --no-check-certificate -T20 -t3 \
+        -O "${TMP_DATA_DIR}"/"${REMOTE_IMG}" "${REMOTE_URL}"/"${REMOTE_IMG}"
+   WGET_RET="$?"
+   set -e
+ elif fetch -T 20 -o "${TMP_DATA_DIR}"/"${REMOTE_IMG}" \
+            "${REMOTE_URL}"/"${REMOTE_IMG}"
+ then
+   WGET_RET=0
+ else
+   echo
+   echo "FAIL: ${SELF} : Neither wget nor fetch are present and willing to work"
+   cleanup
+   exit 10
+ fi
+ case ${WGET_RET} in
+     0)
+      echo -e "\n${SELF}: Downloading successfully completed.\n"
+     ;;
+     *)
+      echo -e "\nFAIL : ${SELF} : wget returned code: $WGET_RET\n"
+      rm "${TMP_DATA_DIR}"/"${REMOTE_IMG}"
+      cleanup
+      exit 5
+     ;;
+ esac
+else
+ printf "\n${SELF}: Found ISO image: ${TMP_DATA_DIR}/${REMOTE_IMG}\n"
+fi
+
+# check for extraction directory existence
+if [ -d "${IMG_EXTRACT_DIR}" ]; then
+ printf "\n${SELF}: Found ${IMG_EXTRACT_DIR}. Please cleanup.\n"
+ cleanup
+ exit 6
+else
+ mkdir "${IMG_EXTRACT_DIR}"
+fi
+
+# extract image content
+CMD_EXTRACT="${RELENG_XORRISO} -indev ${TMP_DATA_DIR}/${REMOTE_IMG} \
+        -osirrox on:auto_chmod_on \
+	-extract / ${IMG_EXTRACT_DIR} \
+"
+
+# TODO: drop set +e|-e block, catch exit code instead when 
+#       the boot catalog warnings get completely resolved.
+echo -e "${SELF}: Extracting ISO image:\n${CMD_EXTRACT}\n"
+set +e
+${CMD_EXTRACT}
+set -e
+
+# grab an MBR
+ISOHYBRID_MBR="${GEN_DATA_DIR}/isohybrid.mbr"
+dd if="${TMP_DATA_DIR}/${REMOTE_IMG}" bs=1K count=32 of="${ISOHYBRID_MBR}"
+
+# create FAT partition
+APPEND_PART="${GEN_DATA_DIR}/fatpart.fat"
+MKFS_MSDOS="/sbin/mkfs.msdos"
+if [ -x "${MKFS_MSDOS}" ]; then
+ "${MKFS_MSDOS}" -n Bla -C "${APPEND_PART}" 8192
+ APPEND_PART_CMD="-append_partition 2 0x01 ${APPEND_PART}"
+else
+ APPEND_PART_CMD=
+
+#  printf "\nFAIL : ${SELF} : Not found: ${MKFS_MSDOS}"
+#  printf "\n${SELF}: Not found: "${MKFS_MSDOS}". Install dosfstools."
+#  printf "\n${SELF}: http://www.daniel-baumann.ch/software/dosfstools/\n"
+#  cleanup
+#  exit 7
+fi
+
+# GENERAL section
+CMD="${RELENG_XORRISO} \
+ -as mkisofs \
+ -quiet \
+ -o ${GEN_DATA_DIR}/${RELENG_IMG}.iso \
+ -R \
+ -V ISOJIGDO \
+ -partition_offset 16 \
+ -J -joliet-long \
+"
+
+# BOOT section
+if [ -f "${IMG_EXTRACT_DIR}"/"${RELENG_ISOLINUX_BIN}" -a -f "${ISOHYBRID_MBR}" ]
+then
+CMD="$CMD \
+ -b ${RELENG_ISOLINUX_BIN} \
+ -c ${RELENG_BOOT_CAT} \
+ -no-emul-boot -boot-load-size 4 -boot-info-table \
+ -isohybrid-mbr ${ISOHYBRID_MBR} \
+ -partition_offset 16 \
+"
+else
+ printf "\n${SELF}: FAIL to compose the boot section.\n"
+ cleanup
+ exit 8
+fi
+if [ -n "${APPEND_PART_CMD}" -a -f "${APPEND_PART}" ]; then
+CMD="$CMD \
+ ${APPEND_PART_CMD} 
+"
+fi
+
+# JIGDO section
+JIGDO_JIGDO=${GEN_DATA_DIR}/${RELENG_IMG}.jigdo
+JIGDO_TEMPLATE=${GEN_DATA_DIR}/${RELENG_IMG}.template
+
+JIGDO_MAP_RHV=$(cd ${RELENG_DIR} 2>/dev/null && pwd)
+
+JIGDO_MAP="Debian=${JIGDO_MAP_RHV}/"
+
+# create jigdo MD5 list in base64 format
+JIGDO_GEN_MD5=${GEN_DATA_DIR}/${RELENG_IMG}.md5
+
+printf "${SELF}: Creating MD5 list in hex format in ${JIGDO_GEN_MD5}..."
+set +e
+./jigdo-gen-md5-list ${RELENG_DIR} > ${JIGDO_GEN_MD5}
+ret=$?
+set -e
+
+if test "$ret" = 0
+then
+  printf "Done.\n"
+else
+  printf "\nFAIL : ${SELF}: ./jigdo-gen-md5-list returns $ret"
+  cleanup
+  exit 9
+fi
+ 
+
+CMD="$CMD \
+ -jigdo-template-compress gzip \
+ -checksum_algorithm_iso md5,sha1,sha256,sha512 \
+ -checksum_algorithm_template md5,sha1,sha256,sha512 \
+ -jigdo-jigdo ${JIGDO_JIGDO} \
+ -jigdo-template ${JIGDO_TEMPLATE} \
+ -jigdo-map ${JIGDO_MAP} \
+ -md5-list ${JIGDO_GEN_MD5} \
+ -jigdo-min-file-size 1024 \
+"
+
+CMD="$CMD ${RELENG_DIR}"
+
+# Run the whole compound command
+echo -e "${SELF}: Creating ISO and jigdo representations:\n$CMD\n"
+${CMD}
+
+# Create another imange this time from jigdo files
+if which jigit-mkimage >/dev/null 2>&1; then
+ printf "${SELF}: Creating new ISO from jigdo files..."
+ jigit-mkimage \
+  -t ${JIGDO_TEMPLATE} \
+  -j ${JIGDO_JIGDO} \
+  -m ${JIGDO_MAP} \
+  -o ${GEN_DATA_DIR}/${RELENG_IMG}.new
+ printf "Done.\n"
+else
+ printf "\n${SELF}: Not found: jigit-mkimage. Install jigit."
+ printf "\n${SELF}: http://www.einval.com/~steve/software/JTE/\n"
+ cleanup
+ exit 10
+fi
+
+# trap the exit code of diff and let the Universe explode
+diff ${GEN_DATA_DIR}/${RELENG_IMG}.iso ${GEN_DATA_DIR}/${RELENG_IMG}.new
+DIFF_RET="$?"
+case ${DIFF_RET} in
+     0)
+      echo -e "${SELF}: Match: diff ${GEN_DATA_DIR}/${RELENG_IMG}.iso ${GEN_DATA_DIR}/${RELENG_IMG}.new"
+     ;;
+     *)
+      echo -e "FAIL : ${SELF} : diff returned code: $DIFF_RET\n"
+     ;;
+esac
+
+# sort out the cruft
+cleanup
+
+# warn about downloaded image left behind
+if [ -f "${TMP_DATA_DIR}"/"${REMOTE_IMG}" ]; then
+ printf "${SELF}: Leaving "
+ ls -sh "${TMP_DATA_DIR}"/"${REMOTE_IMG}"
+fi
+
+# last hints
+if [ -d ${GEN_DATA_DIR} ]; then
+ printf "\n${SELF}: HINT: manual checks remained to be done:\n"
+ printf " * ${GEN_DATA_DIR}/${RELENG_IMG}.iso boots from USB stick and/or optical media.\n"
+ printf " * appended FAT partition is mountable.\n"
+ printf " * xorriso -indev ${GEN_DATA_DIR}/${RELENG_IMG}.iso -pvd_info\n"
+ printf " * fdisk -lu ${GEN_DATA_DIR}/${RELENG_IMG}.iso\n"
+fi
+
+exit 0
--- a/releng/run_all_auto
+++ b/releng/run_all_auto
@ -0,0 +1,254 @@
+#!/bin/bash
+
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Copyright 2011 Thomas Schmitt <scdbackup@gmx.net>
+# Licensed under GNU GPL version 2 or later
+
+set -e
+
+export RELENG_SCRIPT_RUN_BY_RUN_ALL_AUTO=1
+
+SELF=$(basename "$0")
+GEN_DATA_DIR=releng_generated_data
+CLOG=${GEN_DATA_DIR}/log.${SELF}
+CLOG_PREV=${CLOG}.prev
+PASSED_OPTIONS="$@"
+RELENG_XORRISO=
+CLEANUP_LOG=0
+
+# It is not a good idea to include inc/releng_getopts.inc with the
+# master script as it calls the subordinate scripts and they include
+# this file too, and we want to avoid sharing variable with subshells
+if [ ! -f inc/releng_getopts.inc ]; then
+  printf "\nPlease execute the tests from releng directory.\n\n"
+  exit 1
+fi
+
+# To catch the exit value of a command in a pipe
+return_value_file="$GEN_DATA_DIR"/run_all_"$$"_return_value
+return_wrapper()
+{
+ cmd="$1"
+ shift 1
+ "$cmd" "$@"
+ RET="$?"
+ echo "$RET" >"$return_value_file"
+ return "$RET"
+}
+
+# Using only bash builtin commands.
+# On 4 year old amd64 x2 3000 MHz, xterm local,it counts 22471 lines per second
+# On 2 year old amd64 x4 2600 MHz, ssh remote, it counts 35348 lines per second
+count_lines()
+{
+ # $1 if not empty: start count
+ line=
+ if test -n "$1"
+ then
+   count="$1"
+ else
+   count=0
+ fi
+ while read line
+ do
+   count=$(($count + 1))
+   printf "\r  %4d lines logged ... " "$count" >&2
+   printf "%s\n" "$line"
+ done
+ return 0
+}
+
+#############################################
+print_usage()
+{
+cat << HLP
+
+${SELF} runs executables from releng directory starting with auto_*,
+and passing them its own options. stdout/stderr output is stored in:
+./${CLOG} (last run) and
+./${CLOG_PREV} (previous run)
+
+Usage: ${SELF} -x path/to/xorriso [-k] [-c] [-h]
+   -x  absolute or relative path to xorriso binary to be run.
+   -k  keep self-generated data in ./${GEN_DATA_DIR}.
+   -c  cleanup self-generated data kept from previous run and exit.
+   -h  print this help text
+				   
+Examples:
+# run xorriso and keep the self-generated data
+ $ ./${SELF} -x path/to/xorriso -k
+
+# clean up self-generated data from previous run
+ $ ./${SELF} -c
+
+HLP
+}
+
+#############################################
+if [ ! "${1}" ]; then
+ print_usage
+ exit 0
+fi
+next_is=
+for i in "$@"
+do
+  if test x"$i" = x"-h" -o x"$i" = x"--h" -o x"$i" = x"-help" -o x"$i" = x"--help"
+  then :
+       print_usage
+       exit 0
+  fi
+
+  if test "$next_is" = "ignore"
+  then :
+  elif test "$next_is" = "x"
+  then
+       RELENG_XORRISO="$i"
+       next_is=
+  elif test x"$i" = x"-x"
+  then
+       next_is="x"
+  elif test x"$i" = x"-c"
+  then
+       CLEANUP_LOG=1
+  fi
+done
+#############################################
+if test "$next_is" = x
+then
+       echo
+       echo "Option -x expects an argument (the path to the xorriso program)"
+       exit 31
+fi
+
+
+########################################################
+ if [ -f "${CLOG}" ]; then
+   mv "${CLOG}" "${CLOG_PREV}"
+ fi
+ > ${CLOG}
+ if [ -x "${RELENG_XORRISO}" ]; then
+    echo "_OVERVIEW_______________________________________________________________" >> ${CLOG}
+    date -u                                                                         >> ${CLOG}
+    ${RELENG_XORRISO} --version                                                        >> ${CLOG}
+    echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" >> ${CLOG}
+ fi
+ DSTART=`date -u`
+ echo "${SELF}: Started at ${DSTART}" | tee -a ${CLOG}
+ E1=`date '+%s'`
+ exit_value=0
+ # require ^auto_, avoid running (your)self explicitly
+ for s in `ls | grep ^auto_ | grep -v ${SELF} | sort -n`; do
+  if [ -x ${s} -a ! -d ${s} ]; then
+    echo >> ${CLOG}
+    echo >> ${CLOG}
+    echo "_STARTING_TEST_________________________________________________________"      >> ${CLOG}
+    echo "${SELF}: Running ./${s} ${PASSED_OPTIONS} :" \
+    | tee -a ${CLOG}
+    T1=`date '+%s'`
+    set +e
+
+    if test -n "$PIPESTATUS"
+    then
+      # PIPESTATUS[0] should be available in bash
+      ./${s} ${PASSED_OPTIONS} 2>&1 | count_lines >> ${CLOG}
+      RET="${PIPESTATUS[0]}"
+    else
+      # a more portable method which uses a temporary file to record exit value
+      return_wrapper ./${s} ${PASSED_OPTIONS} 2>&1 | count_lines >> ${CLOG}
+      RET=$(cat "$return_value_file")
+      rm "$return_value_file"
+    fi
+#   echo "RET='$RET'" >/dev/tty
+
+    T2=`date '+%s'`
+    TS=`expr ${T2} - ${T1}`
+    case ${RET} in
+         0)
+           echo "done in ${TS} sec. ok."
+           ;;
+         *)
+           exit_value=2
+	   printf "done in ${TS} sec. "
+           which tput >/dev/null 2>&1 && tput smso
+           printf "FAIL -> EXIT CODE $RET"
+           which tput >/dev/null 2>&1 && tput rmso
+           echo
+           ;;
+    esac
+    set -e
+  fi
+ done
+
+ DEND=`date -u`
+ echo | tee -a ${CLOG}
+ echo -n "${SELF}: Stopped at ${DEND}." | tee -a ${CLOG}
+ if   [ "${CLEANUP_LOG}" -eq 1 ]; then
+      if [ -f "${CLOG}" ]; then
+	 rm -f "${CLOG}"
+         echo # | tee -a ${CLOG}
+         echo -n "${SELF}: Removed my own log ${CLOG}." # | tee -a ${CLOG}
+      fi
+      if [ -f "${CLOG_PREV}" ]; then
+         rm -f "${CLOG_PREV}"
+         echo # | tee -a ${CLOG}
+         echo "${SELF}: Removed my own log ${CLOG_PREV}." # | tee -a ${CLOG}
+      fi
+ else
+      E2=`date '+%s'`
+      if [ ${E2} -eq ${E1} ]; then
+        echo " Total elapsed 0 sec." | tee -a ${CLOG}
+      else
+        ES=`expr ${E2} - ${E1}`
+        echo " Total elapsed ${ES} sec." | tee -a ${CLOG}
+      fi
+      #####
+      echo >> ${CLOG}
+      echo "_SUMMARY________________________________________________________________" >> ${CLOG}
+      echo "${SELF}: Trivial log examination: ${CLOG}" | tee -a ${CLOG}
+      echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" | tee -a ${CLOG}
+      # severity classes of libdax_msgs.h in libburn and libisofs
+      # List of boring keywords:
+      #   'UPDATE|NOTE|DEBUG|ALL' - not considered interesting for lazy log inspection.
+      # List of interesting keywords:
+        # thrown by xorriso and underlying libraries
+      LIST_KWD="NEVER|ABORT|FATAL|FAILURE|MISHAP|SORRY|WARNING|HINT"
+        # thrown by others
+      LIST_KWD="${LIST_KWD}|FAIL|ERROR|WRONG"
+
+      if [ -f "${CLOG}" ]; then
+          set +e
+	  # lines, perl regex, leading tabs
+          grep -n -E "${LIST_KWD}" "${CLOG}"
+	  RET_GREP="$?"
+          case ${RET_GREP} in
+              0) # found
+                 ;;
+              1) # not found
+		 echo "${SELF}: Log file looks clear." # | tee -a ${CLOG}
+                 ;;
+	      *) #
+                 echo "${SELF}: grep returned EXIT CODE: ${RET_GREP}." # | tee -a ${CLOG}
+		 ;;
+          esac
+	  set -e
+      fi
+      echo "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" | tee -a ${CLOG}
+
+      ##### TODO: work out a less noisy diff'ing technique!
+      if [ -f "${CLOG_PREV}" -a -f "${CLOG}" ]; then
+        echo "${SELF}: See diff against previous log file (might be long):" | tee -a ${CLOG}
+	echo "diff -Naur ${CLOG_PREV} ${CLOG} | less" | tee -a ${CLOG}
+      fi
+
+ fi
+ 
+ #
+ which tput >/dev/null 2>&1 && tput smso
+ echo # | tee -a ${CLOG}
+ echo "${SELF}: Leaving the following cruft in ${GEN_DATA_DIR}:" # | tee -a ${CLOG}
+ which tput >/dev/null 2>&1 && tput rmso
+ ls -lth "${GEN_DATA_DIR}" # | tee -a ${CLOG}
+
+ # Fin
+ exit $exit_value
+
--- a/releng/template_new
+++ b/releng/template_new
@ -0,0 +1,135 @@
+#!/bin/bash
+
+# Copyright 2011 George Danchev <danchev@spnet.net>
+# Copyright 2011 Thomas Schmitt <scdbackup@gmx.net>
+# === TEMPLATE: Add your own copyright here
+#
+# Licensed under GNU GPL version 2 or later
+
+# === TEMPLATE: Remove this remark before releasing this script.
+#
+# This is a template for creating a new libisoburn/releng test.
+# It is supposed that you have read releng/README before you begin to work
+# here.
+#
+# Step 1: Invent a name for your test
+#           test_name="manual_"...some.name...
+#         or
+#           test_name="auto_"...some.name...
+#
+# Step 2: Copy releng/template_new to $test_name
+# 
+# Step 3: Edit $test_name and process any line that begins by
+#         "# === TEMPLATE:". Do what the line prescribes and then remove it
+#         from the script. You are not done as long as such a line remains.
+#
+# === TEMPLATE: End of remark to remove
+
+set -e
+
+
+# === TEMPLATE: Describe your own specific options (if any) and the test
+print_specific_help() {
+cat << HLP
+Specific options:
+       --option  Explanation of specific option
+Overview:
+       Short explanation of test purpose and activities.
+HLP
+} 
+
+
+getopts_inc=inc/releng_getopts.inc
+if test -e "$getopts_inc"
+then
+  . "$getopts_inc"
+  
+  if test "$SPECIFIC_HELP" = 1
+  then
+       print_specific_help
+       exit 0
+  fi
+else
+  echo >&2
+  echo "File not found: $getopts_inc" >&2
+  echo "Are we in the ./releng directory of a libisoburn SVN checkout ?" >&2
+  echo "(Please execute the tests from that ./releng directory.)" >&2
+  echo >&2
+  exit 29  
+fi
+
+
+# === TEMPLATE: Decide whether the test will have own options,
+# === TEMPLATE: apart from those interpreted by inc/releng_getopts.inc
+# === TEMPLATE: If not, then remove this interpreter code.
+# Set default values for specific option variables. E.g.:
+# dev=
+# Interpret specific options, they begin after the first --.
+next_is=ignore
+for i in "$@"
+do
+  if test "$next_is" = "ignore"
+  then
+       if test "$i" = "--"
+       then
+            next_is=""
+       fi
+
+# === TEMPLATE: Implement interpretation of specific options. Like:
+#  elif test "$next_is" = "dev"
+#  then
+#       dev="$i"
+#       next_is=""
+#  elif test "$i" = "--dev"
+#  then
+#       next_is="dev"
+
+  else
+       echo >&2
+       echo "Unknown test specific option: $i" >&2
+       print_help
+       print_specific_help
+       exit 31
+  fi
+done
+# === TEMPLATE: End of own option interpreter code. 
+
+
+# Each test should decide whether or not it needs
+# a xorriso binary to test, since some do compilations only.
+# === TEMPLATE: Decide whether you need a xorriso program.
+# === TEMPLATE: If not, then remove this function call
+check_for_xorriso -x
+
+
+# check data dir, if any and after checking -x xorriso
+# === TEMPLATE: Decide whether your test will possibly create own files.
+# === TEMPLATE: If yes, then create your files underneath ${GEN_DATA_DIR}.
+# === TEMPLATE: The name in this variable is set by inc/releng_getopts.inc .
+# === TEMPLATE: If not, then remove this if ... fi statement.
+if [ -d "${GEN_DATA_DIR}" ]; then
+ printf "\n${SELF}: directory %s exists!" ${GEN_DATA_DIR}
+ printf "\n${SELF}: use '${SELF} -c' to remove.\n"
+ exit 30
+else
+ mkdir "${GEN_DATA_DIR}"
+fi
+
+
+#####################################################################
+
+
+# === TEMPLATE: Perform your test activities here.
+
+
+# === TEMPLATE: In case of failure, issue a line to stdout that begins by
+# === TEMPLATE: the word "FAIL", and make sure that the test script finally
+# === TEMPLATE: returns a non-zero exit value.
+# === TEMPLATE: 31 = Unknown option or unusable argument with known option
+# === TEMPLATE: 30 = Unexpected state of own directory for self generated files
+# === TEMPLATE: 29 = Not in ./releng directory or missing essential parts
+# === TEMPLATE: 1 to 28 = test specific exit values
+# === TEMPLATE: When exiting prematurely, make sure to call cleanup.
+
+cleanup
+exit 0
--- a/test/compare_file.c
+++ b/test/compare_file.c
@ -13,6 +13,10 @@
  cc -g -o compare_file compare_file.c
 */

+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <ctype.h>
 #include <sys/types.h>
 #include <unistd.h>
@ -126,11 +130,13 @@ int Compare_2_files(char *adr1, char *adr2, char *adrc, int flag)
   differs= 1;
 }
 if(s1.st_uid != s2.st_uid) {
-   printf("%s : st_uid   :  %d  <>  %d\n", a, s1.st_uid, s2.st_uid);
+   printf("%s : st_uid   :  %lu  <>  %lu\n",
+          a, (unsigned long) s1.st_uid, (unsigned long) s2.st_uid);
   differs= 1;
 }
 if(s1.st_gid != s2.st_gid) {
-   printf("%s : st_gid   :  %d  <>  %d\n", a, s1.st_gid, s2.st_gid);
+   printf("%s : st_gid   :  %lu  <>  %lu\n",
+          a, (unsigned long) s1.st_gid, (unsigned long) s2.st_gid);
   differs= 1;
 }
 if((S_ISCHR(s1.st_mode) && S_ISCHR(s2.st_mode)) ||
@ -248,6 +254,12 @@ int main(int argc, char **argv)
 int ret, i, with_ctime= 1;
 char adr1[4096], adr2[4096], adrc[4096];

+ if(sizeof(off_t) < 8) {
+   fprintf(stderr,
+    "%s : FATAL : Compile time misconfiguration. sizeof(off_t) too small.\n\n",
+    argv[0]);
+   exit(4);
+ }
 if(argc<4) {
   fprintf(stderr, "usage: %s  path  prefix1  prefix2\n", argv[0]);
   exit(2);
@ -257,7 +269,7 @@ int main(int argc, char **argv)
     with_ctime= 0;
   else {
     fprintf(stderr, "%s : Option not recognized: '%s'\n", argv[0], argv[i]);
-     exit(1);
+     exit(2);
   }
 }

--- a/xorriso/AUTHORS_gnu_xorriso
+++ b/xorriso/AUTHORS_gnu_xorriso
@ -3,4 +3,13 @@ Ben Jansens
 Thomas Schmitt
 Mario Danic
 Vreixo Formoso Lopes
+Colin Plumb
+Tatu Ylonen
+Jim Kingdon
+Scott G. Miller
+Ulrich Drepper
+Richard Atterer
+Steve McIntyre
+George Danchev
+and possibly others who gave their copyright to Free Software Foundation, Inc.

--- a/xorriso/COPYRIGHT_gnu_xorriso
+++ b/xorriso/COPYRIGHT_gnu_xorriso
@ -3,15 +3,22 @@ Ben Jansens <xor@orodu.net>
 Thomas Schmitt <scdbackup@gmx.net>
 Mario Danic <mario.danic@gmail.com>,
 Vreixo Formoso <metalpain2002@yahoo.es> 
+Steve McIntyre <steve@einval.com>
+George Danchev <danchev@spnet.net>

-GNU xorriso is a compilation of
-xorriso     Copyright (C) 2007-2010 Thomas Schmitt
-libisoburn  Copyright (C) 2007-2010 Vreixo Formoso, Thomas Schmitt
-libisofs    Copyright (C) 2007-2010 Vreixo Formoso, Mario Danic, Thomas Schmitt
+GNU xorriso is a compilation of modules from libburnia-project.org :
+xorriso     Copyright (C) 2007-2011 Thomas Schmitt
+libisoburn  Copyright (C) 2007-2011 Vreixo Formoso, Thomas Schmitt
+libisofs    Copyright (C) 2007-2011 Vreixo Formoso, Mario Danic, Thomas Schmitt
 libburn     Copyright (C) 2002-2006 Derek Foreman, Ben Jansens
-                          2006-2010 Mario Danic, Thomas Schmitt
-from libburnia-project.org with a license derived from GPLv2+.
+                          2006-2011 Mario Danic, Thomas Schmitt
+Further included is :
+libjte      Copyright (C) 2000-2007 Free Software Foundation, Inc.
+                          2004-2011 Steve McIntyre
+                          2010-2011 George Danchev, Thomas Schmitt

+Originally they all are licensed directly or indirectly as GPLv2+.
+GNU xorriso is licensed by the following statement:

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License version 3
--- a/xorriso/README_gnu_xorriso
+++ b/xorriso/README_gnu_xorriso
@ -4,7 +4,7 @@
 GNU xorriso. By Thomas Schmitt <scdbackup@gmx.net>
 Derived from and supported by libburnia-project.org, published via:
 http://www.gnu.org/software/xorriso/xorriso_eng.html
-ftp://ftp.gnu.org/gnu/xorriso/xorriso-0.5.2.tar.gz
+http://www.gnu.org/software/xorriso/xorriso-1.2.8.tar.gz
 Provided under GPL version 3 or later. No warranty.
 ------------------------------------------------------------------------------

@ -20,8 +20,9 @@ A special property of xorriso is that it needs neither an external ISO 9660
 formatter program nor an external burn program for CD or DVD but rather
 incorporates the libraries of libburnia-project.org .

-Currently it is fully supported on GNU/Linux with kernels >= 2.4 and on
-FreeBSD versions with ATAPI/CAM support enabled in the kernel, see atapicam(4).
+Currently it is fully supported on GNU/Linux with kernels >= 2.4,
+on FreeBSD with ATAPI/CAM support enabled in the kernel, see atapicam(4),
+and on OpenSolaris (tested with kernel 5.11).
 On other X/Open compliant systems there will only be POSIX i/o with disk
 file objects, but no direct MMC operation on CD/DVD/BD drives.

@ -31,8 +32,7 @@ By using this software you agree to the disclaimer at the end of this text:

                   Compilation, First Glimpse, Installation

-The most simple way to get xorriso from source code is the xorriso standalone
-tarball.
+The most simple way to get xorriso from source code is the GNU xorriso tarball.

 Prerequisites:
 The tarball contains everything that is needed except the following system
@ -41,15 +41,15 @@ components:
   plus on FreeBSD: libiconv, libcam, IDE and SATA drives need atapicam
 Optional at compile time are:
   libreadline and the readline-dev headers make dialog mode more convenient.
-   on GNU/Linux: libacl and libacl-devel allow getting and setting ACLs.
   zlib and zlib-devel allow zisofs compression.
+   on GNU/Linux: libacl and libacl-devel allow getting and setting ACLs.
 If they were present at compile time, then the optional libraries have to
 be present at runtime, too.

-Obtain xorriso-0.5.2.tar.gz, take it to a directory of your choice and do:
+Obtain xorriso-1.2.8.tar.gz, take it to a directory of your choice and do:

-    tar xzf xorriso-0.5.2.tar.gz
-    cd xorriso-0.5.2
+    tar xzf xorriso-1.2.8.tar.gz
+    cd xorriso-1.2.8

 Within that directory execute:

@ -72,15 +72,14 @@ or you may execute as superuser:

 For general concepts, options and usage examples see
    info xorriso
+    info xorrisofs
+    info xorrecord
 or
    man 1 xorriso
+    man 1 xorrisofs 
+    man 1 xorrecord 

-The documents are part of the tarball as
-    xorriso/xorriso.info
-    xorriso/xorriso.1
-Original source text of both is
-    xorriso/xorriso.texi
-You may get a first glimpse by
+You may get a first glimpse by e.g.
    info ./xorriso/xorriso.info
    man ./xorriso/xorriso.1

@ -97,12 +96,15 @@ development package is installed, then rather build xorriso by:
 Never omit the "make clean" command after switching libreadline enabling.
 Other deliberate dependency reduction options of ./configure are:
    --disable-libacl   avoid use of ACL functions like acl_to_text()
-    --disable-xattr    avoid use of xattr functions like listxattr()
-    --disable-zlib     avoid use of zlib functions like compress2()
+    --disable-xattr    avoid use of xattr functions like listxattr() on Linux
+                       resp. extattr_list_file() on FreeBSD
+    --disable-zlib     avoid use of zlib functions like compress2() 
+                       this also avoids the use of libjte and option -jigdo.

 xorriso brings own system adapters which allow burning optical media on
-GNU/Linux and FreeBSD. Alternatively it can use libcdio-0.83 or later for
-sending commands to optical drives:
+GNU/Linux, FreeBSD, Solaris.
+Alternatively it can use libcdio-0.83 or later for sending commands to
+optical drives:
    --enable-libcdio

 xorriso allows to use external processes as file content filters. This is
@ -125,6 +127,53 @@ and the cdrecord emulation of xorriso can be told to use this peculiar read
 mode by:
    --enable-track-src-odirect

+Linux only:
+libburn tries to avoid a collision with udev's drive examination by waiting
+0.1 seconds before opening the device file for a longer time, after udev
+might have been alarmed by drive scanning activities.
+The waiting time can be set at ./configure time with microsecond granularity.
+E.g. 2 seconds:
+  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=2000000"
+  ./configure ...options...
+Waiting can be disabled by zero waiting time:
+  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=0"
+Alternatively, libburn can try to be nice by opening the device file,
+closing it immediately, waiting, and only then opening it for real:
+  CFLAGS="$CFLAGS -DLibburn_udev_extra_open_cyclE -DLibburn_udev_wait_useC=500000"
+
+
+             xorriso under control of a (GUI) frontend process
+
+The dialog mode allows frontend programs to connect via pipes to the standard
+input and output of xorriso. Several commands of xorriso help with receiving
+and parsing of reply messages.
+
+As a proof of concept, there is the Tcl/Tk script xorriso-tcltk which can
+be launched by this shell command:
+
+    xorriso-tcltk
+
+Or in the xorriso build directory, without installation of xorriso:
+
+    xorriso/xorriso -launch_frontend frontend/xorriso-tcltk --stdio --
+
+In the running GUI, click with the rightmost mouse button on any GUI element
+to get its particular help text. The "Help" button at the upper right corner
+gives a short introduction and instructions for some common use cases.
+See also file frontend/README-tcltk.
+See its Tcl code for getting an idea how this gets achieved.
+
+The script is part of the tarball and gets installed by make install. If a 
+xorriso distro package does not install it, you may get it directly from
+  http://libburnia-project.org/export/head/libisoburn/trunk/frontend/xorriso-tcltk
+
+Further there is the C program frontend/frontend_pipes_xorriso.c which
+forks a xorriso process and shows the same communication gestures as 
+xorriso-tcltk.
+In particular it connects to xorriso via two pipes, sends commands, waits 
+for all replies of a command, picks info out of the xorriso message sieve, 
+and parses reply message lines into words.
+

                       Drives and Disk File Objects 

@ -134,34 +183,51 @@ A list of rw-accessible drives can be obtained by

    xorriso -devices

-CD devices which offer no rw-permission are invisible to normal users.
+CD devices which offer not enough permission are invisible to normal users.
 The superuser should be able to see any usable drive and then set the
 permissions as needed.
+On Linux and FreeBSD, rw-permissions are needed.
+On Solaris, the privilege "sys_devices" and r-permission are needed.

 The output of  xorriso -devices  might look like

 0  -dev '/dev/sr0' rwrw-- :  'TSSTcorp' 'CDDVDW SH-S203B' 
 1  -dev '/dev/hda' rwrw-- :  'HL-DT-ST' 'DVD-ROM GDR8162B' 

-Full and insecure enabling of both for everybody would look like
+On Linux, full and insecure enabling of both for everybody would look like
    chmod a+rw /dev/sr0 /dev/hda
 This is equivalent to the traditional setup chmod a+x,u+s cdrecord.

+On FreeBSD, device permissions are to be set in /etc/devfs.rules.
+On Solaris, pfexec privileges may be restricted to "basic,sys_devices".
+See below "System Dependent Drive Permission Examples".
+
 I strongly discourage to run xorriso with setuid root or via sudo !
 It is not checked for the necessary degree of hacker safety.
-
-Consider to put all authorized users into group "floppy", to chgrp the
-device file to that group and to disallow w-access to others.
+Better consider to grant the necessary permissions to group "floppy"
+and to add users to it.


 A possible source of problems are hald or other automounters. 
 If you can spot a process "hald-addon-storage" with the address of
 your desired drive, then consider to kill it.
+A similar process "udisks-daemon: polling ..." can be seen on newer Linuxes.

-If you cannot get rid of the automounter that easily, try whether it helps
-to always load the drive tray manually before starting a write run of
-xorriso. Wait until the drive light is off.
-Better try to unmount an eventually mounted media before a write run.
+On Debian GNU/Linux 6.0.2 amd64 there is
+  /lib/udev/rules.d/80-udisks.rules 
+where one can remove all CD drives ("sr*") from the list of automountable 
+devices:
+  KERNEL=="sd*|hd*|mmcblk*|mspblk*", ENV{UDISKS_PRESENTATION_NOPOLICY}="0"
+  # KERNEL=="sd*|hd*|sr*|mmcblk*|mspblk*", ENV{UDISKS_PRESENTATION_NOPOLICY}="0"
+Copying the recognition criterion from
+  /etc/udev/rules.d/70-persistent-cd.rules
+one can prevent automounting a single drive, too:
+  SUBSYSTEM=="block", ENV{ID_CDROM}=="?*", ENV{ID_PATH}=="pci-0000:00:11.0-scsi-2:0:0:0", ENV{UDISKS_PRESENTATION_NOPOLICY}:="1"
+
+If you cannot get rid of the automounter, try whether it helps to always load 
+the drive tray manually before starting a write run of xorriso. Wait until the 
+drive light is off and the mounted media appears.
+Then try to unmount the mounted media before a write run.


 Besides true optical drives, xorriso can also address disk files as input or
@ -177,6 +243,12 @@ which is accessible by generic SCSI/MMC commands.

                              Testing

+For automated and manual tests of xorriso's functionality see file
+  releng/README
+
+
+              Result comparison with self produced ISO images
+
 We are quite sure that libisofs produces accurate representations of the disk
 files. This opinion is founded on a lot of test burns and checks by a little
 test program which compares files from the mounted image with the orignals
@ -232,7 +304,7 @@ any file but rather tell the MD5 of a certain range of data blocks.
 The superblock checksum tag is written after the ECMA-119 volume descriptors.
 The tree checksum tag is written after the ECMA-119 directory entries.
 The session checksum tag is written after all payload including the checksum
-array. (Then follows eventual padding.)
+array. (Then follows padding.)

 The tags are single lines of printable text, padded by 0 bytes. They have
 the following format:
@ -248,12 +320,12 @@ Tag_id distinguishes the following tag types
  "libisofs_checksum_tag_v1"            Session end tag

 A relocated superblock may appear at LBA 0 of an image which was produced for
-being stored in a disk file or on overwriteable media (e.g. DVD+R, BD-RE).
-xorriso records the first session at LBA 32. An eventual follow-up session
+being stored in a disk file or on overwriteable media (e.g. DVD+RW, BD-RE).
+xorriso records the first session at LBA 32. A follow-up session
 begins at the next block address which is divisible by 32 and higher than the
 address of the previous session's end tag. Normally no session starts after the
 address given by relocated superblock parameter session_start=.
-Session oriented media like CD-R[W], DVD+R, BD-R will have no relocated
+Session oriented media like CD-R[W], DVD-R, DVD+R, BD-R will have no relocated
 superblock but rather bear a table-of-content on media level.

 A tag is valid if pos= tells its own block address and self= tells its own MD5
@ -266,31 +338,109 @@ The newline character at the end is mandatory.

                             libisoburn

-xorriso is based on libisofs which does ISO 9600 filesystem aspects and on
+xorriso is based on libisofs which does ISO 9660 filesystem aspects and on
 libburn which does the input and output aspects. Parts of this foundation
 are accessed via libisoburn, which is closely related to xorriso.

-libisoburn provides two services:
+libisoburn provides several services:
 - Encapsulation of coordination between libisofs and libburn.
 - Emulation of ISO 9660 multi-session on overwriteable media
  or random access files.
+- Implementation of the xorriso API.

 The sourcecode of all three libraries is included in the xorriso standalone
 tarball. It is compiled with xorriso and linked statically.
 But you may as well get and install releases of libburn and libisofs, in order
 to be able to install a release of libisoburn which produces libisoburn.so.1
 and a matching dynamically linked xorriso binary.
-This binary is leaner but depends on properly installed libraries of suitable
-revision.
+This binary is very lean but depends on properly installed libraries of
+suitable revision.

-Dynamic library and compile time header requirements for libisoburn-0.5.2 :
- libburn.so.4  , version libburn-0.7.6 or higher
- libisofs.so.6 , version libisofs-0.6.28 or higher
+Dynamic library and compile time header requirements for libisoburn-1.2.8 :
+- libburn.so.4  , version libburn-1.2.8 or higher
+- libisofs.so.6 , version libisofs-1.2.8 or higher
 libisoburn and xorriso will not start with libraries which are older than their
 headers seen at compile time. So compile in the oldest possible installation
 setup unless you have reason to enforce a newer bug fix level.

-Standalone xorriso has less runtime dependencies and can be moved more freely.
+GNU xorriso has less runtime dependencies and can be moved more freely.
+
+
+                  System Dependent Drive Permission Examples
+
+Accessing the optical drives requires privileges which usually are granted
+only to the superuser. GNU/Linux, FreeBSD and Solaris offer quite different
+approaches for avoiding the need for unrestricted privileges.
+
+First check whether some friendly system setting already allows you to
+access the drives as normal user:
+  xorriso -devices
+Those drives of which you see address and type strings are already usable.
+
+If there remain drives invisible which the superuser can see by the same
+command, then the following examples might help:
+
+---------------------
+On all three systems:
+---------------------
+Add the authorized users of CD drives to group "floppy" in /etc/group.
+If missing: create this group.
+Changes to /etc/group often only affect new login sessions. So log out and in
+before making the first tests.
+
+-------------
+On GNU/Linux:
+-------------
+Allow rw-access to the drives
+  chgrp floppy /dev/sr0 /dev/sr1
+  chmod g+rw   /dev/sr0 /dev/sr1
+It might be necessary to perform chgrp and chmod after each reboot or to
+edit distro dependent device configuration files for permanent settings.
+
+-----------
+On FreeBSD:
+-----------
+Edit /etc/devfs.rules and make sure to have these lines
+  [localrules=10]
+  add path 'acd*' mode 0664 group floppy
+  add path 'cd*' mode 0664 group floppy
+  add path 'pass*' mode 0664 group floppy
+  add path 'xpt*' mode 0664 group floppy
+  [localrules=5]
+  add path 'pass*' mode 0664 group floppy
+  add path 'cd*' mode 0664 group floppy
+  add path 'xpt*' mode 0664 group floppy
+  add path 'acd*' mode 0664 group floppy
+
+Edit /etc/rc.conf and add the following line if missing
+  devfs_system_ruleset="localrules"
+
+This gets into effect by reboot or by command
+  /etc/rc.d/devfs start
+
+-----------
+On Solaris:
+-----------
+Run xorriso by
+  pfexec xorriso ...arguments...
+
+The following settings will make pfexec keep original UID and EUID and prevent
+most superuser powers. Be aware that you still can manipulate all device files
+if you have the file permissions for that.
+Full root privileges for xorriso can then be acquired only by command su.
+
+Edit /etc/security/exec_attr and add this line to the other "Media Backup"
+lines:
+  Media Backup:solaris:cmd:::/usr/local/bin/xorriso:privs=basic,sys_devices
+Edit /etc/user_attr and add profile "Media Backup" to the user's line:
+  thomas::::profiles=Media Backup,Primary Administrator;roles=root
+See also man privileges, man exec_attr, man user_attr.
+
+Then allow the group r-access to the drives
+  pfexec chgrp floppy /dev/rdsk/c3t0d0s2 /dev/rdsk/c4t0d0s2
+  pfexec chmod g+r    /dev/rdsk/c3t0d0s2 /dev/rdsk/c4t0d0s2
+The last two commands have to be executed after each boot. I do not know
+the relevant device configuration files yet.


 ------------------------------------------------------------------------------
@ -326,17 +476,23 @@ By Mario Danic           <mario.danic@gmail.com>,  libburn, libisofs
   Vreixo Formoso        <metalpain2002@yahoo.es>, libisofs, libisoburn
   Thomas Schmitt        <scdbackup@gmx.net>,      libburn, libisofs,
                                                   libisoburn, xorriso
-Copyright (C) 2006-2010 Mario Danic, Vreixo Formoso, Thomas Schmitt.
+Copyright (C) 2006-2013 Mario Danic, Vreixo Formoso, Thomas Schmitt.

 libburnia-project.org is inspired by and in libburn still containing parts
 of old
 Libburn. By Derek Foreman <derek@signalmarketing.com> and
            Ben Jansens <xor@orodu.net>
 Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
+
+GNU xorriso contains libjte out of source package jigit >= 1.17
+Copyright (C) 2000-2007 Free Software Foundation, Inc.
+              2004-2011 Steve McIntyre
+              2010-2011 George Danchev, Thomas Schmitt
+
 ------------------------------------------------------------------------------

 This text itself is
-Copyright (c) 2007 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+Copyright (c) 2007 - 2013 Thomas Schmitt <scdbackup@gmx.net>
 and is freely distributable.
 It shall only be modified in sync with the technical properties of xorriso.
 If you make use of the license to derive modified versions of xorriso
--- a/xorriso/aux_objects.c
+++ b/xorriso/aux_objects.c
--- a/xorriso/aux_objects.h
+++ b/xorriso/aux_objects.h
@ -0,0 +1,186 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of classes:
+
+   - SplitparT which represents byte intervals of data files.
+
+   - DirseQ which crawls along a directory's content list.
+
+   - ExclusionS which manages the list of excluded file paths and 
+     leaf patterns.
+
+   - Xorriso_lsT which provides a generic double-linked list.
+
+   - LinkiteM, PermiteM which temporarily record relations and states.
+
+*/
+
+
+#ifndef Xorriso_pvt_auxobj_includeD
+#define Xorriso_pvt_auxobj_includeD yes
+
+struct SplitparT;
+
+int Splitparts_new(struct SplitparT **o, int count, int flag);
+
+int Splitparts_destroy(struct SplitparT **o, int count, int flag);
+
+int Splitparts_set(struct SplitparT *o, int idx,
+                   char *name, int partno, int total_parts,
+                   off_t offset, off_t bytes, off_t total_bytes, int flag);
+
+int Splitparts_get(struct SplitparT *o, int idx, char **name, int *partno,
+                   int *total_parts, off_t *offset, off_t *bytes, 
+                   off_t *total_bytes, int flag);
+
+int Splitpart__parse(char *name, int *partno, int *total_parts,
+                    off_t *offset, off_t *bytes, off_t *total_bytes, int flag);
+
+int Splitpart__is_part_path(char *path, int flag);
+
+int Splitpart__compose(char *adr, int partno, int total_parts,
+                       off_t offset, off_t bytes, off_t total_bytes, int flag);
+
+int Splitpart__read_next_num(char *base_pt, char **next_pt, off_t *num,
+                             int flag);
+
+int Splitparts_sort(struct SplitparT *o, int count, int flag);
+
+
+
+struct DirseQ;
+
+int Dirseq_new(struct DirseQ **o, char *adr, int flag);
+
+int Dirseq_destroy(struct DirseQ **o, int flag);
+
+int Dirseq_next_adr(struct DirseQ *o, char reply[SfileadrL], int flag);
+
+int Dirseq_rewind(struct DirseQ *o, int flag);
+
+
+
+struct Xorriso_lsT {
+  char *text;
+  struct Xorriso_lsT *prev,*next;
+};
+
+/** Create a new list item with arbitrary byte content.
+    @param lstring  The newly created object or NULL on failure
+    @param data     An array of bytes to be copied into the new object
+    @param data_len Number of bytes to be copied
+    @param link     Xorriso_lsT object to which the new object shall be linked
+    @param flag Bitfield for control purposes
+                bit0= insert before link rather than after it
+                bit1= do not copy data (e.g. because *data is invalid)
+                bit2= attach data directly by pointer rather than by copying
+    @return <=0 error, 1 ok
+*/
+int Xorriso_lst_new_binary(struct Xorriso_lsT **lstring, char *data,
+                           int data_len, struct Xorriso_lsT *link, int flag);
+
+
+/** Create a new list item with a 0-terminated text as content.
+    @param lstring  The newly created object or NULL on failure
+    @param text     A 0-terminated array of bytes
+    @param link     Xorriso_lsT object to which the new object shall be linked
+    @param flag     see Xorriso_lst_new_binary
+    @return <=0 error, 1 ok
+*/
+int Xorriso_lst_new(struct Xorriso_lsT **lstring, char *text,
+                    struct Xorriso_lsT *link, int flag);
+
+
+/** Create a new list item at the end of a given list.
+    @param entry    Contains as input a pointer to a pointer to any existing
+                    list item. As output this list item pointer may be
+                    changed to the address of the new list item:
+                    if ((*entry == 0) || (flag & 1))
+    @param data     An array of bytes to be copied into the new object
+    @param data_len Number of bytes to be copied
+    @param flag     Bitfield for control purposes
+                    bit0= Return new object address in *entry
+                    bit1= do not copy data (e.g. because *data is invalid)
+                    bit2= attach data directly by pointer rather than by copying
+                    bit2= attach data directly by pointer rather than by copying
+    @return <=0 error, 1 ok
+*/
+int Xorriso_lst_append_binary(struct Xorriso_lsT **entry,
+                              char *data, int data_len, int flag);
+
+
+/** Destroy a single list item and connect its eventual list neighbors.
+    @param lstring  pointer to the pointer to be freed and set to NULL
+    @param flag     unused yet, submit 0
+    @return 0= *lstring was alredy NULL, 1= ok
+*/
+int Xorriso_lst_destroy(struct Xorriso_lsT **lstring, int flag);
+
+
+struct Xorriso_lsT *Xorriso_lst_get_next(struct Xorriso_lsT *entry, int flag);
+
+struct Xorriso_lsT *Xorriso_lst_get_prev(struct Xorriso_lsT *entry, int flag);
+
+char *Xorriso_lst_get_text(struct Xorriso_lsT *entry, int flag);
+
+int Xorriso_lst_detach_text(struct Xorriso_lsT *entry, int flag);
+
+int Xorriso_lst_get_last(struct Xorriso_lsT *entry, struct Xorriso_lsT **last,
+                         int flag);
+
+int Xorriso_lst_concat(struct Xorriso_lsT *first, struct Xorriso_lsT *second,
+                       int flag);
+
+
+int Exclusions_new(struct ExclusionS **o, int flag);
+
+int Exclusions_destroy(struct ExclusionS **o, int flag);
+
+int Exclusions_get_descrs(struct ExclusionS *o,
+                          struct Xorriso_lsT **not_paths_descr,
+                          struct Xorriso_lsT **not_leafs_descr, int flag);
+
+/* @param flag bit0= whole subtree is banned with -not_paths
+   @return 0=no match , 1=not_paths , 2=not_leafs, <0=error
+*/
+int Exclusions_match(struct ExclusionS *o, char *abs_path, int flag);
+
+int Exclusions_add_not_leafs(struct ExclusionS *o, char *not_leafs_descr,
+                             regex_t *re, int flag);
+
+int Exclusions_add_not_paths(struct ExclusionS *o, int descrc, char **descrs,
+                             int pathc, char **paths, int flag);
+
+
+
+struct LinkiteM;          /* Trace of hops during symbolic link resolution */
+
+int Linkitem_new(struct LinkiteM **o, char *link_path, dev_t target_dev,
+                 ino_t target_ino, struct LinkiteM *next, int flag);
+
+int Linkitem_destroy(struct LinkiteM **o, int flag);
+
+int Linkitem_reset_stack(struct LinkiteM **o, struct LinkiteM *to, int flag);
+
+int Linkitem_find(struct LinkiteM *stack, dev_t target_dev, ino_t target_ino,
+                  struct LinkiteM **result, int flag);
+
+int Linkitem_get_link_count(struct LinkiteM *item, int flag);
+
+
+struct PermiteM;          /* Stack of temporarily altered access permissions */
+
+int Permstack_push(struct PermiteM **o, char *disk_path, struct stat *stbuf,
+                   int flag);
+
+int Permstack_pop(struct PermiteM **o, struct PermiteM *stopper,
+                  struct XorrisO *xorriso, int flag);
+
+
+#endif /* ! Xorriso_pvt_auxobj_includeD */
+
--- a/xorriso/base_obj.c
+++ b/xorriso/base_obj.c
@ -0,0 +1,730 @@
+
+
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2012 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains functions which are needed to read data
+   from ISO image.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <time.h>
+#include <errno.h>
+#include <pthread.h>
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+
+#ifdef Xorriso_standalonE
+
+#ifdef Xorriso_with_libjtE
+#include "../libjte/libjte.h"
+#endif
+
+#else
+
+#ifdef Xorriso_with_libjtE
+#include <libjte/libjte.h>
+#endif
+
+#endif /* ! Xorriso_standalonE */
+
+#include "xorriso.h"
+#include "xorriso_private.h"
+
+#include "base_obj.h"
+#include "lib_mgt.h"
+
+
+
+/* See Xorriso__preset_signal_behavior() */
+static int Xorriso_signal_behavioR= 1;
+
+
+void Xorriso__version(int *major, int *minor, int *micro)
+{
+ *major= Xorriso_header_version_majoR;
+ *minor= Xorriso_header_version_minoR;
+ *micro= Xorriso_header_version_micrO;
+}
+
+
+int Xorriso__is_compatible(int major, int minor, int micro, int flag)
+{
+ int own_major, own_minor, own_micro;
+
+ Xorriso__version(&own_major, &own_minor, &own_micro);
+ return(own_major > major ||
+        (own_major == major && (own_minor > minor ||
+         (own_minor == minor && own_micro >= micro))));
+}
+
+
+char *Xorriso__get_patch_level_text(int flag)
+{
+ return(Xorriso_program_patch_leveL);
+}
+
+
+/** The list of startup file names */
+#define Xorriso_rc_nuM 4
+
+static char Xorriso_sys_rc_nameS[Xorriso_rc_nuM][80]= {
+ "/etc/default/xorriso",
+ "/etc/opt/xorriso/rc",
+ "/etc/xorriso/xorriso.conf",
+ "placeholder for $HOME/.xorrisorc"
+};
+
+
+int Xorriso_new(struct XorrisO ** xorriso,char *progname, int flag)
+{
+ int i, ret;
+ struct XorrisO *m;
+ char *leafname= NULL;
+
+ leafname= TSOB_FELD(char, SfileadrL);
+ if(leafname == NULL)
+   return(-1); 
+ *xorriso= m= TSOB_FELD(struct XorrisO,1);
+ if(m==NULL) {
+   free(leafname);
+   return(-1);
+ }
+ m->libs_are_started= 0;
+ strncpy(m->progname,progname,sizeof(m->progname)-1);
+ m->progname[sizeof(m->progname)-1]= 0;
+ if(getcwd(m->initial_wdx,sizeof(m->initial_wdx)-1)==NULL)
+   m->initial_wdx[0]= 0;
+ m->no_rc= 0;
+ m->argument_emulation= 0;
+
+ m->rc_filename_count= Xorriso_rc_nuM;
+ for(i=0;i<m->rc_filename_count-1;i++)
+   strcpy(m->rc_filenames[i],Xorriso_sys_rc_nameS[i]);
+ m->rc_filenames[m->rc_filename_count-1][0]= 0;
+ m->arrange_args= 0;
+ m->mkisofsrc_done= 0;
+
+ m->wdi[0]= 0;
+ strcpy(m->wdx, m->initial_wdx);
+ m->did_something_useful= 0;
+ m->add_plainly= 0;
+ m->split_size= 0;
+ strcpy(m->list_delimiter, "--");
+ m->ino_behavior= 7;
+ m->iso_level= 3;
+ m->iso_level_is_default= 1;
+ m->do_joliet= 0;
+ m->do_hfsplus= 0;
+ m->do_fat= 0;
+ m->do_rockridge= 1;
+ m->do_iso1999= 0;
+ m->do_aaip= 0;
+ m->do_md5= 0;
+ m->no_emul_toc= 0;
+ m->do_old_empty= 0;
+ m->scdbackup_tag_name[0]= 0;
+ m->scdbackup_tag_time[0]= 0;
+ m->scdbackup_tag_written[0]= 0;
+ m->scdbackup_tag_listname[0]= 0;
+ m->relax_compliance= 0;
+ m->allow_dir_id_ext_dflt= 1;
+ m->rr_reloc_dir[0]= 0;
+ m->rr_reloc_flags= 1;
+ m->untranslated_name_len= 0;
+ m->do_follow_pattern= 1;
+ m->do_follow_param= 0;
+ m->do_follow_links= 0;
+ m->follow_link_limit= 100;
+ m->do_follow_mount= 1;
+ m->do_global_uid= 0;
+ m->global_uid= 0;
+ strcpy(m->volid, "ISOIMAGE");
+ m->volid_default= 1;
+ m->loaded_volid[0]= 0;
+ m->assert_volid[0]= 0;
+ m->assert_volid_sev[0]= 0;
+ m->preparer_id[0]= 0;
+ m->publisher[0]= 0;
+ m->application_id[0]= 0;
+ m->system_id[0]= 0;
+ m->volset_id[0]= 0;
+ m->copyright_file[0]= 0;
+ m->biblio_file[0]= 0;
+ m->abstract_file[0]= 0;
+ m->session_logfile[0]= 0;
+ m->session_lba= -1;
+ m->session_blocks= 0;
+ m->do_global_gid= 0;
+ m->global_gid= 0;
+ m->do_global_mode= 0;
+ m->global_dir_mode= 0555;
+ m->global_file_mode= 0444;
+ m->do_tao= 0;
+ m->filters= NULL;
+ m->filter_list_closed= 0;
+ m->zlib_level_default= m->zlib_level= 6;
+ m->zisofs_block_size= m->zisofs_block_size_default= (1 << 15);
+ m->zisofs_by_magic= 0;
+ m->do_overwrite= 2;
+ m->do_reassure= 0;
+ m->drive_blacklist= NULL;
+ m->drive_greylist= NULL;
+ m->drive_whitelist= NULL;
+ m->toc_emulation_flag= 0;
+ m->image_start_mode= 0;
+ m->image_start_value[0]= 0;
+ m->displacement= 0;
+ m->displacement_sign= 0;
+ m->drives_exclusive= 1;
+ m->early_stdio_test= 0;
+ m->cache_num_tiles= 0;
+ m->cache_tile_blocks= 0;
+ m->cache_default= 1 | 2;
+ m->do_calm_drive= 1;
+ m->indev[0]= 0;
+ m->in_drive_handle= NULL;
+ m->in_volset_handle= NULL;
+ m->in_charset= NULL;
+ m->isofs_st_out= time(0) - 1;
+ m->indev_is_exclusive= 1;
+ m->indev_off_adr[0]= 0;
+ m->isofs_st_in= 0;
+ m->volset_change_pending= 0;
+ m->no_volset_present= 0;
+ m->in_sector_map= NULL;
+ m->check_media_default= NULL;
+ m->check_media_bad_limit= Xorriso_read_quality_invaliD;
+ m->outdev[0]= 0;
+ m->out_drive_handle= NULL;
+ m->out_charset= NULL;
+ m->dev_fd_1= -1;
+ m->outdev_is_exclusive= 1;
+ m->outdev_off_adr[0]= 0;
+ m->grow_blindly_msc2= -1;
+ m->ban_stdio_write= 0;
+ m->do_dummy= 0;
+ m->do_close= 0;
+ m->speed= 0;
+ m->fs= 4*512; /* 4 MiB */
+ m->padding= 300*1024;
+ m->do_padding_by_libisofs= 0;
+ m->alignment= 0;
+ m->do_stream_recording= 0;
+ m->dvd_obs= 0;
+ m->stdio_sync= 0;
+ m->keep_boot_image= 0;
+ m->boot_image_cat_path[0]= 0;
+ m->boot_image_cat_hidden= 0;
+ m->boot_count= 0;
+ m->boot_platform_id= 0x00; /* El Torito Boot Catalog Platform ID: 0 = 80x86 */
+ m->patch_isolinux_image= 0;
+ m->boot_image_bin_path[0]= 0;
+ m->boot_image_bin_form[0]= 0;
+ m->boot_image_emul= 0;
+ m->boot_emul_default= 1;
+ m->boot_image_load_size= 4 * 512;     /* hearsay out of libisofs/demo/iso.c */
+ memset(m->boot_id_string, 0, sizeof(m->boot_id_string));
+ memset(m->boot_selection_crit, 0, sizeof(m->boot_selection_crit));
+
+#ifdef Xorriso_with_isohybriD
+ m->boot_image_isohybrid= 1;
+#else
+ m->boot_image_isohybrid= 0;
+#endif
+
+ m->boot_efi_default= 0;
+ m->system_area_disk_path[0]= 0;
+ m->system_area_options= 0;
+ m->patch_system_area= 0;
+ m->partition_offset= 0;
+ m->partition_secs_per_head= 0;
+ m->partition_heads_per_cyl= 0;
+ m->prep_partition[0]= 0;
+ m->efi_boot_partition[0]= 0;
+ for(i= 0; i < Xorriso_max_appended_partitionS; i++) {
+   m->appended_partitions[i]= NULL;
+   m->appended_part_types[i]= 0;
+ }
+ m->ascii_disc_label[0]= 0;
+ memset(m->hfsp_serial_number, 0, 8);
+ m->hfsp_block_size= 0;
+ m->apm_block_size= 0;
+ m->vol_creation_time= 0;
+ m->vol_modification_time= 0;
+ m->vol_expiration_time= 0;
+ m->vol_effective_time= 0;
+ m->vol_uuid[0]= 0;
+
+#ifdef Xorriso_with_libjtE
+ m->libjte_handle= NULL;
+#endif
+
+ m->jigdo_params= NULL;
+ m->jigdo_values= NULL;
+ m->libjte_params_given= 0;
+ m->loaded_boot_bin_lba= 0;
+ m->loaded_boot_cat_path[0]= 0;
+ m->allow_graft_points= 0;
+ m->allow_restore= 0;
+ m->do_concat_split= 1;
+ m->do_auto_chmod= 0;
+ m->do_restore_sort_lba= 0;
+ m->do_strict_acl= 0;
+ m->dialog= 0;
+ m->bsl_interpretation= 0;
+ m->search_mode= 0;
+ m->structured_search= 1;
+ m->do_iso_rr_pattern= 1;
+ m->do_disk_pattern= 2;
+ m->temp_mem_limit= 16*1024*1024;
+ m->file_size_limit= Xorriso_default_file_size_limiT;
+ m->disk_exclusions= NULL;
+ m->iso_rr_hidings= NULL;
+ m->joliet_hidings= NULL;
+ m->hfsplus_hidings= NULL;
+ m->disk_excl_mode= 1;
+ m->use_stdin= 0;
+ m->result_page_length= 0;
+ m->result_page_width= 80;
+ m->mark_text[0]= 0;
+ m->packet_output= 0;
+ for(i=0; i<4; i++) {
+   m->logfile[i][0]= 0;
+   m->logfile_fp[i]= NULL;
+ }
+ m->pktlog_fp= NULL;
+ m->stderr_fp= NULL;
+ for(i= 0; i < Xorriso_max_outlist_stacK; i++) {
+   m->result_msglists[i]= NULL;
+   m->info_msglists[i]= NULL;
+   m->msglist_flags[i]= 0;
+ }
+ m->lib_msg_queue_lock_ini= 0;
+ m->result_msglists_lock_ini= 0;
+ m->write_to_channel_lock_ini= 0;
+ m->msg_watcher_lock_ini= 0;
+ m->msg_watcher_state= 0;
+ m->msgw_result_handler= NULL;
+ m->msgw_result_handle= NULL;
+ m->msgw_info_handler= NULL;
+ m->msgw_info_handle= NULL;
+ m->msgw_stack_handle= -1;
+ m->msgw_msg_pending= 0;
+ m->msgw_fetch_lock_ini= 0;
+ m->msg_sieve= NULL;
+ m->msg_sieve_disabled= 0;
+ m->msglist_stackfill= 0;
+ m->status_history_max= Xorriso_status_history_maX;
+ m->scsi_log= 0;
+ strcpy(m->report_about_text, "UPDATE");
+ Xorriso__text_to_sev(m->report_about_text, &m->report_about_severity, 0);
+ m->library_msg_direct_print= 0;
+ strcpy(m->abort_on_text,"FAILURE");
+ Xorriso__text_to_sev(m->abort_on_text, &m->abort_on_severity, 0);
+ m->abort_on_is_default= 1;
+ m->problem_status= 0;
+ m->problem_status_lock_ini= 0;
+ m->problem_status_text[0]= 0;
+ m->errfile_log[0]= 0;
+ m->errfile_mode= 0;
+ m->errfile_fp= NULL;
+ 
+ m->img_read_error_mode= 1;       /* abort faulty image reading with FAILURE */
+ m->extract_error_mode= 1;          /* keep extracted files after read error */
+ strcpy(m->return_with_text, "SORRY");
+ Xorriso__text_to_sev(m->return_with_text, &m->return_with_severity, 0);
+ m->return_with_value= 32;
+ m->eternal_problem_status= 0;
+ m->eternal_problem_status_text[0]= 0;
+ m->re= NULL;
+ /* >>> ??? how to initialize m->match[0] ? */
+ m->re_constants= NULL;
+ m->re_count= 0;
+ m->re_fill= 0;
+ m->reg_expr[0]= 0;
+ m->run_state= 0;
+ m->is_dialog= 0;
+ m->bar_is_fresh= 0;
+ m->pending_option[0]= 0;
+ m->request_to_abort= 0;
+ m->request_not_to_ask= 0;
+ m->idle_time= 0.0;
+ m->re_failed_at= -1;
+ m->prepended_wd= 0;
+ m->insert_count= 0;
+ m->insert_bytes= 0;
+ m->error_count= 0;
+ m->launch_frontend_banned= 0;
+ m->pacifier_style= 0;
+ m->pacifier_interval= 1.0;
+ m->pacifier_count= 0;
+ m->pacifier_prev_count= 0;
+ m->pacifier_total= 0;
+ m->pacifier_byte_count= 0;
+ m->pacifier_fifo= NULL;
+ m->start_time= 0.0;
+ m->last_update_time= 0.0;
+ m->find_compare_result= 1;
+ m->find_check_md5_result= 0;
+ m->last_abort_file_time= 0.0;
+
+ m->node_counter= 0;
+ m->node_array_size= 0;
+ m->node_array= NULL;
+ m->node_disk_prefixes= NULL;
+ m->node_img_prefixes= NULL;
+
+ m->hln_count= 0;
+ m->hln_array= NULL; 
+ m->hln_targets= NULL;
+ m->hln_change_pending= 0;
+ m->di_do_widen= NULL;
+ m->di_disk_paths= NULL;
+ m->di_iso_paths= NULL;
+
+ m->node_targets_availmem= 0;
+
+ m->di_count= 0;
+ m->di_array= NULL;
+
+ m->perm_stack= NULL;
+
+ m->update_flags= 0;
+
+ m->result_line[0]= 0;
+ m->result_line_counter= 0;
+ m->result_page_counter= 0;
+ m->result_open_line_len= 0;
+
+ m->info_text[0]= 0;
+
+ ret= Sfile_leafname(progname, leafname, 0);
+ if(ret<=0)
+   goto failure;
+ if(strcmp(leafname, "osirrox")==0) {
+   m->allow_restore= 1;
+   m->drives_exclusive= 0;
+ } else if(strcmp(leafname, "xorrisofs")==0 || strcmp(leafname, "genisofs")==0 ||
+        strcmp(leafname, "mkisofs")==0 || strcmp(leafname, "genisoimage")==0) {
+   m->argument_emulation= 1;
+   m->pacifier_style= 1;
+   Xorriso_protect_stdout(*xorriso, 0);
+ } else if(strcmp(leafname, "xorrecord")==0 || strcmp(leafname, "wodim")==0 ||
+           strcmp(leafname, "cdrecord")==0 || strcmp(leafname, "cdrskin")==0) {
+   m->argument_emulation= 2;
+   m->pacifier_style= 2;
+ }
+ ret= Exclusions_new(&(m->disk_exclusions), 0);
+ if(ret<=0)
+   goto failure;
+ ret= Exclusions_new(&(m->iso_rr_hidings), 0);
+ if(ret<=0)
+   goto failure;
+ ret= Exclusions_new(&(m->joliet_hidings), 0);
+ if(ret<=0)
+   goto failure;
+ ret= Exclusions_new(&(m->hfsplus_hidings), 0);
+ if(ret<=0)
+   goto failure;
+ Xorriso_relax_compliance(m, "default", 0);
+ ret= Xorriso_lst_new(&(m->drive_greylist), "/dev", m->drive_greylist, 1);
+ if(ret <= 0)
+   goto failure;
+ Xorriso_preparer_string(m, m->preparer_id, 1); /* avoids library calls */
+ ret= pthread_mutex_init(&(m->lib_msg_queue_lock), NULL);
+ if(ret != 0)
+   goto failure;
+ m->lib_msg_queue_lock_ini= 1;
+ ret= pthread_mutex_init(&(m->result_msglists_lock), NULL);
+ if(ret != 0)
+   goto failure;
+ m->result_msglists_lock_ini= 1;
+ ret= pthread_mutex_init(&(m->write_to_channel_lock), NULL);
+ if(ret != 0)
+   goto failure;
+ m->result_msglists_lock_ini= 1;
+ ret= pthread_mutex_init(&(m->problem_status_lock), NULL);
+ if(ret != 0)
+   goto failure;
+ m->problem_status_lock_ini= 1;
+ ret= pthread_mutex_init(&(m->msg_watcher_lock), NULL);
+ if(ret != 0)
+   goto failure;
+ m->msg_watcher_lock_ini= 1;
+ ret= pthread_mutex_init(&(m->msgw_fetch_lock), NULL);
+ if(ret != 0)
+   goto failure;
+ m->msgw_fetch_lock_ini= 1;
+
+ if(leafname != NULL)
+   free(leafname);
+ return(1);
+failure:;
+ Xorriso_destroy(xorriso, 0);
+ if(leafname != NULL)
+   free(leafname);
+ return(-1);
+}
+
+
+int Xorriso_destroy_re(struct XorrisO *m, int flag)
+{
+ int i;
+
+ if(m->re!=NULL) {
+   for(i=0;i<m->re_fill;i++) {
+     if(m->re_constants!=NULL)
+       if(m->re_constants[i]!=NULL)
+   continue; /* ,->re[i] was never subject to regcomp() */
+     regfree(&(m->re[i]));
+   }
+   free((char *) m->re);
+   m->re= NULL;
+ }
+
+ if(m->re_constants!=NULL) {
+   for(i=0;i<m->re_fill;i++)
+     if(m->re_constants[i]!=NULL)
+       free(m->re_constants[i]);
+   free((char *) m->re_constants);
+   m->re_constants= NULL;
+ }
+ m->re_count= 0;
+ m->re_fill= 0;
+ return(1);
+}
+
+
+/* @param flag bit0= global shutdown of libraries */
+int Xorriso_destroy(struct XorrisO **xorriso, int flag)
+{
+ struct XorrisO *m;
+ int i;
+
+ m= *xorriso;
+ if(m==NULL)
+   return(0);
+
+ /* Give up drives and image to unref all connected xorriso objects */
+ Xorriso_give_up_drive(m, 3);
+
+ if(m->in_charset!=NULL)
+   free(m->in_charset);
+ if(m->out_charset!=NULL)
+   free(m->out_charset);
+ Xorriso_destroy_re(m,0);
+ Exclusions_destroy(&(m->disk_exclusions), 0);
+ Exclusions_destroy(&(m->iso_rr_hidings), 0);
+ Exclusions_destroy(&(m->joliet_hidings), 0);
+ Exclusions_destroy(&(m->hfsplus_hidings), 0);
+ Xorriso_destroy_all_extf(m, 0);
+ Xorriso_lst_destroy_all(&(m->drive_blacklist), 0);
+ Xorriso_lst_destroy_all(&(m->drive_greylist), 0);
+ Xorriso_lst_destroy_all(&(m->drive_whitelist), 0);
+ Xorriso_destroy_node_array(m, 0);
+ Xorriso_destroy_hln_array(m, 0);
+ Xorriso_destroy_di_array(m, 0);
+
+#ifdef Xorriso_with_libjtE
+ if(m->libjte_handle)
+   libjte_destroy(&(m->libjte_handle));
+#endif
+
+ Xorriso_lst_destroy_all(&(m->jigdo_params), 0);
+ Xorriso_lst_destroy_all(&(m->jigdo_values), 0);
+ for(i= 0; i < Xorriso_max_appended_partitionS; i++)
+   if(m->appended_partitions[i] != NULL)
+     free(m->appended_partitions[i]);
+
+ Xorriso_detach_libraries(m, flag&1);
+
+ if(m->lib_msg_queue_lock_ini)
+   pthread_mutex_destroy(&(m->lib_msg_queue_lock));
+ if(m->result_msglists_lock_ini)
+   pthread_mutex_destroy(&(m->result_msglists_lock));
+ if(m->write_to_channel_lock_ini)
+   pthread_mutex_destroy(&(m->write_to_channel_lock));
+ if(m->problem_status_lock_ini)
+   pthread_mutex_destroy(&(m->problem_status_lock));
+ if(m->msg_watcher_lock_ini)
+   pthread_mutex_destroy(&(m->msg_watcher_lock));
+ if(m->msgw_fetch_lock_ini)
+   pthread_mutex_destroy(&(m->msgw_fetch_lock));
+ Xorriso_sieve_dispose(m, 0);
+ 
+ free((char *) m);
+ *xorriso= NULL;
+ return(1);
+}
+
+
+int Xorriso_destroy_node_array(struct XorrisO *xorriso, int flag)
+{
+ int i;
+
+ if(xorriso->node_array != NULL) {
+   for(i= 0; i < xorriso->node_counter; i++)
+     iso_node_unref((IsoNode *) xorriso->node_array[i]);
+   free(xorriso->node_array);
+ }
+ xorriso->node_array= NULL;
+ xorriso->node_counter= xorriso->node_array_size= 0;
+ Xorriso_lst_destroy_all(&(xorriso->node_disk_prefixes), 0);
+ Xorriso_lst_destroy_all(&(xorriso->node_img_prefixes), 0);
+ return(1);
+}
+
+
+/* @param flag bit0= do not destroy hln_array but only hln_targets
+*/
+int Xorriso_destroy_hln_array(struct XorrisO *xorriso, int flag)
+{
+ int i;
+
+ 
+ if(xorriso->hln_array != NULL && !(flag & 1)) {
+   for(i= 0; i < xorriso->hln_count; i++)
+     iso_node_unref((IsoNode *) xorriso->hln_array[i]);
+   free(xorriso->hln_array);
+   xorriso->hln_array= NULL;
+   xorriso->hln_count= 0;
+ }
+ if(xorriso->hln_targets != NULL) {
+   for(i= 0; i < xorriso->hln_count; i++)
+     if(xorriso->hln_targets[i] != NULL)
+       free(xorriso->hln_targets[i]);
+   free(xorriso->hln_targets);
+   xorriso->hln_targets= NULL;
+ }
+ xorriso->node_targets_availmem= 0;
+ return(1);
+}
+
+
+int Xorriso_destroy_di_array(struct XorrisO *xorriso, int flag)
+{
+ int i;
+
+ if(xorriso->di_array != NULL) {
+   for(i= 0; i < xorriso->di_count; i++)
+     if(xorriso->di_array[i] != NULL)
+       iso_node_unref((IsoNode *) xorriso->di_array[i]);
+   free(xorriso->di_array);
+   xorriso->di_array= NULL;
+ }
+ if(xorriso->di_do_widen != NULL) {
+   free(xorriso->di_do_widen);
+   xorriso->di_do_widen= NULL;
+ }
+ Xorriso_lst_destroy_all(&(xorriso->di_disk_paths), 0);
+ Xorriso_lst_destroy_all(&(xorriso->di_iso_paths), 0);
+ xorriso->di_count= 0;
+
+#ifdef NIX
+ /* <<< */
+ fprintf(stderr, "xorriso_DEBUG: get_di_count= %lu\n",
+         Xorriso_get_di_counteR);
+#endif /* NIX */
+
+ return(1);
+}
+
+
+int Xorriso_new_node_array(struct XorrisO *xorriso, off_t mem_limit,
+                           int addon_nodes, int flag)
+{
+ int i;
+
+ if(xorriso->node_counter <= 0)
+   return(1);
+
+ xorriso->node_array= calloc(xorriso->node_counter + addon_nodes,
+                             sizeof(IsoNode *));
+ if(xorriso->node_array == NULL) {
+   Xorriso_no_malloc_memory(xorriso, NULL, 0);
+   return(-1);
+ }
+ for(i= 0; i < xorriso->node_counter + addon_nodes; i++)
+   xorriso->node_array[i]= NULL;
+ xorriso->node_array_size= xorriso->node_counter + addon_nodes;
+ xorriso->node_counter= 0;
+ return(1);
+}
+
+
+/* @param flag bit0= do not allocate hln_array but only hln_targets
+*/
+int Xorriso_new_hln_array(struct XorrisO *xorriso, off_t mem_limit, int flag)
+{
+ int i;
+
+ Xorriso_destroy_hln_array(xorriso, flag & 1);
+ if(xorriso->hln_count <= 0)
+   return(1);
+
+ if(!(flag & 1)) {
+   xorriso->hln_array= calloc(xorriso->hln_count, sizeof(char *));
+   if(xorriso->hln_array == NULL) {
+     Xorriso_no_malloc_memory(xorriso, NULL, 0);
+     return(-1);
+   }
+   for(i= 0; i < xorriso->hln_count; i++)
+     xorriso->hln_array[i]= NULL;
+ }
+
+ xorriso->hln_targets= calloc(xorriso->hln_count, sizeof(char *));
+ if(xorriso->hln_targets == NULL) {
+   if(!(flag & 1)) {
+     free(xorriso->hln_array);
+     xorriso->hln_array= NULL;
+   }
+   Xorriso_no_malloc_memory(xorriso, NULL, 0);
+   return(-1);
+ }
+ for(i= 0; i < xorriso->hln_count; i++)
+   xorriso->hln_targets[i]= NULL;
+ xorriso->node_targets_availmem= mem_limit
+                                 - xorriso->hln_count * sizeof(void *)
+                                 - xorriso->hln_count * sizeof(char *);
+ if(xorriso->node_targets_availmem < 0)
+   xorriso->node_targets_availmem= 0;
+ return(1);
+}
+
+
+int Xorriso__preset_signal_behavior(int behavior, int flag)
+{
+ if(behavior < 0 || behavior > 3)
+   return(0);
+ Xorriso_signal_behavioR= behavior;
+ return(1);
+}
+
+
+int Xorriso__get_signal_behavior(int flag)
+{
+ return(Xorriso_signal_behavioR);
+}
+
--- a/xorriso/base_obj.h
+++ b/xorriso/base_obj.h
@ -0,0 +1,31 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which perform the
+   fundamental operations of the XorrisO object.
+*/
+
+
+#ifndef Xorriso_pvt_base_obj_includeD
+#define Xorriso_pvt_base_obj_includeD yes
+
+
+#ifdef NIX
+/* <<< */
+unsigned long Xorriso_get_di_counteR= 0;
+#endif /* NIX */
+
+struct XorrisO;
+
+
+int Xorriso_destroy_re(struct XorrisO *m, int flag);
+
+int Xorriso__get_signal_behavior(int flag);
+
+
+#endif /* ! Xorriso_pvt_base_obj_includeD */
+
--- a/xorriso/changelog.txt
+++ b/xorriso/changelog.txt
--- a/xorriso/check_media.c
+++ b/xorriso/check_media.c
--- a/xorriso/check_media.h
+++ b/xorriso/check_media.h
@ -0,0 +1,184 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2011 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of classes SpotlistiteM, SpotlisT,
+   SectorbitmaP, CheckmediajoB which represent media checks and their outcome.
+*/
+
+
+#ifndef Xorriso_pvt_check_includeD
+#define Xorriso_pvt_check_includeD yes
+
+struct SpotlisT;          /* List of intervals with different read qualities */
+struct CheckmediajoB;     /* Parameters for Xorriso_check_media() */
+
+int Xorriso_check_media_setup_job(struct XorrisO *xorriso,
+                              struct CheckmediajoB *job,
+                              char **argv, int old_idx, int end_idx, int flag);
+
+int Xorriso_sectormap_to_spotlist(struct XorrisO *xorriso,
+                                  struct CheckmediajoB *job,
+                                  struct SpotlisT **spotlist,
+                                  int flag);
+
+/* @param flag bit0= mark untested areas as valid
+*/
+int Xorriso_spotlist_to_sectormap(struct XorrisO *xorriso,
+                                  struct SpotlisT *spotlist,
+                                  int read_chunk,
+                                  struct SectorbitmaP **map,
+                                  int flag);
+
+/* Opens the -check_media data copy in for reading and writing
+*/
+int Xorriso_open_job_data_to(struct XorrisO *xorriso,
+                             struct CheckmediajoB *job, int flag);
+
+/* @param report Buffer of at least 10*SfileadrL
+   @param flag bit0= only report non-default settings
+   @return <=0 error , 1 ok , 2 with bit0: every option is on default setting
+*/
+int Xorriso_check_media_list_job(struct XorrisO *xorriso,
+                                 struct CheckmediajoB *job,
+                                 char *report, int flag);
+
+int Xorriso_update_in_sector_map(struct XorrisO *xorriso,
+                                 struct SpotlisT *spotlist, int read_chunk,
+                                 struct CheckmediajoB *job, int flag);
+
+
+/* Distiniction between valid and invalid sectors */
+struct SectorbitmaP {
+ int sectors;
+ int sector_size;
+ unsigned char *map;
+ int map_size;
+};
+
+int Spotlist_new(struct SpotlisT **o, int flag);
+
+int Spotlist_destroy(struct SpotlisT **o, int flag);
+
+int Spotlist_add_item(struct SpotlisT *o, int start_lba, int blocks,
+                      int quality, int flag);
+
+int Spotlist_count(struct SpotlisT *o, int flag);
+
+int Spotlist_block_count(struct SpotlisT *o, int flag);
+
+int Spotlist_sector_size(struct SpotlisT *o, int read_chunk, int flag);
+
+int Spotlist_get_item(struct SpotlisT *o, int idx,
+                      int *start_lba, int *blocks, int *quality, int flag);
+
+char *Spotlist__quality_name(int quality, char name[80], int bad_limit,
+                             int flag);
+
+
+#define Xorriso_read_quality_gooD         0x7fffffff
+#define Xorriso_read_quality_md5_matcH    0x70000000
+#define Xorriso_read_quality_sloW         0x60000000
+#define Xorriso_read_quality_partiaL      0x50000000
+#define Xorriso_read_quality_valiD        0x40000000
+#define Xorriso_read_quality_untesteD     0x3fffffff
+#define Xorriso_read_quality_invaliD      0x3ffffffe
+#define Xorriso_read_quality_tao_enD      0x28000000
+#define Xorriso_read_quality_off_tracK    0x20000000
+#define Xorriso_read_quality_md5_mismatcH 0x10000000
+#define Xorriso_read_quality_unreadablE   0x00000000
+
+
+struct CheckmediajoB {
+ int use_dev;        /* 0= use indev , 1= use outdev , 2= use sector map*/
+ 
+ int min_lba;        /* if >=0 : begin checking at this address */ 
+ int max_lba;        /* if >=0 : read up to this address, else use mode */
+ 
+ int min_block_size; /* granularity desired by user
+                     */
+ int async_chunks;   /* >= 2 : run MD5 thread, use given number of chunks
+                        else : synchronous
+                     */
+ int mode;           /* 0= track by track
+                        1= single sweep over libisoburn medium capacity
+                        2= single sweep over libburn medium capacity
+                     */
+ time_t start_time;  
+ int time_limit;     /* Number of seconds after which to abort */
+ 
+ int item_limit;     /* Maximum number of medium check list items as result */
+ 
+ char abort_file_path[SfileadrL];
+
+ char data_to_path[SfileadrL];
+ int data_to_fd;
+ off_t data_to_offset; /* usually 0 with image copy, negative with file copy */
+ off_t data_to_limit;  /* used with file copy */
+ int patch_lba0;
+ int patch_lba0_msc1;
+
+ char sector_map_path[SfileadrL];
+ struct SectorbitmaP *sector_map;
+ int map_with_volid;  /* 0=add quick toc to map file,
+                         1=read ISO heads for toc
+                      */
+
+ int retry;          /* -1= only try full read_chunk, 1=retry with 2k blocks
+                         0= retry with CD, full chunk else
+                      */
+
+ int report_mode;    /* 0= print MCL items
+                        1= print damaged files
+                     */
+
+ char event_severity[20]; /* If not "ALL": trigger event of given severity
+                             at the end of a check job if bad blocks were
+                             discovered.
+                           */
+
+ double slow_threshold_seq; /* Time limit in seconds for the decision whether
+                               a read operation is considered slow. This does
+                               not apply to thr first read of an interval.
+                             */
+
+ int untested_valid; /* 1= mark untested data blocks as valid when calling
+                           Xorriso_spotlist_to_sectormap()
+                      */
+};
+
+int Checkmediajob_new(struct CheckmediajoB **o, int flag);
+
+int Checkmediajob_destroy(struct CheckmediajoB **o, int flag);
+
+int Checkmediajob_copy(struct CheckmediajoB *from, struct CheckmediajoB *to,
+                       int flag);
+
+int Sectorbitmap_new(struct SectorbitmaP **o, int sectors, int sector_size,
+                     int flag);
+int Sectorbitmap_destroy(struct SectorbitmaP **o, int flag);
+int Sectorbitmap_from_file(struct SectorbitmaP **o, char *path, char *msg,
+                           int *os_errno, int flag);
+int Sectorbitmap_to_file(struct SectorbitmaP *o, char *path, char *info,
+                         char *msg, int *os_errno, int flag);
+int Sectorbitmap_set(struct SectorbitmaP *o, int sector, int flag);
+int Sectorbitmap_set_range(struct SectorbitmaP *o,
+                           int start_sector, int sectors, int flag);
+int Sectorbitmap_is_set(struct SectorbitmaP *o, int sector, int flag);
+int Sectorbitmap_bytes_are_set(struct SectorbitmaP *o,
+                               off_t start_byte, off_t end_byte, int flag);
+
+int Sectorbitmap_get_layout(struct SectorbitmaP *o,
+                           int *sectors, int *sector_size, int flag);
+
+int Sectorbitmap_copy(struct SectorbitmaP *from, struct SectorbitmaP *to,
+                      int flag);
+
+int Sectorbitmap_clone(struct SectorbitmaP *from, struct SectorbitmaP **clone,
+                      int flag);
+
+#endif /* ! Xorriso_pvt_check_includeD */
+
--- a/xorriso/cmp_update.c
+++ b/xorriso/cmp_update.c
--- a/xorriso/cmp_update.h
+++ b/xorriso/cmp_update.h
@ -0,0 +1,45 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of class DirseQ which
+   crawls along a directory's content list.
+*/
+
+
+#ifndef Xorriso_pvt_cmp_includeD
+#define Xorriso_pvt_cmp_includeD yes
+
+int Xorriso_compare_2_files(struct XorrisO *xorriso, char *disk_adr,
+                            char *iso_adr, char *adr_common_tail,
+                            int *result, int flag);
+
+int Xorriso_pfx_disk_path(struct XorrisO *xorriso, char *iso_path,
+                          char *iso_prefix, char *disk_prefix,
+                          char disk_path[SfileadrL], int flag);
+
+/* @param boss_iter Opaque handle to be forwarded to actions in ISO image
+                    Set to NULL if calling this function from outside ISO world
+   @param node      Opaque handle to be forwarded to actions in ISO image
+                    Set to NULL if calling this function from outside ISO world
+   @param flag bit0= update rather than compare
+*/
+int Xorriso_find_compare(struct XorrisO *xorriso, void *boss_iter, void *node,
+                         char *iso_path, char *iso_prefix, char *disk_prefix,
+                         int flag);
+
+/* @param boss_iter Opaque handle to be forwarded to actions in ISO image
+                    Set to NULL if calling this function from outside ISO world
+   @param @node     Opaque handle to be forwarded to actions in ISO image
+                    Set to NULL if calling this function from outside ISO world
+*/
+int Xorriso_update_interpreter(struct XorrisO *xorriso,
+                               void *boss_iter, void *node,
+                               int compare_result, char *disk_path,
+                               char *iso_rr_path, int flag);
+
+#endif /* ! Xorriso_pvt_cmp_includeD */
+
--- a/xorriso/compile_xorriso.sh
+++ b/xorriso/compile_xorriso.sh
@ -18,15 +18,19 @@ isoburn=./libisoburn-develop/libisoburn
 xorr=./libisoburn-develop/xorriso

 debug_opts="-O2"
-def_opts="-DXorriso_allow_external_filterS"
+def_opts="-DXorriso_allow_external_filterS -DXorriso_allow_launch_frontenD"
 largefile_opts="-D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1"
 do_strip=0
 static_opts=
-warn_opts="-Wall"
+warn_opts="-Wall -Wextra -Wno-unused-parameter"
+# warn_opts="-Wall -Wsign-compare"
 nglibisofs=1
+def_have="-DHAVE_STDINT_H"
 def_libreadline="-DXorriso_with_readlinE"
+def_libjte="-DXorriso_with_libjtE  -DLibisofs_with_libjtE"
 link_libreadline="-lreadline"
 link_libcdio=
+link_libjte="-ljte"

 for i in "$@"
 do
@ -50,6 +54,10 @@ do
  elif test "$i" = "-use_libcdio"
  then
    link_libcdio="-lcdio"
+  elif test "$i" = "-no_libjte"
+  then
+    def_libjte=""
+    link_libjte=""
  elif test "$i" = "-help" -o "$i" = "--help" -o "$i" = "-h"
  then
    echo \
@ -58,6 +66,7 @@ do
    echo "  -dvd_obs_64k      64 KB default size for DVD/BD writing."
    echo "  -no_libreadline   do not compile for and link with libreadline."
    echo "  -use_libcdio      link with -lcdio because libburn uses it."
+    echo "  -no_libjte        do not compile for and link with libjte."
    echo "  -do_diet          produce capability reduced lean version."
    echo "  -do_strip         apply program strip to compiled programs."
    echo "  -g                produce debuggable programm."
@ -83,6 +92,10 @@ libisofs="$libisofs $isofs"fsource.o
 libisofs="$libisofs $isofs"image.o
 libisofs="$libisofs $isofs"iso1999.o
 libisofs="$libisofs $isofs"joliet.o
+libisofs="$libisofs $isofs"hfsplus.o
+libisofs="$libisofs $isofs"hfsplus_decompose.o
+libisofs="$libisofs $isofs"hfsplus_classes.o
+libisofs="$libisofs $isofs"hfsplus_case.o
 libisofs="$libisofs $isofs"libiso_msgs.o
 libisofs="$libisofs $isofs"messages.o
 libisofs="$libisofs $isofs"node.o
@ -108,7 +121,7 @@ date -u '+#define Xorriso_build_timestamP "%Y.%m.%d.%H%M%S"' >"$xorr"/xorriso_bu
 echo "Build timestamp   :  $(sed -e 's/#define Xorriso_build_timestamP "//' -e 's/"$//' "$xorr"/xorriso_buildstamp.h)"

 echo "compiling program $xorr/xorriso.c $static_opts $debug_opts $def_opts $link_libcdio"
-cc -I. -DXorriso_with_maiN $def_libreadline \
+cc -I. -DXorriso_with_maiN $def_have $def_libreadline $def_libjte \
  $warn_opts \
  $static_opts \
  $debug_opts \
@ -117,9 +130,38 @@ cc -I. -DXorriso_with_maiN $def_libreadline \
  \
  -o "$xorr"/xorriso \
  \
-  "$xorr"/xorriso.c \
+  "$xorr"/xorriso_main.c \
+  "$xorr"/sfile.c \
+  "$xorr"/aux_objects.c \
+  "$xorr"/findjob.c \
+  "$xorr"/check_media.c \
+  "$xorr"/misc_funct.c \
+  "$xorr"/text_io.c \
+  "$xorr"/match.c \
+  "$xorr"/emulators.c \
+  "$xorr"/disk_ops.c \
+  "$xorr"/cmp_update.c \
+  "$xorr"/parse_exec.c \
+  "$xorr"/opts_a_c.c \
+  "$xorr"/opts_d_h.c \
+  "$xorr"/opts_i_o.c \
+  "$xorr"/opts_p_z.c \
  \
-  "$xorr"/xorrisoburn.c \
+  "$xorr"/base_obj.c \
+  "$xorr"/lib_mgt.c \
+  "$xorr"/sort_cmp.c \
+  "$xorr"/drive_mgt.c \
+  "$xorr"/iso_img.c \
+  "$xorr"/iso_tree.c \
+  "$xorr"/iso_manip.c \
+  "$xorr"/write_run.c \
+  "$xorr"/read_run.c \
+  "$xorr"/filters.c \
+  \
+  "$isoburn"/isoburn.c \
+  "$isoburn"/burn_wrap.c \
+  "$isoburn"/data_source.c \
+  "$isoburn"/isofs_wrap.c \
  \
  "$burn"/async.o \
  "$burn"/debug.o \
@ -136,6 +178,7 @@ cc -I. -DXorriso_with_maiN $def_libreadline \
  "$burn"/libdax_audioxtr.o \
  "$burn"/libdax_msgs.o \
  "$burn"/cleanup.o \
+  "$burn"/cdtext.o \
  \
  "$burn"/mmc.o \
  "$burn"/sbc.o \
@ -148,15 +191,11 @@ cc -I. -DXorriso_with_maiN $def_libreadline \
  "$burn"/crc.o \
  "$burn"/ecma130ab.o \
  \
-  "$isoburn"/isoburn.o \
-  "$isoburn"/burn_wrap.o \
-  "$isoburn"/data_source.o \
-  "$isoburn"/isofs_wrap.o \
-  \
  $libisofs \
  \
  $link_libreadline \
  $link_libcdio \
+  $link_libjte \
  \
  -lpthread \
  -lacl \
--- a/xorriso/configure_ac.txt
+++ b/xorriso/configure_ac.txt
@ -1,11 +1,10 @@

 # configure.ac stems from xorriso/configure_ac.txt and leads to ./configure
-# Copyright (c) 2007 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+# Copyright (c) 2007 - 2013 Thomas Schmitt <scdbackup@gmx.net>
 # Provided under GPL version 2 or later.

-AC_INIT([xorriso], [0.5.2], [http://libburnia-project.org])
+AC_INIT([xorriso], [1.2.8], [http://libburnia-project.org])
 AC_PREREQ([2.50])
-dnl AC_CONFIG_HEADER([config.h])	

 AC_CANONICAL_HOST
 AC_CANONICAL_TARGET
@ -13,17 +12,25 @@ AC_CANONICAL_TARGET
 LIBBURNIA_SET_FLAGS

 AM_INIT_AUTOMAKE([subdir-objects])
+AC_CONFIG_MACRO_DIR([./])

-BURN_MAJOR_VERSION=0
-BURN_MINOR_VERSION=7
-BURN_MICRO_VERSION=9
+dnl Let autoheader produce config.h.in and let configure produce config.h
+dnl This saves about 500 characters of compile message per source file.
+AC_CONFIG_HEADER(config.h)
+
+AH_TEMPLATE([Xorriso_standalonE], [Define to prepare sources for statically linked xorriso])
+AC_DEFINE([Xorriso_standalonE], [])
+
+BURN_MAJOR_VERSION=1
+BURN_MINOR_VERSION=2
+BURN_MICRO_VERSION=8
 AC_SUBST(BURN_MAJOR_VERSION)
 AC_SUBST(BURN_MINOR_VERSION)
 AC_SUBST(BURN_MICRO_VERSION)

-LIBISOFS_MAJOR_VERSION=0
-LIBISOFS_MINOR_VERSION=6
-LIBISOFS_MICRO_VERSION=29
+LIBISOFS_MAJOR_VERSION=1
+LIBISOFS_MINOR_VERSION=2
+LIBISOFS_MICRO_VERSION=8
 AC_SUBST(LIBISOFS_MAJOR_VERSION)
 AC_SUBST(LIBISOFS_MINOR_VERSION)
 AC_SUBST(LIBISOFS_MICRO_VERSION)
@ -50,12 +57,26 @@ if test ! $ac_cv_func_fseeko; then
   AC_ERROR([Libburn requires largefile support.])
 fi

+AH_TEMPLATE([ICONV_CONST], [Whether to apply const qualifier to iconv inbuf])
+if test x$XORRISO_OLD_ICONV_CONFIGURE = x
+then
+
+dnl ts B00410 : To detect the need for -liconv and const argument of iconv()
+LIBBURNIA_CHECK_ICONV
+dnl ts B00411 : To abort configuration if iconv() still cannot be compiled
+LIBBURNIA_ASSERT_ICONV
+
+else
+
+dnl Outdated: produces double -liconv and warnings about parameter mismatch
 dnl If iconv(3) is in an extra libiconv, then it gets added to variable LIBS.
 dnl If not, then no -liconv will be added.
 AC_CHECK_LIB(iconv, iconv, , )
 dnl GNU iconv has no function iconv() but libiconv() and a macro iconv()
 AC_CHECK_LIB(iconv, libiconv, , )
- 
+
+fi
+
 AC_PROG_LIBTOOL
 AC_SUBST(LIBTOOL_DEPS)
 LIBTOOL="$LIBTOOL --silent"
@ -90,14 +111,16 @@ AC_SUBST(ARCH)
 AC_SUBST(LIBBURNIA_PKGCONFDIR)
 AC_SUBST(LIBBURN_ARCH_LIBS)

-
-dnl ts A90303
 dnl Check the preconditions for using statvfs() in sg-dummy
 dnl (sg-linux and sg-freebsd use statvfs() unconditionally)
+AH_TEMPLATE([Libburn_os_has_statvfS], [Define to use statvfs() with libburn stdio])
 STATVFS_DEF=-DLibburn_os_has_statvfS
 AC_CHECK_HEADER(sys/statvfs.h, X=, STATVFS_DEF=)
 AC_CHECK_FUNC([statvfs], X=, STATVFS_DEF=)
-CFLAGS="$CFLAGS $STATVFS_DEF"
+if test x$STATVFS_DEF = x-DLibburn_os_has_statvfS
+then
+    AC_DEFINE([Libburn_os_has_statvfS], [])
+fi


 dnl Add compiler-specific flags
@ -108,15 +131,15 @@ AC_ARG_ENABLE(debug,
              , enable_debug=yes)
 if test x$enable_debug != xyes; then
    if test x$GCC = xyes; then
-        CFLAGS="$CFLAGS -O3"
-        CFLAGS="$CFLAGS -fexpensive-optimizations"
+        CFLAGS="-O3 $CFLAGS"
+        CFLAGS="-fexpensive-optimizations $CFLAGS"
    fi
-    CFLAGS="$CFLAGS -DNDEBUG"
+    CFLAGS="-DNDEBUG $CFLAGS"
 else
    if test x$GCC = xyes; then
-        CFLAGS="$CFLAGS -g -pedantic -Wall"
+        CFLAGS="-g -pedantic -Wall -Wextra -Wno-unused-parameter $CFLAGS"
    fi
-    CFLAGS="$CFLAGS -DDEBUG"
+    CFLAGS="-DDEBUG $CFLAGS"
 fi


@ -126,6 +149,7 @@ dnl
 LIBBURNIA_SET_PKGCONFIG


+AH_TEMPLATE([Xorriso_with_readlinE], [Define to use libreadline])
 AC_ARG_ENABLE(libreadline,
 [  --enable-libreadline    Enable use of libreadline by xorriso, default=yes],
               , enable_libreadline=yes)
@ -133,31 +157,54 @@ if test x$enable_libreadline = xyes; then
 dnl Check whether there is readline-devel and readline-runtime.
 dnl If not, erase this macro which would enable use of readline(),add_history()
    READLINE_DEF="-DXorriso_with_readlinE"
+
+    if test x$XORRISO_OLD_READLINE_CONFIGURE = x
+    then
+
+dnl ts B00411 : To disable readline if not all needed functions are present
+        LIBBURNIA_ASSERT_READLINE
+
+    else
 dnl The empty yes case obviously causes -lreadline to be linked
-    AC_CHECK_HEADER(readline/readline.h, AC_CHECK_LIB(readline, readline, , READLINE_DEF= ), READLINE_DEF= )
+        AC_CHECK_HEADER(readline/readline.h, AC_CHECK_LIB(readline, readline, , READLINE_DEF= ), READLINE_DEF= )
 dnl The X= in the yes case prevents that -lreadline gets linked twice
-    AC_CHECK_HEADER(readline/history.h, AC_CHECK_LIB(readline, add_history, X= , READLINE_DEF= ), READLINE_DEF= )
+        AC_CHECK_HEADER(readline/history.h, AC_CHECK_LIB(readline, add_history, X= , READLINE_DEF= ), READLINE_DEF= )
+
+    fi
 else
    READLINE_DEF=
 fi
-AC_SUBST(READLINE_DEF)
-
+if test x$READLINE_DEF = x-DXorriso_with_readlinE
+then
+    AC_DEFINE([Xorriso_with_readlinE], [])
+fi

+AH_TEMPLATE([Libisofs_with_aaip_acL], [Define to use ACL capabilities])
 AC_ARG_ENABLE(libacl,
-[  --enable-libacl         Enable use of libacl by libisofs, default=yes],
+[  --enable-libacl         Enable use of ACL functions by libisofs, default=yes],
               , enable_libacl=yes)
 if test x$enable_libacl = xyes; then
 dnl Check whether there is libacl-devel and libacl-runtime.
 dnl If not, erase this macro which would enable use of acl_to_text and others
    LIBACL_DEF="-DLibisofs_with_aaip_acL"
 dnl The empty yes case obviously causes -lacl to be linked
-    AC_CHECK_HEADER(sys/acl.h, AC_CHECK_LIB(acl, acl_to_text, , LIBACL_DEF= ), LIBACL_DEF= )
+    has_acl_h_but_no_func=0
+    AC_CHECK_HEADER(sys/acl.h, AC_CHECK_LIB(acl, acl_to_text, , has_acl_h_but_no_libacl=1 ), LIBACL_DEF= )
+    if test "$has_acl_h_but_no_libacl" = 1
+    then
+       AC_CHECK_LIB(c, acl_to_text, X= , LIBACL_DEF= )
+    fi
 else
    LIBACL_DEF=
 fi
-AC_SUBST(LIBACL_DEF)
+if test x$LIBACL_DEF = x-DLibisofs_with_aaip_acL
+then
+    AC_DEFINE([Libisofs_with_aaip_acL], [])
+fi


+AH_TEMPLATE([Libisofs_with_aaip_xattR], [Define to use xattr capabilities])
+AH_TEMPLATE([Libisofs_with_freebsd_extattR], [Define to use extattr capabilities])
 AC_ARG_ENABLE(xattr,
 [  --enable-xattr          Enable use of xattr by libisofs, default=yes],
               , enable_xattr=yes)
@ -166,12 +213,26 @@ dnl Check whether there is the header for GNU/Linux xattr.
 dnl If not, erase this macro which would enable use of listxattr and others
    XATTR_DEF="-DLibisofs_with_aaip_xattR"
    AC_CHECK_HEADER(attr/xattr.h, AC_CHECK_LIB(c, listxattr, X= , XATTR_DEF= ), XATTR_DEF= )
+    if test "x$XATTR_DEF" = x
+    then
+       XATTR_DEF="-DLibisofs_with_freebsd_extattR"
+       AC_CHECK_HEADER(sys/extattr.h, AC_CHECK_LIB(c, extattr_list_file, X=, XATTR_DEF= ), XATTR_DEF= )
+    fi
 else
    XATTR_DEF=
 fi
-AC_SUBST(XATTR_DEF)
+if test x$XATTR_DEF = x-DLibisofs_with_aaip_xattR
+then
+    AC_DEFINE([Libisofs_with_aaip_xattR], [])
+fi
+if test x$XATTR_DEF = x-DLibisofs_with_freebsd_extattR
+then
+    AC_DEFINE([Libisofs_with_freebsd_extattR], [])
+fi


+AH_TEMPLATE([Libisofs_with_zliB], [Define to use compression via zlib])
+AH_TEMPLATE([LIBJTE_WITH_ZLIB], [Allow libjte to use zlib])
 AC_ARG_ENABLE(zlib,
 [  --enable-zlib           Enable use of zlib by libisofs, default=yes],
               , enable_zlib=yes)
@ -181,17 +242,83 @@ dnl If not, erase this macro which would enable use of compress2() and others.
 dnl Linking fails on SuSE 9.0 because zlib has compress2() but lacks 
 dnl compressBound(). So compressBound is the more modern thing to test.
 dnl The empty parameter after "compressBound" causes -lz.
-    ZLIB_DEF="-DLibisofs_with_zliB"
+    ZLIB_DEF=yes
    AC_CHECK_HEADER(zlib.h, AC_CHECK_LIB(z, compressBound, , ZLIB_DEF= ), ZLIB_DEF= )
 else
    ZLIB_DEF=
 fi
-AC_SUBST(ZLIB_DEF)
+if test x$ZLIB_DEF = xyes
+then
+    AC_DEFINE([Libisofs_with_zliB], [])
+    AC_DEFINE([LIBJTE_WITH_ZLIB], [])
+fi


+# libjte source is included in GNU xorriso. Enable it if zlib is enabled.
+AH_TEMPLATE([Xorriso_with_libjtE],
+            [Define to use Jigdo Template Extraction via libjte])
+AH_TEMPLATE([Libisofs_with_libjtE],
+            [Define to use Jigdo Template Extraction via libjte])
+if test x$ZLIB_DEF = xyes
+then
+    AC_DEFINE([Xorriso_with_libjtE], [])
+    AC_DEFINE([Libisofs_with_libjtE], [])
+    LIBJTE_DEF=yes
+    echo "enabled  built-in libjte"
+else
+    LIBJTE_DEF=
+    echo "disabled libjte because zlib not enabled or not available"
+fi
+
+
+AH_TEMPLATE([THREADED_CHECKSUMS],
+            [Define to use multi-threading in built-in libjte])
+AC_ARG_ENABLE(jtethreads,
+[  --enable-jtethreads     Enable multi-threading in libjte, default=yes],
+               , enable_jtethreads=yes) 
+if test x$LIBJTE_DEF = xyes
+then
+    if test "x$enable_jtethreads" = xyes; then
+        AC_DEFINE([THREADED_CHECKSUMS], [])
+        echo "enabled  multi-threading in libjte"
+    else
+        echo "disabled multi-threading in libjte"
+    fi
+
+fi
+
+
+AH_TEMPLATE([LIBJTE_WITH_LIBBZ2],
+            [Define to use libbz2 by built-in libjte])
+AC_ARG_ENABLE(libbz2,
+[  --enable-libbz2         Enable use of libbz2 by libjte, default=yes],
+               , enable_libbz2=yes)
+if test "x$enable_libbz2" = xyes -a x$LIBJTE_DEF = xyes ; then
+dnl Check whether there is the header for libbz2.
+    BZIP2_DEF=yes
+    AC_CHECK_HEADER(bzlib.h, AC_CHECK_LIB(bz2, BZ2_bzCompressInit, , BZIP2_DEF= ), BZIP2_DEF= )
+else
+    BZIP2_DEF=
+fi
+if test x$BZIP2_DEF = xyes
+then
+    AC_DEFINE([LIBJTE_WITH_LIBBZ2], [])
+    BZIP2_DEF="-DLIBJTE_WITH_LIBBZ2"
+fi
+
+
+case $host_os in
+    cygwin*|mingw*)
+        default_libcdio=yes
+        ;;
+    *)
+        default_libcdio=no
+        ;;
+esac
+AH_TEMPLATE([Libburn_use_libcdiO], [Define to use libcdio as system adapter])
 AC_ARG_ENABLE(libcdio,
-[  --enable-libcdio         Enable EXPERIMENTAL use of libcdio as system adapter, default=no],
-               , enable_libcdio=no)
+[  --enable-libcdio        Enable use of libcdio as system adapter, default=no (except on MSWindows)],
+               , enable_libcdio=$default_libcdio)
 if test x$enable_libcdio = xyes; then
 dnl Check whether there is libcdio-devel and libcdio-runtime.
 dnl If not, erase this macro
@ -208,14 +335,15 @@ then
      echo "WARNING: could not enable use of libcdio as system adapter"
    fi
 else
-    echo "enabled  EXPERIMENTAL use of libcdio as system adapter"
-
-    LIBCDIO_REQUIRED=0.83
-    PKG_CHECK_MODULES(LIBCDIO, libcdio >= $LIBCDIO_REQUIRED)
+    echo "enabled  use of libcdio as system adapter"
+fi
+if test x$LIBCDIO_DEF = x-DLibburn_use_libcdiO
+then
+    AC_DEFINE([Libburn_use_libcdiO], [])
 fi
-AC_SUBST(LIBCDIO_DEF)


+AH_TEMPLATE([Xorriso_allow_external_filterS], [Define to allow xorriso to start external filter processes])
 AC_ARG_ENABLE(external-filters,
 [  --enable-external-filters   Enable use of external filter programs by xorriso, default=yes],
               , enable_external_filters=yes)
@ -226,8 +354,13 @@ else
    EXTF_DEF=
    echo "disabled xorriso external filter programs"
 fi
-AC_SUBST(EXTF_DEF)
+if test x$EXTF_DEF = x-DXorriso_allow_external_filterS
+then
+    AC_DEFINE([Xorriso_allow_external_filterS], [])
+fi

+
+AH_TEMPLATE([Xorriso_allow_extf_suiD], [Define to allow external filters to xorriso when running under setuid])
 AC_ARG_ENABLE(external-filters-setuid,
 [  --enable-external-filters-setuid   Enable xorriso external filter programs under setuid, default=no],
               , enable_external_filters_setuid=no)
@ -238,8 +371,45 @@ else
    EXTF_SUID_DEF=
    echo "disabled xorriso external filter programs under setuid"
 fi
-AC_SUBST(EXTF_SUID_DEF)
+if test x$EXTF_SUID_DEF = x-DXorriso_allow_extf_suiD
+then
+    AC_DEFINE([Xorriso_allow_extf_suiD], [])
+fi

+AH_TEMPLATE([Xorriso_allow_launch_frontenD], [Define to allow xorriso command -launch_frontend])
+AC_ARG_ENABLE(launch-frontend,
+[  --enable-launch-frontend        Enable start of piped frontend program by xorriso, default=yes],
+               , enable_launch_frontend=yes)
+if test x"$enable_launch_frontend" = xyes; then
+    LFRONT_DEF="-DXorriso_allow_launch_frontenD"
+    echo "enabled  xorriso command -launch_frontend"
+else
+    LFRONT_DEF=
+    echo "disabled xorriso command -launch_frontend"
+fi
+if test x$LFRONT_DEF = x-DXorriso_allow_launch_frontenD
+then
+    AC_DEFINE([Xorriso_allow_launch_frontenD], [])
+fi
+
+AH_TEMPLATE([Xorriso_allow_extf_suiD], [Define to allow xorriso command -launch_frontend when running under setuid])
+AC_ARG_ENABLE(launch-frontend-setuid,
+[  --enable-launch-frontend-setuid   Enable start of piped frontend program under setuid, default=no],
+               , enable_launch_frontend_setuid=no)
+if test x$enable_launch_frontend_setuid = xyes; then
+    LFRONT_SUID_DEF="-DXorriso_allow_extf_suiD"
+    echo "enabled  xorriso command -launch_frontend under setuid"
+else
+    LFRONT_SUID_DEF=
+    echo "disabled xorriso command -launch_frontend under setuid"
+fi
+if test x$LFRONT_SUID_DEF = x-DXorriso_allow_extf_suiD
+then
+    AC_DEFINE([Xorriso_allow_extf_suiD], [])
+fi
+
+
+AH_TEMPLATE([Xorriso_dvd_obs_default_64K], [Define to make 64 KB default size for DVD/BD writing])
 AC_ARG_ENABLE(dvd-obs-64k,
 [  --enable-dvd-obs-64k         64 KB default size for DVD/BD writing, default=no],
               , enable_dvd_obs=no)
@ -250,8 +420,13 @@ else
    XORRISO_DVD_OBS_64K=
    echo "disabled xorriso write size default 64 KB on DVD and BD"
 fi
-AC_SUBST(XORRISO_DVD_OBS_64K)
+if test x$XORRISO_DVD_OBS_64K = x-DXorriso_dvd_obs_default_64K
+then
+    AC_DEFINE([Xorriso_dvd_obs_default_64K], [])
+fi

+
+AH_TEMPLATE([Libburn_read_o_direcT], [Define to use O_DIRECT with -as cdrskin])
 AC_ARG_ENABLE(track-src-odirect,
 [  --enable-track-src-odirect   Enable use of O_DIRECT with -as cdrskin, default=no],
               , enable_track_src_odirect=no)
@ -262,12 +437,45 @@ else
    LIBBURN_O_DIRECT_DEF=
    echo "disabled use of O_DIRECT with input of -as cdrskin"
 fi
-AC_SUBST(LIBBURN_O_DIRECT_DEF)
+if test x$LIBBURN_O_DIRECT_DEF = x-DLibburn_read_o_direcT
+then
+    AC_DEFINE([Libburn_read_o_direcT], [])
+fi
+
+
+# ------- Visible mark in configure : Start of library check
+
+# Check for proper library versions if this is desired.
+# (It fails too often on too many systems.)
+AC_ARG_ENABLE(pkg-check-modules,
+[  --enable-pkg-check-modules      Enable pkg-config check for libburn and libisofs , default=no],
+               , enable_pkg_check_modules=no)
+if test x$enable_pkg_check_modules = xyes; then
+
+dnl If PKG_CHECK_MODULES is to be used after this if-block,
+dnl then it might be necessary to perform PKG_PROG_PKG_CONFIG before the block.
+
+  if test x$LIBCDIO_DEF = x; then
+    dummy=dummy
+  else
+    LIBCDIO_REQUIRED=0.83
+    PKG_CHECK_MODULES(LIBCDIO, libcdio >= $LIBCDIO_REQUIRED)
+  fi
+else
+  if test x$LIBCDIO_DEF = x; then
+    dummy=dummy
+  else
+    echo "checking for LIBCDIO... skipped, no --enable-pkg-check-modules"
+  fi
+fi
+
+# ------- Visible mark in configure : End of library check
+

 AC_CONFIG_FILES([
 	Makefile
 	version.h
 	])
 AC_OUTPUT
-
 #	xorriso.pc
+
--- a/xorriso/convert_man_to_html.sh
+++ b/xorriso/convert_man_to_html.sh
@ -1,117 +1,14 @@
 #!/bin/sh

 #
-# convert_man_to_html.sh - ts A80118
+# convert_man_to_html.sh - ts B11024
 #
-# Generates a HTML version of man page xorriso.1
+# Generates a HTML version of man pages xorriso.1 , xorrisofs.1 , xorrecord.1
 #
-# To be executed in the libisoburn toplevel directory (eg. ./libisoburn-0.1.0)
+# To be executed in the libisoburn toplevel directory (eg. ./libisoburn-1.1.8)
 #

-# set -x
+xorriso/man_xorriso_to_html.sh
+xorriso/man_xorrisofs_to_html.sh
+xorriso/man_xorrecord_to_html.sh

-man_dir=$(pwd)"/xorriso"
-export MANPATH="$man_dir"
-manpage="xorriso"
-raw_html=$(pwd)/"xorriso/raw_man_1_xorriso.html"
-htmlpage=$(pwd)/"xorriso/man_1_xorriso.html"
-
-if test -r "$man_dir"/"$manpage".1
-then
-  dummy=dummy
-else
-  echo "Cannot find readable man page source $1" >&2
-  exit 1
-fi
-
-if test -e "$man_dir"/man1
-then
-  dummy=dummy
-else
-  ln -s . "$man_dir"/man1
-fi
-
-if test "$1" = "-work_as_filter"
-then
-
-#  set -x
-
-  sed \
-  -e 's/<meta name="generator" content="groff -Thtml, see www.gnu.org">/<meta name="generator" content="groff -Thtml, via man -H, via xorriso\/convert_man_to_html.sh">/' \
-  -e 's/<meta name="Content-Style" content="text\/css">/<meta name="Content-Style" content="text\/css"><META NAME="description" CONTENT="man page of xorriso"><META NAME="keywords" CONTENT="man xorriso, manual, xorriso, CD, CD-RW, CD-R, burning, cdrecord, compatible"><META NAME="robots" CONTENT="follow">/' \
-  -e 's/<title>XORRISO<\/title>/<title>man 1 xorriso<\/title>/' \
-  -e 's/<h1 align=center>XORRISO<\/h1>/<h1 align=center>man 1 xorriso<\/h1>/' \
-  -e 's/<body>/<body BGCOLOR="#F5DEB3" TEXT=#000000 LINK=#0000A0 VLINK=#800000>/' \
-  -e 's/<b>Overview of features:<\/b>/\&nbsp;<BR><b>Overview of features:<\/b>/' \
-  -e 's/<b>General information paragraphs:<\/b>/\&nbsp;<BR><b>General information paragraphs:<\/b>/' \
-  -e 's/have a look at section EXAMPLES/have a look at section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
-  -e 's/<b>Session model:<\/b>/\&nbsp;<BR><b>Session model:<\/b>/' \
-  -e 's/<b>Media types and states:<\/b>/\&nbsp;<BR><b>Media types and states:<\/b>/' \
-  -e 's/<b>Creating, Growing, Modifying, Blind/\&nbsp;<BR><b>Creating, Growing, Modifying, Blind/' \
-  -e 's/<b>Libburn drives:<\/b>/\&nbsp;<BR><b>Libburn drives:<\/b>/' \
-  -e 's/^-dev /\&nbsp;\&nbsp;-dev /' \
-  -e 's/^-devices /\&nbsp;\&nbsp;-devices /' \
-  -e 's/<b>Rock Ridge, POSIX, X\/Open, El Torito, ACL,/\&nbsp;<BR><b>Rock Ridge, POSIX, X\/Open, El Torito, ACL,/' \
-  -e 's/<b>Command processing:<\/b>/\&nbsp;<BR><b>Command processing:<\/b>/' \
-  -e 's/<b>Dialog, Readline, Result pager:<\/b>/\&nbsp;<BR><b>Dialog, Readline, Result pager:<\/b>/' \
-  -e 's/<b>Aquiring source and target drive:<\/b>/\&nbsp;<BR><b>Aquiring source and target drive:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Influencing the behavior of image/\&nbsp;<BR><b>Influencing the behavior of image/' \
-  -e 's/<b>Inserting files into ISO image:<\/b>/\&nbsp;<BR><b>Inserting files into ISO image:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>File manipulations:<\/b>/\&nbsp;<BR><b>File manipulations:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Tree traversal command -find:<\/b>/\&nbsp;<BR><b>Tree traversal command -find:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/^<p><b>&minus;iso_rr_pattern/<p>\&nbsp;<BR><b>\&minus;iso_rr_pattern/' \
-  -e 's/EXAMPLES):<br>/<A HREF="#EXAMPLES">EXAMPLES<\/A>):<br>/' \
-  -e 's/<b>Filters for data file content:<\/b>/\&nbsp;<BR><b>Filters for data file content:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Writing the result, drive control:<\/b>/\&nbsp;<BR><b>Writing the result, drive control:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/^-find \/ /\&nbsp;\&nbsp;-find \/ /' \
-  -e 's/<b>Settings for file insertion:<\/b>/\&nbsp;<BR><b>Settings for file insertion:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/^$<\/b> ln -s/\&nbsp;\&nbsp;$<\/b> ln -s/' \
-  -e 's/<b>Settings for result writing:<\/b>/\&nbsp;<BR><b>Settings for result writing:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/^706k = 706kB/\&nbsp;\&nbsp;706k = 706kB/' \
-  -e 's/^5540k = 5540kB/\&nbsp;\&nbsp;5540k = 5540kB/' \
-  -e 's/<b>Character sets:<\/b>/\&nbsp;<BR><b>Character sets:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Exception processing:<\/b>/\&nbsp;<BR><b>Exception processing:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>El Torito bootable ISO images:<\/b>/\&nbsp;<BR><b>El Torito bootable ISO images:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Dialog mode control:<\/b>/\&nbsp;<BR><b>Dialog mode control:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Drive and media related inquiry actions:<\/b>/\&nbsp;<BR><b>Drive and media related inquiry actions:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Navigation in ISO image/\&nbsp;<BR><b>Navigation in ISO image/' \
-  -e 's/^filesystem:<\/b>/filesystem:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Evaluation of readability and recovery:<\/b>/\&nbsp;<BR><b>Evaluation of readability and recovery:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>osirrox ISO-to-disk restore options:<\/b>/\&nbsp;<BR><b>osirrox ISO-to-disk restore options:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Command compatibility emulations:<\/b>/\&nbsp;<BR><b>Command compatibility emulations:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/^<p><b>&minus;as</<p>\&nbsp;<BR><b>\&minus;as</' \
-  -e 's/<b>Scripting, dialog and/\&nbsp;<BR><b>Scripting, dialog and/' \
-  -e 's/^features:<\/b>/features:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/<b>Support for frontend/\&nbsp;<BR><b>Support for frontend/' \
-  -e 's/^listening at stdout:<\/b>/listening at stdout:<\/b><BR>\&nbsp;<BR>/' \
-  -e 's/xorriso -outdev \/dev\/sr2 \\ -blank fast \\ -pathspecs on/xorriso -outdev \/dev\/sr2 -blank fast -pathspecs on/' \
-  -e 's/\\ -add \\ \/sounds=\/home\/me\/sounds \\ \/pictures \\ -- \\ -rm_r \\/ -add \/sounds=\/home\/me\/sounds \/pictures -- -rm_r /' \
-  -e 's/\/sounds\/indecent \\ \&rsquo;\/pictures\/\*private\*\&rsquo; \\/\/sounds\/indecent \&rsquo;\/pictures\/*private*\&rsquo; /' \
-  -e 's/\/pictures\/confidential \\ -- \\ -add \\/\/pictures\/confidential -- -add/' \
-  -e 's/xorriso -dev \/dev\/sr2 \\ -rm_r \/sounds -- \\ -mv \\/xorriso -dev \/dev\/sr2 -rm_r \/sounds -- -mv /' \
-  -e 's/\/pictures\/confidential \\ \/pictures\/restricted \\ -- \\ -chmod/\/pictures\/confidential \/pictures\/restricted -- -chmod/' \
-  -e 's/go-rwx \/pictures\/restricted -- \\ -pathsspecs on \\ -add \\/go-rwx \/pictures\/restricted -- -pathsspecs on -add /' \
-  -e 's/\/sounds=\/home\/me\/prepared_for_dvd\/sounds_dummy /\/sounds=\/home\/me\/prepared_for_dvd\/sounds_dummy/' \
-  -e 's/\/movies=\/home\/me\/prepared_for_dvd\/movies \\ -- \\ -commit/\/movies=\/home\/me\/prepared_for_dvd\/movies -- -commit/' \
-  -e 's/xorriso -indev \/dev\/sr2 \\ -rm_r \/sounds -- \\/xorriso -indev \/dev\/sr2 -rm_r \/sounds -- /' \
-  -e 's/-outdev \/dev\/sr0 -blank fast \\ -commit -eject all/-outdev \/dev\/sr0 -blank fast -commit -eject all/' \
-  -e 's/See section FILES/See section <A HREF="#FILES">FILES<\/A>/' \
-  -e 's/See section EXAMPLES/See section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
-  -e 's/<\/body>/<BR><HR><FONT SIZE=-1><CENTER>(HTML generated from '"$manpage"'.1 on '"$(date)"' by '$(basename "$0")' )<\/CENTER><\/FONT><\/body>/' \
-  <"$2" >"$htmlpage"
-
-  set +x
-
-  chmod u+rw,go+r,go-w "$htmlpage"
-  echo "Emerged file:"
-  ls -lL "$htmlpage"
-
-else
-
-  export BROWSER='cp "%s" '"$raw_html"
-  man -H "$manpage"
-  "$0" -work_as_filter "$raw_html"
-  rm "$raw_html"
-  rm "$man_dir"/man1
-
-fi
--- a/xorriso/disk_ops.c
+++ b/xorriso/disk_ops.c
--- a/xorriso/disk_ops.h
+++ b/xorriso/disk_ops.h
@ -0,0 +1,117 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of class DirseQ which
+   crawls along a directory's content list.
+*/
+
+
+#ifndef Xorriso_pvt_diskop_includeD
+#define Xorriso_pvt_diskop_includeD yes
+
+
+/* @param flag bit0= simple readlink(): no normalization, no multi-hop
+*/
+int Xorriso_resolve_link(struct XorrisO *xorriso,
+                     char *link_path, char result_path[SfileadrL], int flag);
+
+int Xorriso_convert_gidstring(struct XorrisO *xorriso, char *gid_string,
+                              gid_t *gid, int flag);
+
+int Xorriso_convert_modstring(struct XorrisO *xorriso, char *cmd, char *mode,
+                              mode_t *mode_and, mode_t *mode_or, int flag);
+
+int Xorriso_convert_uidstring(struct XorrisO *xorriso, char *uid_string,
+                              uid_t *uid, int flag); 
+
+/* @param flag bit0= for Xorriso_msgs_submit: use pager
+*/
+int Xorriso_hop_link(struct XorrisO *xorriso, char *link_path,
+                   struct LinkiteM **link_stack, struct stat *stbuf, int flag);
+
+int Xorriso__mode_to_perms(mode_t st_mode, char perms[11], int flag);
+
+int Xorriso_format_ls_l(struct XorrisO *xorriso, struct stat *stbuf, int flag);
+
+/* @param flag bit0= long format
+               bit1= do not print count of nodes
+               bit2= du format
+               bit3= print directories as themselves (ls -d)
+*/
+int Xorriso_lsx_filev(struct XorrisO *xorriso, char *wd, 
+                      int filec, char **filev, off_t boss_mem, int flag);
+
+/*
+   @param flag >>> bit0= remove whole sub tree: rm -r
+               bit1= remove empty directory: rmdir 
+               bit2= recursion: do not reassure in mode 2 "tree"
+               bit3= this is for overwriting and not for plain removal
+               bit4= count deleted files in xorriso->pacifier_count
+               bit5= with bit0 only remove directory content, not the directory
+   @return   <=0 = error
+               1 = removed leaf file object
+               2 = removed directory or tree
+               3 = did not remove on user revocation
+*/
+int Xorriso_rmx(struct XorrisO *xorriso, off_t boss_mem, char *path, int flag);
+
+int Xorriso_findx(struct XorrisO *xorriso, struct FindjoB *job,
+                  char *abs_dir_parm, char *dir_path,
+                  struct stat *dir_stbuf, int depth,
+                  struct LinkiteM *link_stack, int flag);
+
+/* @param flag bit0= no hardlink reconstruction
+               bit1= do not set xorriso->node_*_prefixes
+               bit5= -extract_single: eventually do not insert directory tree
+*/
+int Xorriso_restore_sorted(struct XorrisO *xorriso, int count,
+                           char **src_array, char **tgt_array, 
+                           int *problem_count, int flag);
+
+/* @param flag bit0= path is a directory
+               bit2= recursion: do not reassure in mode 2 "tree"
+               bit3= this is for overwriting and not for plain removal
+*/
+int Xorriso_reassure_restore(struct XorrisO *xorriso, char *path, int flag);
+
+/* @param flag bit7= return 4 if restore fails from denied permission
+                     do not issue error message
+   @return <=0 failure , 1 success ,
+           4 with bit7: permission to create file was denied
+*/
+int Xorriso_make_tmp_path(struct XorrisO *xorriso, char *orig_path,
+                          char *tmp_path, int *fd, int flag);
+
+/* @param flag bit0= change regardless of xorriso->do_auto_chmod
+               bit1= desired is only rx
+*/
+int Xorriso_auto_chmod(struct XorrisO *xorriso, char *disk_path, int flag);
+
+int Xorriso_make_accessible(struct XorrisO *xorriso, char *disk_path,int flag);
+
+/* @param flag bit0= prefer to find a match after *img_prefixes
+                     (but deliver img_prefixes if no other can be found)
+*/
+int Xorriso_make_restore_path(struct XorrisO *xorriso,
+         struct Xorriso_lsT **img_prefixes, struct Xorriso_lsT **disk_prefixes,
+         char img_path[SfileadrL], char disk_path[SfileadrL], int flag);
+
+int Xorriso_restore_make_hl(struct XorrisO *xorriso,
+                            char *old_path, char *new_path, int flag);
+
+int Xorriso_afile_fopen(struct XorrisO *xorriso,
+                        char *filename, char *mode, FILE **ret_fp, int flag);
+
+int Xorriso_make_mount_cmd(struct XorrisO *xorriso, char *cmd,
+                           int lba, int track, int session, char *volid,
+                           char *devadr, char result[SfileadrL], int flag);
+
+int Xorriso_append_scdbackup_record(struct XorrisO *xorriso, int flag);
+
+
+#endif /* ! Xorriso_pvt_diskop_includeD */
+
--- a/xorriso/drive_mgt.c
+++ b/xorriso/drive_mgt.c
--- a/xorriso/drive_mgt.h
+++ b/xorriso/drive_mgt.h
@ -0,0 +1,42 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which operate on drives
+   and media.
+*/
+
+
+#ifndef Xorriso_pvt_drive_mgt_includeD
+#define Xorriso_pvt_drive_mgt_includeD yes
+
+
+int Xorriso_may_burn(struct XorrisO *xorriso, int flag);
+
+int Xorriso_toc_line(struct XorrisO *xorriso, int flag);
+
+int Xorriso_media_product(struct XorrisO *xorriso, int flag);
+
+int Xorriso_check_md5_range(struct XorrisO *xorriso, off_t start_lba,
+                            off_t end_lba, char md5[16], int flag);
+
+int Xorriso_check_interval(struct XorrisO *xorriso, struct SpotlisT *spotlist,
+                           struct CheckmediajoB *job,
+                           int from_lba, int block_count, int read_chunk,
+                           int md5_start, int flag);
+
+int Xorriso_get_drive_handles(struct XorrisO *xorriso,
+                              struct burn_drive_info **dinfo,
+                              struct burn_drive **drive,
+                              char *attempt, int flag);
+
+int Xorriso_check_for_abort(struct XorrisO *xorriso,
+                            char *abort_file_path,
+                            double post_read_time,
+                            double *last_abort_file_time, int flag);
+
+#endif /* ! Xorriso_pvt_drive_mgt_includeD */
+
--- a/xorriso/emulators.c
+++ b/xorriso/emulators.c
--- a/xorriso/emulators.h
+++ b/xorriso/emulators.h
@ -0,0 +1,37 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of emulators for mkisofs and cdrecord.
+*/
+
+
+#ifndef Xorriso_pvt_emul_includeD
+#define Xorriso_pvt_emul_includeD yes
+
+/* micro version of cdrskin */
+int Xorriso_cdrskin(struct XorrisO *xorriso, char *whom, int argc, char **argv,
+                    int flag);
+
+int Xorriso_cdrskin_help(struct XorrisO *xorriso, int flag);
+
+int Xorriso_cdrskin_uses_stdout(struct XorrisO *xorriso, int argc, char **argv,
+                                int flag);
+
+int Xorriso_as_cdrskin(struct XorrisO *xorriso, int argc, char **argv,
+                      int *idx, int flag);
+
+/* micro emulation of mkisofs */
+int Xorriso_genisofs(struct XorrisO *xorriso, char *whom,
+                     int argc, char **argv, int flag);
+
+int Xorriso_genisofs_help(struct XorrisO *xorriso, int flag);
+
+int Xorriso_as_genisofs(struct XorrisO *xorriso, int argc, char **argv,
+                      int *idx, int flag);
+
+#endif /* ! Xorriso_pvt_emul_includeD */
+
--- a/xorriso/filters.c
+++ b/xorriso/filters.c
@ -0,0 +1,701 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2011 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains functions which operate on data filter objects.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <time.h>
+#include <errno.h>
+
+#include "lib_mgt.h"
+#include "iso_tree.h"
+
+/*
+
+#include "xorriso.h"
+#include "xorriso_private.h"
+#include "xorrisoburn.h"
+
+#include "iso_img.h"
+#include "iso_manip.h"
+#include "sort_cmp.h"
+
+*/
+
+
+struct Xorriso_extF {
+
+ int flag; /* unused yet */
+
+ IsoExternalFilterCommand *cmd;
+
+};
+
+int Xorriso_extf_destroy(struct XorrisO *xorriso, struct Xorriso_extF **filter,
+                         int flag);
+
+
+/* @param flag see struct Xorriso_extF.flag */
+int Xorriso_extf_new(struct XorrisO *xorriso, struct Xorriso_extF **filter,
+                     char *path, int argc, char **argv, int behavior,
+                     char *suffix, char *name, int flag)
+{
+ int i;
+ struct Xorriso_extF *o= NULL;
+ IsoExternalFilterCommand *cmd;
+
+ *filter= o= calloc(sizeof(struct Xorriso_extF), 1);
+ if(o == NULL)
+   goto failure;
+ o->flag= flag;
+ o->cmd= NULL;
+ o->cmd= cmd= calloc(sizeof(IsoExternalFilterCommand), 1);
+ if(cmd == NULL)
+   goto failure;
+ cmd->version= 0;
+ cmd->refcount= 0;
+ cmd->name= NULL;
+ cmd->path= NULL;
+ cmd->argv= NULL;
+ cmd->argc= argc + 1;
+ cmd->behavior= behavior;
+ cmd->suffix= NULL;
+ cmd->suffix= strdup(suffix);
+ if(cmd->suffix == NULL)
+   goto failure;
+
+ cmd->path= strdup(path);
+ if(cmd->path == NULL)
+   goto failure;
+ cmd->argv= calloc(sizeof(char *), argc + 2);
+ if(cmd->argv == NULL)
+   goto failure;
+ for(i= 0; i < argc + 2; i++)
+   cmd->argv[i]= NULL;
+ cmd->argv[0]= strdup(path);
+ if(cmd->argv[0] == NULL)
+   goto failure;
+ for(i= 0; i < argc; i++) {
+   cmd->argv[i + 1]= strdup(argv[i]);
+   if(cmd->argv[i] == NULL)
+     goto failure;
+ }
+ cmd->name= strdup(name);
+ if(cmd->name == NULL)
+   goto failure;
+ return(1);
+failure:;
+ Xorriso_extf_destroy(xorriso, filter, 0);
+ return(-1);
+}
+
+
+int Xorriso_extf_destroy(struct XorrisO *xorriso, struct Xorriso_extF **filter,
+                         int flag)
+{
+ int i;
+ IsoExternalFilterCommand *cmd;
+
+ if(*filter == NULL)
+   return(0);
+ cmd= (*filter)->cmd;
+ if(cmd != NULL) {
+   if(cmd->refcount > 0)
+     return(0);
+   if(cmd->path != NULL)
+     free(cmd->path);
+   if(cmd->suffix != NULL)
+     free(cmd->suffix);
+   if(cmd->argv != NULL) {
+     for(i= 0; i < cmd->argc; i++)
+       if(cmd->argv[i] != NULL)
+         free(cmd->argv[i]);
+     free((char *) cmd->argv);
+   }
+   if(cmd->name != NULL)
+     free(cmd->name);
+   free((char *) cmd);
+ }
+ free((char *) *filter);
+ *filter= NULL;
+ return(1);
+}
+
+
+int Xorriso_lookup_extf(struct XorrisO *xorriso, char *name,
+                        struct Xorriso_lsT **found_lst, int flag)
+{
+ struct Xorriso_extF *filter;
+ struct Xorriso_lsT *lst;
+
+ for(lst= xorriso->filters; lst != NULL; lst= Xorriso_lst_get_next(lst, 0)) {
+   filter= (struct Xorriso_extF *) Xorriso_lst_get_text(lst, 0);
+   if(strcmp(filter->cmd->name, name) == 0) {
+     *found_lst= lst;
+     return(1);
+   }
+ }
+ return(0);
+}
+
+
+int Xorriso_destroy_all_extf(struct XorrisO *xorriso, int flag)
+{
+ struct Xorriso_extF *filter;
+ struct Xorriso_lsT *lst, *next_lst;
+
+ for(lst= xorriso->filters; lst != NULL; lst= next_lst) {
+   filter= (struct Xorriso_extF *) Xorriso_lst_get_text(lst, 0);
+   Xorriso_lst_detach_text(lst, 0);
+   next_lst= Xorriso_lst_get_next(lst, 0);
+   Xorriso_lst_destroy(&lst, 0);
+   Xorriso_extf_destroy(xorriso, &filter, 0);
+ }
+ xorriso->filters= NULL;
+ return(1);
+}
+
+
+/*
+ @param flag   bit0= return 2 if renaming is not possible by libisofs
+                     (always: if demanded strip suffix is missing
+                              or if suffix makes name length > 255)
+               bit1= strip suffix rather than appending it
+*/
+int Xorriso_rename_suffix(struct XorrisO *xorriso, IsoNode *node, char *suffix,
+                          char *show_path, char new_name[], int flag)
+{
+ int ret, lo= 0, ls= 0, strip_suffix;
+ char *old_name= NULL, *show_name;
+
+ strip_suffix= !!(flag & 2);
+ 
+ old_name= strdup((char *) iso_node_get_name(node));
+ show_name= old_name;
+ if(show_path != NULL)
+   if(show_path[0] != 0)
+     show_name= show_path;
+ lo= strlen(old_name);
+ ls= strlen(suffix);
+ if(strip_suffix) {
+   if(lo <= ls) {
+     /* refuse gracefully */
+     ret= 2; goto ex;
+   }
+   if(strcmp(old_name + lo - ls, suffix) != 0) {
+     ret= 2; goto ex;
+   }
+   if(lo >= SfileadrL)
+     goto cannot_remove_suffix;
+   strcpy(new_name, old_name);
+   new_name[lo - ls]= 0;
+   ret = iso_node_set_name(node, new_name);
+   if (ret < 0) {
+     Xorriso_process_msg_queues(xorriso,0);
+     if (!(flag & 1))
+       Xorriso_report_iso_error(xorriso, "", ret,
+                            "Error when renaming ISO node", 0, "FAILURE", 1);
+cannot_remove_suffix:;
+     strcpy(xorriso->info_text, "-set_filter: Cannot remove suffix from ");
+     Text_shellsafe(show_name, xorriso->info_text, 1);
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
+                         (flag & 1) ? "WARNING" : "FAILURE", 0);
+     ret= 2 * (flag & 1); goto ex;
+   }
+ } else {
+   /* check whether suffix already present */
+   if(lo >= ls)
+     if(strcmp(old_name + lo - ls, suffix) == 0) {
+       /* refuse gracefully */
+       ret= 2; goto ex;
+     }
+   if(lo + ls > 255) {
+cannot_append_suffix:;
+     strcpy(xorriso->info_text, "-set_filter: Cannot append suffix to ");
+     Text_shellsafe(show_name, xorriso->info_text, 1);
+     strcat(xorriso->info_text, ". Left unfiltered.");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
+                         (flag & 1) ? "WARNING" : "FAILURE", 0);
+     ret= 2 * (flag & 1); goto ex;
+   } 
+   sprintf(new_name, "%s%s", old_name, suffix);
+   ret = iso_node_set_name(node, new_name);
+   if (ret < 0) {
+     Xorriso_process_msg_queues(xorriso,0);
+     if (!(flag & 1))
+       Xorriso_report_iso_error(xorriso, "", ret,
+                              "Error when renaming ISO node", 0, "FAILURE", 1);
+     goto cannot_append_suffix;
+   }
+ }
+
+ ret= 1;
+ex:;
+ if(old_name != NULL)
+   free(old_name);
+ Xorriso_process_msg_queues(xorriso,0);
+ return(ret);
+}
+
+
+/*
+ @param flag   bit0= return 2 if renaming is not possible
+               bit1= print pacifier messages
+ */
+int Xorriso_set_filter(struct XorrisO *xorriso, void *in_node,
+                       char *path, char *filter_name, int flag)
+{
+ int ret, strip_suffix= 0, strip_filter= 0, filter_ret= 0;
+ int explicit_suffix= 0, internal_filter= 0;
+ IsoNode *node;
+ IsoFile *file;
+ struct Xorriso_lsT *found_lst;
+ struct Xorriso_extF *found_filter;
+ IsoExternalFilterCommand *cmd = NULL;
+ char *old_name= NULL, *new_name= NULL, *suffix= "";
+ IsoStream *stream;
+
+ Xorriso_alloc_meM(new_name, char, SfileadrL);
+ new_name[0]= 0;
+
+ node= (IsoNode *) in_node;
+ if(node == NULL) {
+   ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
+   if(ret <= 0)
+     goto ex;
+ }
+ if(!LIBISO_ISREG(node)) {
+   strcpy(xorriso->info_text, "-set_filter: Not a regular data file node ");
+   Text_shellsafe(path, xorriso->info_text, 1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
+   ret= 0; goto ex;
+ }
+ file= (IsoFile *) node;
+
+ if(strncmp(filter_name, "--remove-all-filters", 20) == 0) {
+   strip_filter= 1;
+   strip_suffix= 1;
+   if(strlen(filter_name) > 21) {
+     strip_suffix= (filter_name[20] != '+');
+     suffix= filter_name + 21;
+     explicit_suffix= 1;
+   }
+ } else if(strcmp(filter_name, "--zisofs") == 0) {
+   internal_filter= 1;
+ } else if(strcmp(filter_name, "--zisofs-decode") == 0) {
+   internal_filter= 2;
+ } else if(strcmp(filter_name, "--gzip") == 0) {
+   internal_filter= 3;
+   suffix= ".gz";
+   strip_suffix= 0;
+   explicit_suffix= 1;
+ } else if(strcmp(filter_name, "--gunzip") == 0 ||
+           strcmp(filter_name, "--gzip-decode") == 0) {
+   internal_filter= 4;
+   suffix= ".gz";
+   strip_suffix= 1;
+   explicit_suffix= 1;
+ } else {
+   ret= Xorriso_lookup_extf(xorriso, filter_name, &found_lst, 0);
+   if(ret < 0)
+     goto ex;
+   if(ret == 0) {
+     strcpy(xorriso->info_text, "-set_filter: Not a registered filter name ");
+     Text_shellsafe(filter_name, xorriso->info_text, 1);
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+     ret= 0; goto ex;
+   }
+   found_filter= (struct Xorriso_extF *) Xorriso_lst_get_text(found_lst, 0);
+   cmd= found_filter->cmd;
+   suffix= cmd->suffix;
+   strip_suffix= cmd->behavior & 8;
+ }
+
+ if(suffix[0]) {
+
+   /* >>> would need full iso_rr_path of node for showing */;
+
+   old_name= strdup((char *) iso_node_get_name(node));
+   ret= Xorriso_rename_suffix(xorriso, node, suffix, path, new_name,
+                               (flag & 1) | (strip_suffix ? 2 : 0));
+   if(ret <= 0 || ret == 2)
+     goto ex;
+ }
+
+ if(strip_filter) {
+   while(1) {
+     if(!explicit_suffix) {
+       stream= iso_file_get_stream(file);
+
+       if(strncmp(stream->class->type, "gzip", 4) == 0) {
+         suffix= ".gz";
+         strip_suffix= 1;
+       } else if(strncmp(stream->class->type, "pizg", 4) == 0) {
+         suffix= ".gz";
+         strip_suffix= 0;
+       } else {
+         ret= iso_stream_get_external_filter(stream, &cmd, 0);
+         if(ret > 0) {
+           suffix= cmd->suffix;
+           strip_suffix= !(cmd->behavior & 8);
+         }
+       }
+       if(suffix[0]) {
+
+         /* >>> would need the current renaming state of path */;
+
+         ret= Xorriso_rename_suffix(xorriso, node, suffix, NULL, new_name,
+                                    (flag & 1) | (strip_suffix << 1));
+         if(ret <= 0 || ret == 2)
+           goto ex;
+       }
+     }
+     ret= iso_file_remove_filter(file, 0);
+     if(ret != 1)
+   break;
+   }
+   filter_ret= 1;
+ } else if (internal_filter == 1 || internal_filter == 2) {
+   filter_ret = iso_file_add_zisofs_filter(file, 1 | (internal_filter & 2));
+   if(filter_ret < 0) {
+     Xorriso_process_msg_queues(xorriso,0);
+     if(!(internal_filter == 2 && filter_ret == (int) ISO_ZISOFS_WRONG_INPUT))
+       Xorriso_report_iso_error(xorriso, "", filter_ret,
+                    "Error when setting filter to ISO node", 0, "FAILURE", 1);
+   }
+ } else if (internal_filter == 3 || internal_filter == 4) {
+   filter_ret = iso_file_add_gzip_filter(file,
+                                         1 | ((internal_filter == 4) << 1));
+   if(filter_ret < 0) {
+     Xorriso_process_msg_queues(xorriso,0);
+     Xorriso_report_iso_error(xorriso, "", filter_ret,
+                    "Error when setting filter to ISO node", 0, "FAILURE", 1);
+   }
+ } else {
+
+#ifndef Xorriso_allow_extf_suiD
+   /* This is a final safety precaution before iso_file_add_external_filter()
+      performs fork() and executes the alleged filter program.
+   */
+   if(getuid() != geteuid()) {
+     sprintf(xorriso->info_text,
+          "-set_filter: UID and EUID differ. Will not run external programs.");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+     ret= 0; goto ex;
+   }
+#endif /* ! Xorriso_allow_extf_suiD */
+
+   filter_ret = iso_file_add_external_filter(file, cmd, 0);
+   if(filter_ret < 0) {
+     Xorriso_process_msg_queues(xorriso,0);
+     Xorriso_report_iso_error(xorriso, "", filter_ret,
+                    "Error when setting filter to ISO node", 0, "FAILURE", 1);
+   }
+ }
+ if(filter_ret != 1 && new_name[0] && old_name != NULL) {
+   ret = iso_node_set_name(node, old_name);
+   if (ret < 0) {
+     Xorriso_process_msg_queues(xorriso,0);
+     if (!(flag & 1))
+       Xorriso_report_iso_error(xorriso, "", ret,
+                              "Error when renaming ISO node", 0, "FAILURE", 1);
+   }
+ }
+ if(flag & 2) {
+   xorriso->pacifier_count++;
+   Xorriso_pacifier_callback(xorriso, "file filters processed",
+                      xorriso->pacifier_count, xorriso->pacifier_total, "", 0);
+ }
+ if(filter_ret < 0) {
+   ret= 0; goto ex;
+ }
+
+ ret= filter_ret;
+ex:;
+ if(old_name != NULL)
+   free(old_name);
+ Xorriso_free_meM(new_name);
+ Xorriso_process_msg_queues(xorriso,0);
+ return(ret);
+}
+
+
+/* @param flag bit0= delete filter with the given name
+*/
+int Xorriso_external_filter(struct XorrisO *xorriso,
+                            char *name, char *options, char *path, 
+                            int argc, char **argv, int flag)
+{
+ int ret, delete= 0, behavior= 0, extf_flag= 0, is_banned= 0;
+ char *what, *what_next, *suffix= "";
+ struct Xorriso_lsT *lst;
+ struct Xorriso_extF *found_filter, *new_filter= NULL;
+
+#ifndef Xorriso_allow_external_filterS
+ /* To be controlled by: configure --enable-external-filters */
+
+ sprintf(xorriso->info_text, "%s : Banned at compile time.",
+         flag & 1 ? "-unregister_filter" : "-external_filter");
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+ sprintf(xorriso->info_text,
+"This may be changed at compile time by ./configure option --enable-external-filters");
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
+ is_banned= 1;
+ 
+#endif /* ! Xorriso_allow_external_filterS */
+
+#ifndef Xorriso_allow_extf_suiD
+ /* To be controlled by: configure --enable-external-filters-setuid */
+
+ if(getuid() != geteuid()) {
+   sprintf(xorriso->info_text,
+          "-set_filter: UID and EUID differ. Will not run external programs.");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   sprintf(xorriso->info_text,
+"This may be changed at compile time by ./configure option --enable-external-filters-setuid");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0);
+   is_banned= 1;
+ }
+#endif /* ! Xorriso_allow_extf_suiD */
+
+ if(is_banned)
+   return(0);
+
+ if(xorriso->filter_list_closed) {
+   sprintf(xorriso->info_text,
+           "%s : Banned by previous command -close_filter_list",
+           flag & 1 ? "-unregister_filter" : "-external_filter");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   return(0);
+ } 
+ if((!(flag & 1)) && path[0] != '/') {
+   sprintf(xorriso->info_text,
+           "-external_filter : Given command path does not begin by '/' : ");
+   Text_shellsafe(path, xorriso->info_text, 1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   return(0);
+ }
+
+
+ delete= flag & 1;
+ ret= Xorriso_lookup_extf(xorriso, name, &lst, 0);
+ if(ret < 0)
+   return(ret);
+ if(ret > 0) {
+   if(delete) {
+     found_filter= (struct Xorriso_extF *) Xorriso_lst_get_text(lst, 0);
+     if(found_filter->cmd->refcount > 0) {
+       sprintf(xorriso->info_text,
+ "-external_filter: Cannot remove filter because it is in use by %.f nodes : ",
+              (double) found_filter->cmd->refcount);
+       Text_shellsafe(name, xorriso->info_text, 1);
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+       ret= 0; goto ex;
+     }
+     Xorriso_lst_detach_text(lst, 0);
+     if(xorriso->filters == lst)
+       xorriso->filters= Xorriso_lst_get_next(lst, 0);
+     Xorriso_lst_destroy(&lst, 0);
+     Xorriso_extf_destroy(xorriso, &found_filter, 0);
+     ret= 1; goto ex;
+   }
+   strcpy(xorriso->info_text,
+          "-external_filter: filter with given name already existing: ");
+   Text_shellsafe(name, xorriso->info_text, 1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   ret= 0; goto ex;
+ }
+ if(delete) {
+   strcpy(xorriso->info_text,
+          "-external_filter: filter with given name does not exist: ");
+   Text_shellsafe(name, xorriso->info_text, 1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   ret= 0; goto ex;
+ }
+
+ for(what= options; what!=NULL; what= what_next) {
+   what_next= strchr(what, ':');
+   if(what_next!=NULL) {
+     *what_next= 0;
+     what_next++;
+   }
+   if(strncmp(what, "default", 7) == 0) {
+     suffix= "";
+     behavior= 0;
+   } else if(strncmp(what, "suffix=", 7) == 0) {
+     suffix= what + 7;
+   } else if(strcmp(what, "remove_suffix") == 0) {
+     behavior|= 8;
+   } else if(strcmp(what, "if_nonempty") == 0) {
+     behavior|= 1;
+   } else if(strcmp(what, "if_reduction") == 0) {
+     behavior|= 2;
+   } else if(strcmp(what, "if_block_reduction") == 0) {
+     behavior|= 4;
+   } else if(strncmp(what, "used=", 5) == 0) {
+     ; /* this is informational output from -status */
+   } else if(what[0]) {
+     strcpy(xorriso->info_text,
+            "-external_filter: unknown option ");
+     Text_shellsafe(what, xorriso->info_text, 1);
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+     ret= 0; goto ex;
+   }
+ }
+
+ ret= Xorriso_extf_new(xorriso, &new_filter, path, argc, argv, behavior,
+                       suffix, name, extf_flag);
+ if(ret <= 0) {
+could_not_create:;
+   strcpy(xorriso->info_text,
+          "-external_filter: Could not create filter object");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   goto ex;
+ }
+ ret= Xorriso_lst_append_binary(&(xorriso->filters), (char *) new_filter,0, 4);
+ if(ret <= 0)
+   goto could_not_create;
+ ret= 1;
+ex:;
+ if(ret <= 0) {
+   if(new_filter != NULL)
+     Xorriso_extf_destroy(xorriso, &new_filter, 0);
+ }
+ return(ret);
+}
+
+
+int Xorriso_status_extf(struct XorrisO *xorriso, char *filter, FILE *fp,
+                        int flag)
+/*
+ bit1= do only report to fp
+*/ 
+{
+ int i, maxl= 4 * SfileadrL;
+ struct Xorriso_extF *extf;
+ struct Xorriso_lsT *lst;
+ char *line;
+
+ line= xorriso->result_line;
+ for(lst= xorriso->filters; lst != NULL; lst= Xorriso_lst_get_next(lst, 0)) {
+   extf= (struct Xorriso_extF *) Xorriso_lst_get_text(lst, 0);
+   
+   strcpy(xorriso->result_line, "-external_filter ");
+   Text_shellsafe(extf->cmd->name, line, 1);
+   if((int) strlen(line) > maxl)
+ continue;
+   strcat(line, " ");
+   if(extf->cmd->suffix[0]) {
+     strcat(line, "suffix=");
+     Text_shellsafe(extf->cmd->suffix, line, 1);
+     if((int) strlen(line) > maxl)
+ continue;
+     strcat(line, ":");
+   }
+   if(extf->cmd->behavior & 8)
+     strcat(line, "remove_suffix:");
+   if(extf->cmd->behavior & 1)
+     strcat(line, "if_nonempty:");
+   if(extf->cmd->behavior & 2)
+     strcat(line, "if_reduction:");
+   if(extf->cmd->behavior & 4)
+     strcat(line, "if_block_reduction:");
+   sprintf(line + strlen(line), "used=%.f ", (double) extf->cmd->refcount);
+   if((int) strlen(line) > maxl)
+ continue;
+   Text_shellsafe(extf->cmd->path, line, 1);
+   if((int) strlen(line) > maxl)
+ continue;
+   for(i= 1; i < extf->cmd->argc; i++) {
+     strcat(line, " ");
+     Text_shellsafe(extf->cmd->argv[i], line, 1);
+     if((int) strlen(line) > maxl)
+   break;
+   }
+   if(i < extf->cmd->argc)
+ continue;
+   strcat(line, " --\n");
+   Xorriso_status_result(xorriso, filter, fp, flag&2);
+ }
+ if(xorriso->filter_list_closed) {
+   strcpy(line, "-close_filter_list\n");
+   Xorriso_status_result(xorriso, filter, fp, flag&2);
+ }
+ return(1);
+}
+
+
+int Xorriso_set_zisofs_params(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ struct iso_zisofs_ctrl ctrl;
+
+ ctrl.version= 0;
+ ctrl.compression_level= xorriso->zlib_level;
+ if(xorriso->zisofs_block_size == (1 << 16))
+   ctrl.block_size_log2= 16;
+ else if(xorriso->zisofs_block_size == (1 << 17))
+   ctrl.block_size_log2= 17;
+ else
+   ctrl.block_size_log2= 15;
+ ret= iso_zisofs_set_params(&ctrl, 0);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret < 0) {
+   Xorriso_report_iso_error(xorriso, "", ret,
+                      "Error when setting zisofs parameters", 0, "FAILURE", 1);
+   return(0);
+ }
+ return(1);
+}
+
+
+int Xorriso_status_zisofs(struct XorrisO *xorriso, char *filter, FILE *fp,
+                          int flag)
+/*
+ bit0= do only report non-default settings
+ bit1= do only report to fp
+*/ 
+{
+ off_t ziso_count= 0, osiz_count= 0;
+ off_t gzip_count= 0, gunzip_count= 0;
+
+ iso_zisofs_get_refcounts(&ziso_count, &osiz_count, 0);
+ iso_gzip_get_refcounts(&gzip_count, &gunzip_count, 0);
+ if((flag & 1) && xorriso->zlib_level == xorriso->zlib_level_default &&
+    xorriso->zisofs_block_size == xorriso->zisofs_block_size_default &&
+    xorriso->zisofs_by_magic == 0 &&
+    ziso_count == 0 && osiz_count == 0 &&
+    gzip_count == 0 && gunzip_count == 0) {
+   if(filter == NULL)
+     return(2);
+   if(filter[0] == 0)
+     return 2;
+ }
+ sprintf(xorriso->result_line,
+     "-zisofs level=%d:block_size=%dk:by_magic=%s:ziso_used=%.f:osiz_used=%.f",
+     xorriso->zlib_level, xorriso->zisofs_block_size / 1024,
+     xorriso->zisofs_by_magic ? "on" : "off",
+     (double) ziso_count, (double) osiz_count);
+ sprintf(xorriso->result_line + strlen(xorriso->result_line),
+         ":gzip_used=%.f:gunzip_used=%.f\n",
+         (double) gzip_count, (double) gunzip_count);
+ Xorriso_status_result(xorriso, filter, fp, flag&2);
+ return(1);
+}
+
--- a/xorriso/filters.h
+++ b/xorriso/filters.h
@ -0,0 +1,31 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which operate on
+   data filter objects.
+*/
+
+
+#ifndef Xorriso_pvt_filters_includeD
+#define Xorriso_pvt_filters_includeD yes
+
+int Xorriso_extf_new(struct XorrisO *xorriso, struct Xorriso_extF **filter,
+                     char *path, int argc, char **argv, int behavior,
+                     char *suffix, char *name, int flag);
+
+int Xorriso_extf_destroy(struct XorrisO *xorriso, struct Xorriso_extF **filter,
+                         int flag);
+
+int Xorriso_lookup_extf(struct XorrisO *xorriso, char *name,
+                        struct Xorriso_lsT **found_lst, int flag);
+
+int Xorriso_rename_suffix(struct XorrisO *xorriso, IsoNode *node, char *suffix,
+                          char *show_path, char new_name[], int flag);
+
+
+#endif /* ! Xorriso_pvt_filters_includeD */
+
--- a/xorriso/findjob.c
+++ b/xorriso/findjob.c
--- a/xorriso/findjob.h
+++ b/xorriso/findjob.h
@ -0,0 +1,430 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2012 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of classes FindjoB, ExprnodE, ExprtesT
+   which perform tree searches in libisofs or in POSIX filesystem.
+*/
+
+
+#ifndef Xorriso_pvt_findjob_includeD
+#define Xorriso_pvt_findjob_includeD yes
+
+
+#define Xorriso_findjob_on_expR yes
+
+#ifdef Xorriso_findjob_on_expR
+
+/*
+   A single Testnode.
+*/
+struct ExprtesT {
+
+ struct FindjoB *boss;
+
+ int invert;  /* 0=normal  1=invert result */ 
+
+ /*
+   0= -false (with invert : -true)
+   1= -name char *arg1 (regex_t in *arg2)
+   2= -type char *arg1
+   3= -damaged
+   4= -lba_range int *arg1 int *arg2
+   5= -has_acl
+   6= -has_xattr
+   7= -has_aaip
+   8= -has_filter
+   9= -wanted_node IsoNode *arg1 (for internal use, arg1 not allocated)
+  10= -pending_data
+  11= -decision char *arg1 ("yes", "no")
+  12= -prune
+  13= -wholename char *arg1 (regex_t in *arg2)
+  14= -has_any_xattr
+  15= -has_md5
+  16= -disk_name char *arg1 (regex_t in *arg2)
+  17= -hidden int *arg1 (bit0=iso_rr, bit1=joliet)
+  18= -has_hfs_crtp char *creator char *type 
+  19= -has_hfs_bless int bless_index
+  20= -disk_path char *arg1
+ */
+ int test_type;
+
+ void *arg1;
+ void *arg2;
+
+};
+
+
+/* 
+   A computational node.
+   A tree of these nodes forms the expression.
+   Sequences of AND/OR operations form branches, brackets spawn new branches,
+   NOT inverts node's test resp. subtree result.
+*/
+struct ExprnodE {
+
+ struct ExprnodE *up;
+
+ char origin[8];
+
+  /* Operators */
+ int invert;  /* 0=normal  1=invert own result (subtree or test, but not op) */ 
+
+ int assoc; /*
+                0= left : compute own value, combine with left value,
+                          compute right value, combine with current value
+                1= right: compute own value, compute right value, 
+                          combine own and right, combine with left value
+             */
+
+ int use_shortcuts; /* 0= evaluate all tests of -and and -or,
+                       1= evaluate only until the combined result is known
+                     */
+
+ struct ExprnodE *left;
+ int left_op; /* 0=OR , 1=AND */
+  
+ struct ExprnodE *right;
+ int right_op; /* see left_op */
+
+ /* Brackets : a pointer to the first node in a subchain */ 
+ struct ExprnodE *sub; 
+
+ int is_if_then_else;
+ struct ExprnodE *true_branch;
+ struct ExprnodE *false_branch;
+
+ /* elementary test : if sub!=NULL , test is ignored */
+ struct ExprtesT *test;
+
+ /* Result */
+ int own_value;
+ int composed_value;
+
+};
+
+
+struct FindjoB {
+
+ char *start_path;
+
+ struct ExprnodE *test_tree;
+
+ struct ExprnodE *cursor;
+ int invert;  /* 0=normal  1=set invert-property for next new test node */
+ int use_shortcuts;
+
+ /* 0= echo
+    1= rm (also rmdir)
+    2= rm_r
+>>> 3= mv target
+    4= chown user
+    5= chgrp group
+    6= chmod mode_and mode_or
+    7= alter_date type date
+    8= lsdl
+    9= chown_r user
+   10= chgrp_r group
+   11= chmod_r mode_and mode_or
+   12= alter_date_r type date
+   13= find
+   14= compare disk_equivalent_of_start_path
+   15= in_iso iso_rr_equivalent_of_start_path
+   16= not_in_iso iso_rr_equiv
+   17= update disk_equiv
+   18= add_missing iso_rr_equiv
+   19= empty_iso_dir iso_rr_equiv
+   20= is_full_in_iso iso_rr_equiv
+   21= report_damage
+   22= report_lba
+   23= internal: memorize path of last matching node in found_path
+   24= getfacl
+   25= setfacl access_acl default_acl
+   26= getfattr
+   27= setfattr
+   28= set_filter name
+   29= show_stream
+   30= internal: count by xorriso->node_counter
+   31= internal: register in xorriso->node_array
+   32= internal: widen_hardlinks disk_equiv: update nodes marked in di_do_widen
+   33= get_any_xattr
+   34= get_md5
+   35= check_md5
+   36= make_md5
+   37= mkisofs_r
+   38= sort_weight number
+   39= hide on|iso_rr|joliet|off
+   40= estimate_size
+   41= update_merge disk_equiv
+   42= rm_merge
+   43= clear_merge
+   44= list_extattr
+   45= set_hfs_crtp creator type
+   46= get_hfs_crtp
+   47= set_hfs_bless blessing
+   48= get_hfs_bless
+   49= internal: update creator, type, and blessings from persistent isofs.*
+ */
+ int action;
+ int prune;
+
+ /* action specific parameters */
+ char *target;
+ char *text_2;
+ uid_t user;
+ gid_t group;
+ mode_t mode_and, mode_or;
+ int type; /* see Xorriso_set_time flag, also used as weight */
+ time_t date;
+ char *found_path;
+ off_t estim_upper_size;
+ off_t estim_lower_size;
+ struct FindjoB *subjob;
+
+ /* Errors */
+ char errmsg[4096];
+ int errn; /*
+             >0 = UNIX errno
+             -1 = close_bracket: no bracket open 
+             -2 = binary operator or closing bracket expected
+             -3 = unexpected binary operator or closing bracket
+             -4 = unsupported command
+             -5 = -then -elseif -else -endif without -if or at wrong place
+           */
+
+ /* Counts the test matches */
+ unsigned long match_count;
+
+};
+
+
+int Exprnode_destroy(struct ExprnodE **fnode, int flag);
+
+int Exprnode_tree_value(struct XorrisO *xorriso, struct ExprnodE *fnode,
+                        int left_value, void *node, char *name, char *path,
+                        struct stat *boss_stbuf, struct stat *stbuf, int flag);
+
+
+int Findjob_new(struct FindjoB **o, char *start_path, int flag);
+
+int Findjob_destroy(struct FindjoB **o, int flag);
+
+int Findjob_set_start_path(struct FindjoB *o, char *start_path, int flag);
+
+int Findjob_get_start_path(struct FindjoB *o, char **start_path, int flag);
+
+int Findjob_set_commit_filter_2(struct FindjoB *o, int flag);
+
+int Findjob_set_lba_range(struct FindjoB *o, int start_lba, int count, 
+                          int flag);
+
+int Findjob_set_wanted_node(struct FindjoB *o, void *wanted_node, int flag);
+
+/* @param value -1= only undamaged files, 1= only damaged files
+*/
+int Findjob_set_damage_filter(struct FindjoB *o, int value, int flag);
+
+int Findjob_set_test_hidden(struct FindjoB *o, int mode, int flag);
+
+int Findjob_set_crtp_filter(struct FindjoB *o, char *creator, char *hfs_type,
+                            int flag);
+
+int Findjob_set_bless_filter(struct XorrisO *xorriso, struct FindjoB *o,
+                             char *blessing, int flag);
+
+
+int Findjob_set_decision(struct FindjoB *o, char *decision, int flag);
+
+int Findjob_open_bracket(struct FindjoB *job, int flag);
+
+int Findjob_close_bracket(struct FindjoB *job, int flag);
+
+int Findjob_not(struct FindjoB *job, int flag);
+
+int Findjob_and(struct FindjoB *job, int flag);
+
+int Findjob_or(struct FindjoB *job, int flag);
+
+int Findjob_if(struct FindjoB *job, int flag);
+
+int Findjob_then(struct FindjoB *job, int flag);
+
+int Findjob_else(struct FindjoB *job, int flag);
+
+int Findjob_elseif(struct FindjoB *job, int flag);
+
+int Findjob_endif(struct FindjoB *job, int flag);
+
+int Findjob_test_2(struct XorrisO *xorriso, struct FindjoB *o, 
+                   void *node, char *name, char *path,
+                   struct stat *boss_stbuf, struct stat *stbuf, int flag);
+
+int Findjob_set_action_found_path(struct FindjoB *o, int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_target(struct FindjoB *o, int action, char *target,
+                              int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_ad(struct FindjoB *o, int type, time_t date, int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_chgrp(struct FindjoB *o, gid_t group, int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_chmod(struct FindjoB *o,
+                             mode_t mode_and, mode_t mode_or, int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_chown(struct FindjoB *o, uid_t user,int flag);
+
+/* @param flag bit0= -wholename rather than -name
+*/
+int Findjob_set_name_expr(struct FindjoB *o, char *name_expr, int flag);
+
+int Findjob_set_file_type(struct FindjoB *o, char file_type, int flag);
+
+/* @param value -1= files without ACL, 1= only files with ACL
+*/
+int Findjob_set_acl_filter(struct FindjoB *o, int value, int flag);
+
+/* @param value -1= files without xattr, 1= only files with xattr
+   @param flag bit0=-has_any_xattr rather than -has_xattr
+*/
+int Findjob_set_xattr_filter(struct FindjoB *o, int value, int flag);
+
+/* @param value -1= files without aaip, 1= only files with aaip
+*/
+int Findjob_set_aaip_filter(struct FindjoB *o, int value, int flag);
+
+/* @param value -1= files without filter, 1= files with filter
+*/
+int Findjob_set_filter_filter(struct FindjoB *o, int value, int flag);
+
+/* @param value -1= only without property, 1= only with property
+   @param flag bit0= pseudo-test:
+                     if no operator is open, do nothing and return 2
+*/
+int Findjob_set_prop_filter(struct FindjoB *o, int test_type, int value,
+                            int flag);
+
+/* @param value -1= true, 1= false
+   @param flag bit0= pseudo-test:
+                     if no operator is open, do nothing and return 2
+*/
+int Findjob_set_false(struct FindjoB *o, int value, int flag);
+
+int Findjob_set_prune(struct FindjoB *o, int flag);
+
+
+int Findjob_set_action_subjob(struct FindjoB *o, int action,
+                              struct FindjoB *subjob, int flag);
+
+int Findjob_set_action_text_2(struct FindjoB *o, int action, char *target,
+                              char* text_2, int flag);
+
+int Findjob_set_action_type(struct FindjoB *o, int action, int type, int flag);
+
+
+int Findjob_get_action(struct FindjoB *o, int flag);
+
+int Findjob_get_action_parms(struct FindjoB *o, char **target, char **text_2,
+                             uid_t *user, gid_t *group,
+                             mode_t *mode_and, mode_t *mode_or,
+                             int *type, time_t *date, struct FindjoB **subjob,
+                             int flag);
+
+int Findjob_set_found_path(struct FindjoB *o, char *path, int flag);
+
+int Findjob_get_found_path(struct FindjoB *o, char **path, int flag);
+
+#else /* Xorriso_findjob_on_expR */
+
+
+struct FindjoB;
+
+
+int Findjob_new(struct FindjoB **o, char *start_path, int flag);
+
+int Findjob_destroy(struct FindjoB **job, int flag);
+
+
+/* @return 0=no match , 1=match , <0 = error
+*/
+int Findjob_test(struct FindjoB *job, char *name, 
+                 struct stat *boss_stbuf, struct stat *stbuf,
+                 int depth, int flag);
+
+/* @return <0 error, >=0 see xorriso.c struct FindjoB.action
+*/
+int Findjob_get_action(struct FindjoB *o, int flag);
+
+/* @return <0 error, >=0 see xorriso.c struct FindjoB.action
+*/ 
+int Findjob_get_action_parms(struct FindjoB *o, char **target, char **text_2,
+                             uid_t *user, gid_t *group,
+                             mode_t *mode_and, mode_t *mode_or,
+                             int *type, time_t *date, struct FindjoB **subjob,
+                             int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_target(struct FindjoB *o, int action, char *target,
+                              int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_chgrp(struct FindjoB *o, gid_t group, int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_chmod(struct FindjoB *o,
+                             mode_t mode_and, mode_t mode_or, int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_ad(struct FindjoB *o, int type, time_t date, int flag);
+
+int Findjob_set_start_path(struct FindjoB *o, char *start_path, int flag);
+
+int Findjob_set_action_found_path(struct FindjoB *o, int flag);
+
+int Findjob_get_start_path(struct FindjoB *o, char **start_path, int flag);
+
+int Findjob_set_lba_range(struct FindjoB *o, int start_lba, int count,
+                          int flag);
+
+int Findjob_get_lba_damage_filter(struct FindjoB *o, int *start_lba,
+                                  int *end_lba, int *damage_filter, int flag);
+
+int Findjob_get_commit_filter(struct FindjoB *o, int *commit_filter, int flag);
+
+int Findjob_get_acl_filter(struct FindjoB *o, int *acl_filter, int flag);
+
+int Findjob_get_xattr_filter(struct FindjoB *o, int *xattr_filter, int flag);
+
+int Findjob_get_aaip_filter(struct FindjoB *o, int *aaip_filter, int flag);
+
+int Findjob_get_filter_filter(struct FindjoB *o, int *value, int flag);
+
+int Findjob_set_wanted_node(struct FindjoB *o, void *wanted_node, int flag);
+
+int Findjob_get_wanted_node(struct FindjoB *o, void **wanted_node, int flag);
+
+int Findjob_set_found_path(struct FindjoB *o, char *path, int flag);
+
+int Findjob_get_found_path(struct FindjoB *o, char **path, int flag);
+
+#endif /* ! Xorriso_findjob_on_expR */
+
+
+#endif /* ! Xorriso_pvt_findjob_includeD */
+
--- a/xorriso/iso_img.c
+++ b/xorriso/iso_img.c
--- a/xorriso/iso_img.h
+++ b/xorriso/iso_img.h
@ -0,0 +1,44 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which operate on ISO images
+   and their global properties.
+*/
+
+
+#ifndef Xorriso_pvt_iso_img_includeD
+#define Xorriso_pvt_iso_img_includeD yes
+
+
+int Xorriso_update_volid(struct XorrisO *xorriso, int flag);
+
+int Xorriso_record_boot_info(struct XorrisO *xorriso, int flag);
+
+int Xorriso_assert_volid(struct XorrisO *xorriso, int msc1, int flag);
+
+int Xorriso_is_isohybrid(struct XorrisO *xorriso, IsoFile *bootimg_node,
+                         int flag);
+
+int Xorriso_boot_item_status(struct XorrisO *xorriso, char *cat_path,
+                             char *bin_path, int platform_id,
+                             int patch_isolinux, int emul, off_t load_size,
+                             unsigned char *id_string,
+                             unsigned char *selection_crit, char *form,
+                             char *filter, FILE *fp, int flag);
+
+int Xorriso__append_boot_params(char *line, ElToritoBootImage *bootimg,
+                                int flag);
+
+int Xorriso_get_volume(struct XorrisO *xorriso, IsoImage **volume,
+                       int flag);
+
+
+
+
+
+#endif /* ! Xorriso_pvt_iso_img_includeD */
+
--- a/xorriso/iso_manip.c
+++ b/xorriso/iso_manip.c
--- a/xorriso/iso_manip.h
+++ b/xorriso/iso_manip.h
@ -0,0 +1,77 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which manipulate the
+   libisofs tree model.
+*/
+
+
+#ifndef Xorriso_pvt_iso_manip_includeD
+#define Xorriso_pvt_iso_manip_includeD yes
+
+
+int Xorriso_transfer_properties(struct XorrisO *xorriso, struct stat *stbuf,
+                               char *disk_path,  IsoNode *node, int flag);
+
+int Xorriso_graft_split(struct XorrisO *xorriso, IsoImage *volume,
+                        IsoDir *dir, char *disk_path, char *img_name,
+                        char *nominal_source, char *nominal_target,
+                        off_t size, IsoNode **node, int flag);
+
+int Xorriso_tree_graft_node(struct XorrisO *xorriso, IsoImage *volume,
+                            IsoDir *dir, char *disk_path, char *img_name,
+                            char *nominal_source, char *nominal_target,
+                            off_t offset, off_t cut_size,
+                            IsoNode **node, int flag);
+
+int Xorriso_add_tree(struct XorrisO *xorriso, IsoDir *dir,
+                     char *img_dir_path, char *disk_dir_path,
+                     struct LinkiteM *link_stack, int flag);
+
+int Xorriso_copy_implicit_properties(struct XorrisO *xorriso, IsoDir *dir,
+          char *full_img_path, char *img_path, char *full_disk_path, int flag);
+
+int Xorriso_mkisofs_lower_r(struct XorrisO *xorriso, IsoNode *node, int flag);
+
+int Xorriso_widen_hardlink(struct XorrisO *xorriso, void * boss_iter,
+                           IsoNode *node,
+                           char *abs_path, char *iso_prefix, char *disk_prefix,
+                           int flag);
+
+
+int Xorriso_cannot_create_iter(struct XorrisO *xorriso, int iso_error,
+                               int flag);
+
+int Xorriso_findi_iter(struct XorrisO *xorriso, IsoDir *dir_node, off_t *mem,
+                       IsoDirIter **iter,
+                       IsoNode ***node_array, int *node_count, int *node_idx,
+                       IsoNode **iterated_node, int flag);
+
+int Xorriso_findi_action(struct XorrisO *xorriso, struct FindjoB *job,
+                         IsoDirIter *boss_iter, off_t boss_mem,
+                         char *abs_path, char *show_path,
+                         IsoNode *node, int depth, int flag);
+
+int Xorriso_findi_headline(struct XorrisO *xorriso, struct FindjoB *job,
+                           int flag);
+
+int Xorriso_findi_sorted(struct XorrisO *xorriso, struct FindjoB *job,
+                         off_t boss_mem, int filec, char **filev, int flag);
+
+int Xorriso_all_node_array(struct XorrisO *xorriso, int addon_nodes, int flag);
+
+
+int Xorriso__file_start_lba(IsoNode *node, int *lba, int flag);
+
+int Xorriso__mark_update_xinfo(void *data, int flag);
+int Xorriso__mark_update_cloner(void *old_data, void **new_data, int flag);
+
+int Xorriso_get_blessing(struct XorrisO *xorriso, IsoNode *node,
+                         int *bless_idx, char bless_code[17], int flag);
+
+#endif /* ! Xorriso_pvt_iso_manip_includeD */
+
--- a/xorriso/iso_tree.c
+++ b/xorriso/iso_tree.c
--- a/xorriso/iso_tree.h
+++ b/xorriso/iso_tree.h
@ -0,0 +1,97 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2011 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which access nodes of the
+   libisofs tree model.
+*/
+
+
+#ifndef Xorriso_pvt_iso_tree_includeD
+#define Xorriso_pvt_iso_tree_includeD yes
+
+
+#define LIBISO_ISDIR(node) (iso_node_get_type(node) == LIBISO_DIR)
+#define LIBISO_ISREG(node) (iso_node_get_type(node) == LIBISO_FILE)
+#define LIBISO_ISLNK(node) (iso_node_get_type(node) == LIBISO_SYMLINK)
+#define LIBISO_ISCHR(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
+                            S_ISCHR(iso_node_get_mode(node)))
+#define LIBISO_ISBLK(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
+                            S_ISBLK(iso_node_get_mode(node)))
+#define LIBISO_ISFIFO(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
+                             S_ISFIFO(iso_node_get_mode(node)))
+#define LIBISO_ISSOCK(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \
+                             S_ISSOCK(iso_node_get_mode(node)))
+#define LIBISO_ISBOOT(node) (iso_node_get_type(node) == LIBISO_BOOT)
+
+
+int Xorriso_node_from_path(struct XorrisO *xorriso, IsoImage *volume,
+                           char *path, IsoNode **node, int flag);
+
+int Xorriso_get_node_by_path(struct XorrisO *xorriso,
+                             char *in_path, char *eff_path,
+                             IsoNode **node, int flag);
+
+int Xorriso_dir_from_path(struct XorrisO *xorriso, char *purpose,
+                          char *path, IsoDir **dir_node, int flag);
+
+int Xorriso_node_get_dev(struct XorrisO *xorriso, IsoNode *node,
+                         char *path, dev_t *dev, int flag);
+
+int Xorriso_fake_stbuf(struct XorrisO *xorriso, char *path, struct stat *stbuf,
+                       IsoNode **node, int flag);
+
+int Xorriso_node_is_valid(struct XorrisO *xorriso, IsoNode *in_node, int flag);
+
+int Xorriso_path_from_node(struct XorrisO *xorriso, IsoNode *in_node,
+                           char path[SfileadrL], int flag);
+
+int Xorriso_path_from_lba(struct XorrisO *xorriso, IsoNode *node, int lba,
+                          char path[SfileadrL], int flag);
+
+int Xorriso_get_attr_value(struct XorrisO *xorriso, void *in_node, char *path,
+                     char *name, size_t *value_length, char **value, int flag);
+
+int Xorriso_stream_type(struct XorrisO *xorriso, IsoNode *node,
+                        IsoStream *stream, char type_text[], int flag);
+
+
+int Xorriso_show_du_subs(struct XorrisO *xorriso, IsoDir *dir_node,
+                      char *abs_path, char *rel_path, off_t *size,
+                      off_t boss_mem, int flag);
+
+int Xorriso_sorted_dir_i(struct XorrisO *xorriso, IsoDir *dir_node,
+                         int *filec, char ***filev, off_t boss_mem, int flag);
+
+int Xorriso_obtain_pattern_files_i(
+       struct XorrisO *xorriso, char *wd, IsoDir *dir,
+       int *filec, char **filev, int count_limit, off_t *mem,
+       int *dive_count, int flag);
+
+int Xorriso__start_end_lbas(IsoNode *node,
+                            int *lba_count, int **start_lbas, int **end_lbas,
+                            off_t *size, int flag);
+
+int Xorriso__file_start_lba(IsoNode *node,
+                           int *lba, int flag);
+
+int Xorriso_file_eval_damage(struct XorrisO *xorriso, IsoNode *node,
+                             off_t *damage_start, off_t *damage_end,
+                             int flag);
+
+int Xorriso_report_lba(struct XorrisO *xorriso, char *show_path,
+                       IsoNode *node, int flag);
+
+int Xorriso_report_damage(struct XorrisO *xorriso, char *show_path,
+                          IsoNode *node, int flag);
+
+int Xorriso_getfname(struct XorrisO *xorriso, char *path, int flag);
+
+int Xorriso_retrieve_disk_path(struct XorrisO *xorriso, IsoNode *node,
+                               char disk_path[SfileadrL], int flag);
+
+#endif /* ! Xorriso_pvt_iso_tree_includeD */
+
--- a/xorriso/lib_mgt.c
+++ b/xorriso/lib_mgt.c
@ -0,0 +1,963 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2011 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains functions which manage the relation between xorriso
+   and the libraries: libburn, libisofs, libisoburn.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <time.h>
+#include <errno.h>
+#include <pthread.h>
+
+#ifdef HAVE_STDINT_H
+#include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+
+/* for -charset */
+#include <iconv.h>
+#include <langinfo.h>
+
+#ifdef Xorriso_standalonE
+
+#ifdef Xorriso_with_libjtE
+#include "../libjte/libjte.h"
+#endif
+
+#else
+
+#ifdef Xorriso_with_libjtE
+#include <libjte/libjte.h>
+#endif
+
+#endif /* ! Xorriso_standalonE */
+
+#include "xorriso.h" 
+#include "xorriso_private.h"
+#include "xorrisoburn.h"
+
+#include "lib_mgt.h"
+#include "iso_manip.h"
+
+
+int Xorriso_abort(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+
+ ret= burn_abort(4440, burn_abort_pacifier, "xorriso : ");
+ if(ret<=0) {
+   fprintf(stderr,
+       "\nxorriso : ABORT : Cannot cancel burn session and release drive.\n");
+   return(0);
+ } 
+ fprintf(stderr,
+   "xorriso : ABORT : Drive is released and library is shut down now.\n");
+ fprintf(stderr,
+   "xorriso : ABORT : Program done. Even if you do not see a shell prompt.\n");
+ fprintf(stderr, "\n");
+ exit(1);
+}
+
+
+/* @param flag bit0= asynchronous handling (else catch thread, wait, and exit)
+               bit1= dealing with MMC drive in critical state
+                     behavior 2 -> behavior 1
+*/
+int Xorriso_set_signal_handling(struct XorrisO *xorriso, int flag)
+{
+ char *handler_prefix= NULL;
+ int behavior, mode;
+
+ behavior= Xorriso__get_signal_behavior(0);
+ if(behavior == 0)
+   return(2);
+ if(behavior == 2 && !(flag & 2))
+   mode= 1;
+ else if(behavior == 3)
+   mode= 2;
+ else
+   mode= (flag & 1) * 0x30;
+ handler_prefix= calloc(strlen(xorriso->progname)+3+1, 1);
+ if(handler_prefix==NULL) {
+   sprintf(xorriso->info_text,
+           "Cannot allocate memory for setting signal handler");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+
+ /* <<< */
+ sprintf(xorriso->info_text, "burn_set_signal_handling(%d)", mode);
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
+
+ sprintf(handler_prefix, "%s : ", xorriso->progname);
+ burn_set_signal_handling(handler_prefix, NULL, mode);
+ free(handler_prefix);
+ return(1);
+}
+
+
+int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag)
+{
+ int ret, major, minor, micro;
+ char *queue_sev, *print_sev, reason[1024];
+ struct iso_zisofs_ctrl zisofs_ctrl= {0, 6, 15};
+
+
+/* First an ugly compile time check for header version compatibility.
+   If everthing matches, then no C code is produced. In case of mismatch,
+   intentionally faulty C code will be inserted.
+*/
+
+/* The minimum requirement of xorriso towards the libisoburn header
+   at compile time is defined in xorriso/xorrisoburn.h 
+     xorriso_libisoburn_req_major
+     xorriso_libisoburn_req_minor
+     xorriso_libisoburn_req_micro
+   It gets compared against the version macros in libburn/libburn.h :
+     isoburn_header_version_major
+     isoburn_header_version_minor
+     isoburn_header_version_micro
+   If the header is too old then the following code shall cause failure of
+   cdrskin compilation rather than to allow production of a program with
+   unpredictable bugs or memory corruption.
+   The compiler messages supposed to appear in this case are:
+      error: 'LIBISOBURN_MISCONFIGURATION' undeclared (first use in this function)
+      error: 'INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisoburn_dot_h_TOO_OLD__SEE_xorrisoburn_dot_c' undeclared (first use in this function)
+      error: 'LIBISOBURN_MISCONFIGURATION_' undeclared (first use in this function)
+*/
+/* The indendation is an advise of man gcc to help old compilers ignoring */
+ #if xorriso_libisoburn_req_major > isoburn_header_version_major
+ #define Isoburn_libisoburn_dot_h_too_olD 1
+ #endif
+ #if xorriso_libisoburn_req_major == isoburn_header_version_major && xorriso_libisoburn_req_minor > isoburn_header_version_minor
+ #define Isoburn_libisoburn_dot_h_too_olD 1
+ #endif
+ #if xorriso_libisoburn_req_minor == isoburn_header_version_minor && xorriso_libisoburn_req_micro > isoburn_header_version_micro
+ #define Isoburn_libisoburn_dot_h_too_olD 1
+ #endif
+
+#ifdef Isoburn_libisoburn_dot_h_too_olD
+LIBISOBURN_MISCONFIGURATION = 0;
+INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisoburn_dot_h_TOO_OLD__SEE_xorrisoburn_dot_c = 0;
+LIBISOBURN_MISCONFIGURATION_ = 0;
+#endif
+
+/* End of ugly compile time test (scroll up for explanation) */
+
+ reason[0]= 0;
+ ret= isoburn_initialize(reason, 0);
+ if(ret==0) {
+   sprintf(xorriso->info_text, "Cannot initialize libraries");
+   if(reason[0])
+     sprintf(xorriso->info_text+strlen(xorriso->info_text),
+             ". Reason given:\n%s", reason);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(0);
+ }
+ ret= isoburn_is_compatible(isoburn_header_version_major,
+                            isoburn_header_version_minor,
+                            isoburn_header_version_micro, 0);
+ if(ret<=0) {
+   isoburn_version(&major, &minor, &micro);
+   sprintf(xorriso->info_text,
+          "libisoburn version too old: %d.%d.%d . Need at least: %d.%d.%d .\n",
+          major, minor, micro,
+          isoburn_header_version_major, isoburn_header_version_minor,
+          isoburn_header_version_micro);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+
+ xorriso->libs_are_started= 1;
+
+ queue_sev= "ALL";
+ if(xorriso->library_msg_direct_print) {
+
+   /* >>> need option for controlling this in XorrisO.
+          See also Xorriso_msgs_submit */;
+
+   print_sev= xorriso->report_about_text;
+ } else
+   print_sev= "NEVER";
+
+ iso_set_msgs_severities(queue_sev, print_sev, "libsofs : ");
+ burn_msgs_set_severities(queue_sev, print_sev, "libburn : ");
+
+ /* ??? >>> do we want united queues ? */
+ /* burn_set_messenger(iso_get_messenger()); */
+
+ isoburn_set_msgs_submit(Xorriso_msgs_submit_void, (void *) xorriso,
+                         (3<<2) | 128 , 0);
+
+ ret= Xorriso_set_signal_handling(xorriso, 0);
+ if(ret <= 0)
+   return(ret);
+
+ ret = iso_zisofs_get_params(&zisofs_ctrl, 0);
+ if (ret == 1) {
+   xorriso->zisofs_block_size= xorriso->zisofs_block_size_default=
+       (1 << zisofs_ctrl.block_size_log2);
+   xorriso->zlib_level= xorriso->zlib_level_default=
+       zisofs_ctrl.compression_level;
+ }
+
+ iso_node_xinfo_make_clonable(Xorriso__mark_update_xinfo,
+                              Xorriso__mark_update_cloner, 0);
+
+ /* Second initialization. This time with libs. */
+ Xorriso_preparer_string(xorriso, xorriso->preparer_id, 0);
+
+ Xorriso_process_msg_queues(xorriso,0);
+ if(reason[0]) {
+   sprintf(xorriso->info_text, "%s", reason);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
+ }
+ strcpy(xorriso->info_text, "Using ");
+ strncat(xorriso->info_text, burn_scsi_transport_id(0), 1024);
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
+ return(1);
+}
+
+
+/* @param flag bit0= global shutdown of libraries */
+int Xorriso_detach_libraries(struct XorrisO *xorriso, int flag)
+{
+ Xorriso_give_up_drive(xorriso, 3);
+ if(xorriso->in_volset_handle!=NULL) { /* standalone image */
+   iso_image_unref((IsoImage *) xorriso->in_volset_handle);
+   xorriso->in_volset_handle= NULL;
+   Sectorbitmap_destroy(&(xorriso->in_sector_map), 0);
+   Xorriso_destroy_di_array(xorriso, 0);
+   Xorriso_destroy_hln_array(xorriso, 0);
+   xorriso->boot_count= 0;
+ }
+ if(flag&1) {
+   if(xorriso->libs_are_started==0)
+     return(0);
+   isoburn_finish();
+ }
+ return(1);
+}
+
+
+/* @param flag bit0= suppress messages below UPDATE
+               bit1= suppress messages below FAILURE
+*/
+int Xorriso_set_image_severities(struct XorrisO *xorriso, int flag)
+{
+ char *queue_sev, *print_sev;
+
+ if(flag&2)
+   queue_sev= "FAILURE";
+ else if(flag&1)
+   queue_sev= "UPDATE";
+ else
+   queue_sev= "ALL";
+ if(xorriso->library_msg_direct_print)
+   print_sev= xorriso->report_about_text;
+ else
+   print_sev= "NEVER";
+ iso_set_msgs_severities(queue_sev, print_sev, "libisofs : ");
+ return(1);
+}
+
+
+/* @param flag bit0=prepare for a burn run */
+int Xorriso_set_abort_severity(struct XorrisO *xorriso, int flag)
+{
+ int ret, abort_on_number;
+ char *sev_text;
+ static int note_number= -1, failure_number= -1;
+
+ if(note_number==-1)
+   Xorriso__text_to_sev("NOTE", &note_number, 0);
+ if(failure_number==-1)
+   Xorriso__text_to_sev("FAILURE", &failure_number, 0);
+ sev_text= xorriso->abort_on_text;
+ ret= Xorriso__text_to_sev(xorriso->abort_on_text, &abort_on_number, 0);
+ if(ret<=0)
+   return(ret);
+ if(abort_on_number<note_number)
+   sev_text= "NOTE";
+ else if(abort_on_number>failure_number)
+   sev_text= "FAILURE";
+ ret= iso_set_abort_severity(sev_text);
+ return(ret>=0);
+}
+
+
+int Xorriso_report_lib_versions(struct XorrisO *xorriso, int flag)
+{
+ int major, minor, micro;
+ int req_major, req_minor, req_micro;
+
+ iso_lib_version(&major, &minor, &micro);
+ isoburn_libisofs_req(&req_major, &req_minor, &req_micro);
+ sprintf(xorriso->result_line,
+         "libisofs   in use :  %d.%d.%d  (min. %d.%d.%d)\n",
+         major, minor, micro, req_major, req_minor, req_micro);
+ Xorriso_result(xorriso, 0);
+
+#ifdef Xorriso_with_libjtE
+ libjte__version(&major, &minor, &micro);
+ isoburn_libjte_req(&req_major, &req_minor, &req_micro);
+ sprintf(xorriso->result_line,
+         "libjte     in use :  %d.%d.%d  (min. %d.%d.%d)\n",
+         major, minor, micro, req_major, req_minor, req_micro);
+ Xorriso_result(xorriso, 0);
+#endif
+
+ burn_version(&major, &minor, &micro);
+ isoburn_libburn_req(&req_major, &req_minor, &req_micro);
+ sprintf(xorriso->result_line,
+         "libburn    in use :  %d.%d.%d  (min. %d.%d.%d)\n",
+         major, minor, micro, req_major, req_minor, req_micro);
+ Xorriso_result(xorriso, 0);
+ strcpy(xorriso->result_line, "libburn OS adapter:  ");
+ strncat(xorriso->result_line, burn_scsi_transport_id(0), 1024);
+ strcat(xorriso->result_line, "\n");
+ Xorriso_result(xorriso, 0);
+ isoburn_version(&major, &minor, &micro);
+ sprintf(xorriso->result_line,
+         "libisoburn in use :  %d.%d.%d  (min. %d.%d.%d)\n",
+         major, minor, micro,
+         isoburn_header_version_major, isoburn_header_version_minor,
+         isoburn_header_version_micro);
+ Xorriso_result(xorriso, 0);
+ return(1);
+}
+
+
+int Xorriso__sev_to_text(int severity, char **severity_name,
+                         int flag)
+{
+ int ret;
+
+ ret= iso_sev_to_text(severity, severity_name);
+ if(ret>0)
+   return(ret);
+ ret= burn_sev_to_text(severity, severity_name, 0);
+ if(ret>0)
+   return(ret);
+ *severity_name= "";
+ return(0);
+}
+
+
+int Xorriso__text_to_sev(char *severity_name, int *severity_number, int flag)
+{
+ int ret= 1;
+ char severity[20];
+
+ Xorriso__to_upper(severity_name, severity, (int) sizeof(severity), 0);
+ ret= iso_text_to_sev(severity, severity_number);
+ if(ret>0)
+   return(ret);
+ ret= burn_text_to_sev(severity, severity_number, 0);
+ return(ret);
+}
+
+
+int Xorriso__severity_cmp(char *sev1, char *sev2)
+{
+ int s1= 0x7fffffff, s2= 0x7fffffff, ret;
+ char *default_sev= "FATAL";
+
+ ret= Xorriso__text_to_sev(sev1, &s1, 0);
+ if(ret <= 0)
+   Xorriso__text_to_sev(default_sev, &s1, 0);
+ ret= Xorriso__text_to_sev(sev2, &s2, 0);
+ if(ret <= 0)
+   Xorriso__text_to_sev(default_sev, &s2, 0);
+ if(s1 < s2)
+   return -1;
+ if(s1 > s2)
+   return(1);
+ return(0);
+}
+
+
+char *Xorriso__severity_list(int flag)
+{
+ return(burn_list_sev_texts(0));
+}
+
+
+/* @param flag bit0= report libisofs error text
+               bit1= victim is disk_path
+               bit2= do not inquire libisofs, report msg_text and min_severity
+*/
+int Xorriso_report_iso_error(struct XorrisO *xorriso, char *victim,
+                        int iso_error_code, char msg_text[], int os_errno,
+                        char min_severity[], int flag)
+{
+ int error_code, iso_sev, min_sev, ret;
+ char *sev_text_pt, *msg_text_pt= NULL;
+ char *sfe= NULL;
+ static int sorry_sev= -1;
+
+ Xorriso_alloc_meM(sfe, char, 6 * SfileadrL);
+
+ if(sorry_sev<0)
+   Xorriso__text_to_sev("SORRY", &sorry_sev, 0);
+
+ if(flag&4) {
+   error_code= 0x00050000;
+   Xorriso__text_to_sev(min_severity, &iso_sev, 0);
+ } else {
+   error_code= iso_error_get_code(iso_error_code);
+   if(error_code < 0x00030000 || error_code >= 0x00040000)
+     error_code= (error_code & 0xffff) | 0x00050000;
+   if(flag&1)
+     msg_text_pt= (char *) iso_error_to_msg(iso_error_code);
+   iso_sev= iso_error_get_severity(iso_error_code);
+ }
+ if(msg_text_pt==NULL)
+   msg_text_pt= msg_text;
+
+ if(iso_sev >= sorry_sev && (flag & 2) && victim[0])
+   Xorriso_msgs_submit(xorriso, 0, victim, 0, "ERRFILE", 0);
+ sev_text_pt= min_severity;
+ Xorriso__text_to_sev(min_severity, &min_sev, 0);
+ if(min_sev < iso_sev && !(flag&4))
+   Xorriso__sev_to_text(iso_sev, &sev_text_pt, 0);
+ strcpy(sfe, msg_text_pt);
+ if(victim[0]) {
+   strcat(sfe, ": ");
+   Text_shellsafe(victim, sfe+strlen(sfe), 0);
+ }
+ ret= Xorriso_msgs_submit(xorriso, error_code, sfe, os_errno, sev_text_pt, 4);
+ex:;
+ Xorriso_free_meM(sfe);
+ return(ret);
+}
+
+
+int Xorriso_get_local_charset(struct XorrisO *xorriso, char **name, int flag)
+{
+ (*name)= iso_get_local_charset(0);
+ return(1);
+}
+
+
+int Xorriso_set_local_charset(struct XorrisO *xorriso, char *name, int flag)
+{
+ int ret;
+ char *nl_charset;
+ iconv_t iconv_ret= (iconv_t) -1;
+
+ nl_charset= nl_langinfo(CODESET);
+ if(name == NULL)
+   name= nl_charset;
+
+ if(name != NULL) {
+   iconv_ret= iconv_open(nl_charset, name);
+   if(iconv_ret == (iconv_t) -1)
+     goto cannot;
+   else
+     iconv_close(iconv_ret);
+ }
+ ret= iso_set_local_charset(name, 0);
+ if(ret <= 0) {
+cannot:;
+   sprintf(xorriso->info_text,
+           "-local_charset: Cannot assume as local character set: ");
+   Text_shellsafe(name, xorriso->info_text, 1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+   return(0);
+ }
+ sprintf(xorriso->info_text, "Local character set is now assumed as: ");
+ Text_shellsafe(name, xorriso->info_text, 1);
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+ return(1);
+}
+
+
+int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag)
+{
+ int ret, error_code= 0, os_errno= 0, count= 0, pass, imgid, tunneled;
+ int name_prefix_code;
+ char severity[80], *text= NULL;
+
+#ifdef Xorriso_fetch_with_msg_queueS
+ int locked= 0, uret;
+#endif
+
+#ifdef Xorriso_with_libjtE
+ char *msg;
+#endif
+
+ if(!xorriso->libs_are_started) {
+   ret= 1; goto ex;
+ }
+
+#ifdef Xorriso_fetch_with_msg_queueS
+
+ Xorriso_alloc_meM(text, char, sizeof(xorriso->info_text));
+
+ ret= pthread_mutex_lock(&(xorriso->lib_msg_queue_lock));
+ if(ret != 0) {
+   Xorriso_msgs_submit(xorriso, 0,
+              "Cannot aquire mutex lock for processing library message queues",
+               ret, "FATAL", 0);
+ } else
+   locked= 1;
+
+#else /* Xorriso_fetch_with_msg_queueS */
+
+ text= xorriso->info_text;
+
+#endif /* ! Xorriso_fetch_with_msg_queueS */
+
+
+ for(pass= 0; pass< 3; pass++) {
+   while(1) {
+     tunneled= 0;
+     if(pass==0) {
+       ret= 0;
+#ifdef Xorriso_with_libjtE
+       if(xorriso->libjte_handle != NULL) {
+         msg= libjte_get_next_message(xorriso->libjte_handle);
+         if(msg != NULL) {
+           sprintf(text, "%1.4095s", msg);
+           free(msg);
+           strcpy(severity, "NOTE");
+           error_code= 0;
+           os_errno= 0;
+           ret= 1;
+         }
+       }
+#endif /* Xorriso_with_libjtE */
+
+     } else if(pass==1)
+       ret= iso_obtain_msgs("ALL", &error_code, &imgid, text, severity);
+     else {
+       ret= burn_msgs_obtain("ALL", &error_code, text, &os_errno, severity);
+       if((error_code>=0x00030000 && error_code<0x00040000) ||
+          (error_code>=0x00050000 && error_code<0x00060000))
+         tunneled= -1; /* "libisofs:" */
+       else if(error_code>=0x00060000 && error_code<0x00070000)
+         tunneled= 1;  /* "libisoburn:" */
+     }
+     if(ret<=0)
+   break;
+
+     /* <<< tunneled MISHAP from libisoburn through libburn
+            or well known error codes of MISHAP events
+            With libburn-0.4.4 this is not necessary */
+     if(error_code==0x5ff73 || error_code==0x3ff73 ||
+        error_code==0x3feb9 || error_code==0x3feb2)
+       strcpy(severity, "MISHAP");
+     else if(error_code==0x51001)
+       strcpy(severity, "ERRFILE");
+
+     if(pass == 0)
+       name_prefix_code= 0;
+     else
+       name_prefix_code= pass + tunneled;
+     Xorriso_msgs_submit(xorriso, error_code, text, os_errno, 
+                         severity, name_prefix_code << 2);
+     count++;
+   }
+ }
+ if(xorriso->library_msg_direct_print && count>0) {
+   sprintf(text,"   (%d library messages repeated by xorriso)\n", count);
+
+#ifdef Xorriso_fetch_with_msg_queueS
+
+   Xorriso_msgs_submit(xorriso, 0, text, 0, "NOTE", 256);
+
+#else /* Xorriso_fetch_with_msg_queueS */
+
+   Xorriso_info(xorriso, 0);
+
+#endif /* Xorriso_fetch_with_msg_queueS */
+
+ }
+ ret= 1;
+ex:;
+
+#ifdef Xorriso_fetch_with_msg_queueS
+
+ if(locked) {
+   uret= pthread_mutex_unlock(&(xorriso->lib_msg_queue_lock));
+   if(uret != 0) {
+     Xorriso_msgs_submit(xorriso, 0,
+             "Cannot release mutex lock for processing library message queues",
+              uret, "FATAL", 0);
+     ret= -1;
+   }
+ }
+ Xorriso_free_meM(text);
+
+#endif /* Xorriso_fetch_with_msg_queueS */
+
+ return(ret);
+}
+
+
+int Xorriso_md5_start(struct XorrisO *xorriso, void **ctx, int flag)
+{
+ int ret;
+
+ ret= iso_md5_start(ctx);
+ if(ret == 1)
+   return(1);
+ Xorriso_no_malloc_memory(xorriso, NULL, 0);
+ return(-1);
+}
+
+
+int Xorriso_md5_compute(struct XorrisO *xorriso, void *ctx,
+                        char *data, int datalen, int flag)
+{
+ iso_md5_compute(ctx, data, datalen);
+ return(1);
+}
+
+
+int Xorriso_md5_end(struct XorrisO *xorriso, void **ctx, char md5[16],
+                    int flag)
+{
+ int ret;
+
+ ret= iso_md5_end(ctx, md5);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret <= 0)
+   return(0);
+ return(1);
+}
+
+
+/* @param flag  bit0= avoid library calls
+ */
+int Xorriso_preparer_string(struct XorrisO *xorriso, char xorriso_id[129],
+                            int flag)
+{
+ int major, minor, micro;
+
+ xorriso_id[0]= 0;
+ sprintf(xorriso_id, "XORRISO-%d.%d.%d ",
+         Xorriso_header_version_majoR, Xorriso_header_version_minoR,
+         Xorriso_header_version_micrO);
+ if(strlen(xorriso_id) + strlen(Xorriso_timestamP) < 128)
+   strcat(xorriso_id, Xorriso_timestamP);
+ if(flag & 1)
+   return(1);
+ isoburn_version(&major, &minor, &micro);
+ if(strlen(xorriso_id) < 100)
+   sprintf(xorriso_id + strlen(xorriso_id),
+           ", LIBISOBURN-%d.%d.%d", major, minor, micro);
+ iso_lib_version(&major, &minor, &micro);
+ if(strlen(xorriso_id) < 100)
+   sprintf(xorriso_id + strlen(xorriso_id),
+           ", LIBISOFS-%d.%d.%d", major, minor, micro);
+ burn_version(&major, &minor, &micro);
+ if(strlen(xorriso_id) < 100)
+   sprintf(xorriso_id + strlen(xorriso_id),
+           ", LIBBURN-%d.%d.%d", major, minor, micro);
+ return(1);
+}
+
+
+#ifdef Xorriso_with_libjtE
+
+int Xorriso_assert_jte_handle(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ 
+ if(xorriso->libjte_handle == NULL) {
+   ret= libjte_new(&(xorriso->libjte_handle), 0);
+   if(ret <= 0 || xorriso->libjte_handle == NULL) {
+     sprintf(xorriso->info_text,
+             "-jigdo: Failed to create libjte environment object"); 
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+     return(-1);
+   }
+   /* no stderr, no exit() */
+   libjte_set_error_behavior(xorriso->libjte_handle, 0, 0);
+ }
+ return(1);
+}
+
+#endif /* Xorriso_with_libjtE */
+
+
+int Xorriso_jigdo_interpreter(struct XorrisO *xorriso, char *aspect, char *arg,
+                         int flag)
+{
+
+#ifdef Xorriso_with_libjtE
+
+ int ret, num;
+ struct libjte_env *jte;
+ char *msg = NULL;
+
+ if(strcmp(aspect, "clear") == 0) {
+   if(xorriso->libjte_handle != NULL)
+   libjte_destroy(&(xorriso->libjte_handle));
+   Xorriso_lst_destroy_all(&(xorriso->jigdo_params), 0);
+   Xorriso_lst_destroy_all(&(xorriso->jigdo_values), 0);
+   xorriso->libjte_params_given= 0;
+   return(1);
+ }
+ ret= Xorriso_assert_jte_handle(xorriso, 0);
+ if(ret <= 0)
+   return(ret);
+ jte= xorriso->libjte_handle;
+
+ if(strcmp(aspect, "verbose") == 0) {
+   if(strcmp(arg, "on") == 0) {
+     libjte_set_verbose(jte, 1);
+     /* Direct libjte messages to stderr, rather than message list */
+     libjte_set_error_behavior(xorriso->libjte_handle, 1, 0);
+     xorriso->libjte_params_given|= 2;
+   } else if(strcmp(arg, "off") == 0) {
+     libjte_set_verbose(jte, 0);
+     libjte_set_error_behavior(xorriso->libjte_handle, 0, 0);
+     xorriso->libjte_params_given&= ~2;
+   } else
+     goto bad_arg;
+ } else if(strcmp(aspect, "template_path") == 0 ||
+           strcmp(aspect, "-jigdo-template") == 0) {
+   ret= libjte_set_template_path(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 4;
+ } else if(strcmp(aspect, "jigdo_path") == 0 ||
+           strcmp(aspect, "-jigdo-jigdo") == 0) {
+   ret= libjte_set_jigdo_path(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 8;
+ } else if(strcmp(aspect, "md5_path") == 0 ||
+           strcmp(aspect, "-md5-list") == 0) {
+   ret= libjte_set_md5_path(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 16;
+ } else if(strcmp(aspect, "min_size") == 0 ||
+           strcmp(aspect, "-jigdo-min-file-size") == 0) {
+   num= Scanf_io_size(arg, 0);
+   ret= libjte_set_min_size(jte, num);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 32;
+ } else if(strcmp(aspect, "checksum_iso") == 0 ||
+           strcmp(aspect, "-checksum_algorithm_iso") == 0) {
+   ret= libjte_set_checksum_iso(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 64;
+ } else if(strcmp(aspect, "checksum_template") == 0 ||
+           strcmp(aspect, "-checksum_algorithm_template") == 0) {
+   ret= libjte_set_checksum_template(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 128;
+ } else if(strcmp(aspect, "compression") == 0 ||
+           strcmp(aspect, "-jigdo-template-compress") == 0) {
+   ret= libjte_set_compression(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 256;
+ } else if(strcmp(aspect, "exclude") == 0 ||
+           strcmp(aspect, "-jigdo-exclude") == 0) {
+   ret= libjte_add_exclude(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 512;
+ } else if(strcmp(aspect, "demand_md5") == 0 ||
+           strcmp(aspect, "-jigdo-force-md5") == 0) {
+   ret= libjte_add_md5_demand(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 1024;
+ } else if(strcmp(aspect, "mapping") == 0 ||
+           strcmp(aspect, "-jigdo-map") == 0) {
+   ret= libjte_add_mapping(jte, arg);
+   if(ret <= 0)
+     goto jte_failed;
+   xorriso->libjte_params_given|= 2048;
+ } else {
+   sprintf(xorriso->info_text, "-jigdo: unknown aspect '%s'", aspect); 
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   return(0);
+ }
+
+ ret= Xorriso_lst_new(&(xorriso->jigdo_params), aspect, xorriso->jigdo_params,
+                      1);
+ if(ret > 0)
+   ret= Xorriso_lst_new(&(xorriso->jigdo_values), arg, xorriso->jigdo_values,
+                        1);
+ if(ret <= 0) {
+   Xorriso_no_malloc_memory(xorriso, NULL, 0);
+   return(-1);
+ }
+ Xorriso_process_msg_queues(xorriso, 0);
+ return(1);
+
+bad_arg:
+ sprintf(xorriso->info_text, "-jigdo %s : unknown argument '%s'", aspect, arg);
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+ return(0);
+
+jte_failed:
+ while(1) {
+   msg= libjte_get_next_message(xorriso->libjte_handle);
+   if(msg == NULL)
+ break;
+   sprintf(xorriso->info_text, "%1.4095s", msg);
+   free(msg);
+   msg= NULL;
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+ }
+ sprintf(xorriso->info_text, "Experienced libjte failure with: -jigdo %s %s",
+         aspect, arg);
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+ return(0);
+
+#else /* Xorriso_with_libjtE */
+
+ sprintf(xorriso->info_text,
+         "Jigdo Template Extraction was not enabled at compile time");
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+ return(0);
+
+#endif /* ! Xorriso_with_libjtE */
+
+}
+
+
+int Xorriso_list_extras_result(struct XorrisO *xorriso, char *mode,
+                               char *what, int flag)
+{
+ if(mode[0] != 0 && strcmp(mode, "all") != 0) {
+   if(strcmp(mode, what) != 0 &&
+      (mode[0] != '-' || strcmp(mode + 1, what) != 0)) 
+     return(2);
+ }
+ Xorriso_result(xorriso, 0);
+ return(1);
+}
+
+
+int Xorriso_list_extras(struct XorrisO *xorriso, char *mode, int flag)
+{
+ int ret;
+
+ if(strcmp(mode, "codes") == 0) {
+   sprintf(xorriso->result_line,
+        "List of xorriso extra feature codes. Usable with or without dash.\n");
+   Xorriso_result(xorriso, 0);
+   sprintf(xorriso->result_line, "Local ACL    : -acl\n");
+   Xorriso_result(xorriso, 0);
+   sprintf(xorriso->result_line, "Local xattr  : -xattr\n");
+   Xorriso_result(xorriso, 0);
+   sprintf(xorriso->result_line, "Jigdo files  : -jigdo\n");
+   Xorriso_result(xorriso, 0);
+   sprintf(xorriso->result_line, "zisofs       : -zisofs\n");
+   Xorriso_result(xorriso, 0);
+   sprintf(xorriso->result_line, "Ext. filters : -external_filter\n");
+   Xorriso_result(xorriso, 0);
+   sprintf(xorriso->result_line, "DVD obs 64 kB: -dvd_obs\n");
+   Xorriso_result(xorriso, 0);
+   sprintf(xorriso->result_line, "Readline     : -use_readline\n");
+   Xorriso_result(xorriso, 0);
+   return(1);
+ }
+ sprintf(xorriso->result_line,
+         "List of xorriso extra features. yes = enabled , no = disabled\n");
+ Xorriso_list_extras_result(xorriso, mode, "list_extras", 0);
+
+ ret= iso_local_attr_support(3);
+ sprintf(xorriso->result_line, "Local ACL    : %s\n", ret & 1 ? "yes" : "no");
+ Xorriso_list_extras_result(xorriso, mode, "acl", 0);
+ sprintf(xorriso->result_line, "Local xattr  : %s\n", ret & 2 ? "yes" : "no");
+ Xorriso_list_extras_result(xorriso, mode, "xattr", 0);
+ 
+ sprintf(xorriso->result_line, "Jigdo files  : %s\n",
+#ifdef Xorriso_with_libjtE
+         "yes");
+#else
+         "no");
+#endif
+ Xorriso_list_extras_result(xorriso, mode, "jigdo", 0);
+
+ ret= iso_file_add_zisofs_filter(NULL, 4);
+ sprintf(xorriso->result_line, "zisofs       : %s\n", ret == 2 ? "yes" : "no");
+ Xorriso_list_extras_result(xorriso, mode, "zisofs", 0);
+
+ sprintf(xorriso->result_line, "Ext. filters : %s\n",
+#ifdef Xorriso_allow_external_filterS
+#ifdef Xorriso_allow_extf_suiD
+         "yes , setuid allowed");
+#else
+         "yes , setuid banned");
+#endif
+#else
+         "no");
+#endif
+ Xorriso_list_extras_result(xorriso, mode, "external_filter", 0);
+
+ sprintf(xorriso->result_line, "DVD obs 64 kB: %s\n",
+#ifdef Xorriso_dvd_obs_default_64K
+         "yes");
+#else
+         "no");
+#endif
+ Xorriso_list_extras_result(xorriso, mode, "dvd_obs", 0);
+
+ sprintf(xorriso->result_line, "Readline     : %s\n",
+#ifdef Xorriso_with_readlinE
+         "yes");
+#else
+         "no");
+#endif
+ Xorriso_list_extras_result(xorriso, mode, "use_readline", 0);
+
+ return(1);
+}
+
+
+/* @param flag bit0= set num_tiles to default value
+               bit1= set tile_blocks to default value
+*/
+int Xorriso_set_data_cache(struct XorrisO *xorriso, void *o,
+                           int num_tiles, int tile_blocks, int flag)
+{
+ int ret, tiles, blocks, set_flag;
+ struct isoburn_read_opts *ropts;
+
+ ropts= (struct isoburn_read_opts *) o;
+ if(flag & (1 | 2)) {
+   isoburn_ropt_get_data_cache(ropts, &tiles, &blocks, &set_flag, 1);
+   if(flag & 1)
+     num_tiles= tiles;
+   if(flag & 2)
+     tile_blocks= blocks;
+ }
+ ret= isoburn_ropt_set_data_cache(ropts, num_tiles, tile_blocks, 0);
+ return(ret);
+}
+
+
--- a/xorriso/lib_mgt.h
+++ b/xorriso/lib_mgt.h
@ -0,0 +1,73 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which manage the relation
+   between xorriso and the libraries: libburn, libisofs, and libisoburn.
+*/
+
+
+#ifndef Xorriso_pvt_x_includeD
+#define Xorriso_pvt_x_includeD yes
+
+
+#ifndef Xorriso_standalonE
+
+/* The library which does the ISO 9660 / RockRidge manipulations */
+#include <libisofs/libisofs.h>
+
+/* The library which does MMC optical drive operations */
+#include <libburn/libburn.h>
+
+/* The library which enhances overwriteable media with ISO 9660 multi-session
+   capabilities via the method invented by Andy Polyakov for growisofs */
+#include <libisoburn/libisoburn.h>
+
+/* The official xorriso options API. "No shortcuts" */
+#include "xorriso.h"
+
+/* The inner description of XorrisO */
+#include "xorriso_private.h"
+
+/* The inner isofs- and burn-library interface */
+#include "xorrisoburn.h"
+
+#else /* ! Xorriso_standalonE */
+
+#include "../libisofs/libisofs.h"
+#include "../libburn/libburn.h"
+#include "../libisoburn/libisoburn.h"
+#include "xorriso.h"
+#include "xorriso_private.h"
+#include "xorrisoburn.h"
+
+#endif /* Xorriso_standalonE */
+
+
+int Xorriso_abort(struct XorrisO *xorriso, int flag);
+
+
+/* @param flag bit0= suppress messages below UPDATE
+               bit1= suppress messages below FAILURE
+*/
+int Xorriso_set_image_severities(struct XorrisO *xorriso, int flag);
+
+int Xorriso__sev_to_text(int severity, char **severity_name,
+                         int flag);
+
+/* @param flag bit0= report libisofs error text
+               bit1= victim is disk_path
+               bit2= do not inquire libisofs, report msg_text and min_severity
+*/
+int Xorriso_report_iso_error(struct XorrisO *xorriso, char *victim,
+                        int iso_error_code, char msg_text[], int os_errno,
+                        char min_severity[], int flag);
+
+int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag);
+
+
+#endif /* ! Xorriso_pvt_x_includeD */
+
--- a/xorriso/make_docs.sh
+++ b/xorriso/make_docs.sh
@ -1,10 +1,15 @@
 #!/bin/sh
 #
 # Produce man page xorriso/xorriso.1 and info file xorriso/xorriso.info
-# from base file xorris/xorriso.texi.
+# from base file xorriso/xorriso.texi.
+# Same for xorriso/xorrisofs.texi and xorriso/xorrecord.texi.

 ( cd xorriso ; makeinfo ./xorriso.texi )
+( cd xorriso ; makeinfo ./xorrisofs.texi )
+( cd xorriso ; makeinfo ./xorrecord.texi )

 xorriso/make_xorriso_1 -auto
+xorriso/make_xorriso_1 -auto -xorrisofs
+xorriso/make_xorriso_1 -auto -xorrecord


--- a/xorriso/make_xorriso_1.c
+++ b/xorriso/make_xorriso_1.c
@ -3,15 +3,20 @@
  ( cd xorriso ; cc -g -Wall -o make_xorriso_1 make_xorriso_1.c )
 */
 /*
-   Specialized converter from xorriso/xorriso.texi to xorriso/xorriso.1.
+   Specialized converter from xorriso/xorriso.texi to xorriso/xorriso.1
+   resp. from xorriso/xorrisofs.texi to xorriso/xorrisofs.1

   The conversion rules are described at the beginning of xorriso/xorriso.texi

-   Copyright 2010 Thomas Schmitt, <scdbackup@gmx.net>
+   Copyright 2010 - 2011 Thomas Schmitt, <scdbackup@gmx.net>

   Provided under GPL version 2 or later.
 */

+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
@ -33,6 +38,10 @@ struct Mx1 {
 
 };

+int Mx1_substitute(struct Mx1 *m, char line_in[256], char line_out[256],
+                   int raw, int upto, int flag);
+
+

 int Mx1_init(struct Mx1 *m, char *prog, int flag)
 {
@ -73,64 +82,213 @@ int Mx1__get_word(char *line, char word[256], char **remainder, int flag)
 }


-int Mx1_substitute(struct Mx1 *m, char line_in[256], char line_out[256],
-                   int raw, int flag)
+int Mx1_is_wrap(struct Mx1 *m, char wraps[][20], char *start, char **found,
+                int flag)
 {
- char *rpt, *wpt, *ept;
- int l;
+ int i;
+
+ for(i= 0; wraps[i][0] != 0; i++)
+   if(strncmp(start, wraps[i], strlen(wraps[i])) == 0)
+ break;
+ if(wraps[i][0] != 0) {
+   if(found != NULL)
+      *found= wraps[i];
+   return(1);
+ }
+ return(0);
+}
+
+
+int Mx1_is_bold_wrap(struct Mx1 *m, char *start, char **found, int flag)
+{
+ int ret;
+ static char bold_wraps[][20]= {
+   "@b{", "@dfn{", "@emph{", "@strong{", "@command{",
+   "" };
+ 
+ ret= Mx1_is_wrap(m, bold_wraps, start, found, 0);
+ return(ret);
+}
+
+
+int Mx1_is_normal_wrap(struct Mx1 *m, char *start, char **found, int flag)
+{
+ int ret;
+ static char normal_wraps[][20]= {
+   "@var{", "@code{", "@i{", "@abbr{", "@file{", "@option{", "@samp{", "@r{",
+    "" };
+ 
+ ret= Mx1_is_wrap(m, normal_wraps, start, found, 0);
+ return(ret);
+}
+
+
+int Mx1_is_ignored_wrap(struct Mx1 *m, char *start, char **found, int flag)
+{
+ int ret;
+ static char ignored_wraps[][20]= {
+   "@ref{", "@xref{",
+    "" };
+ 
+ ret= Mx1_is_wrap(m, ignored_wraps, start, found, 0);
+ return(ret);
+}
+
+
+int Mx1_is_any_wrap(struct Mx1 *m, char *start, char **found, int flag)
+{
+ int ret;
+
+ ret= Mx1_is_bold_wrap(m, start, found, 0);
+ if(ret > 0)
+   return(1);
+ ret= Mx1_is_normal_wrap(m, start, found, 0);
+ if(ret > 0)
+   return(2);
+ ret= Mx1_is_ignored_wrap(m, start, found, 0);
+ if(ret > 0)
+   return(3);
+ return(0);
+}
+
+
+/* @param flag bit0= recursion
+               bit1= drop content of brackets
+*/
+int Mx1_rewrap(struct Mx1 *m, char **read_pt, char **write_pt,
+                char *write_base, char *envelope,
+                char *front, char *back, int flag)
+{
+ char *rpt, *wpt, *ept, content[256], msg[256];
+ int l, ret;
+
+ rpt= *read_pt;
+ wpt= *write_pt;
+
+ ept= strchr(rpt, '}');
+ if(ept == NULL) {
+   sprintf(msg, "No closing bracket found for '%s'", envelope);
+   Mx1_report_error(m, msg, 0);
+   return(-1);
+ }
+ /* Mapped {...} content is subject to the rules except {...} mapping. */
+ l= ept - rpt;
+ if(flag & 2)
+   l= 0;
+ if(l > 0) {
+   ret= Mx1_substitute(m, rpt, content, 0, l, 1);
+   if(ret <= 0)
+     return(ret);
+   l= strlen(content);
+ }
+ if((wpt - write_base) + l + strlen(front) + strlen(back) > 255) {
+   Mx1_report_error(m, "Line length overflow while text substitution", 0);
+   return(-1);
+ }
+ strcpy(wpt, front);
+ wpt+= strlen(front);
+ if(l > 0)
+   strncpy(wpt, content, l);
+ wpt+= l;
+ strcpy(wpt, back);
+ wpt+= strlen(back);
+
+ (*read_pt)+= ept - rpt;
+ (*write_pt)= wpt;
+ return(1);
+}
+
+
+/* @param flag bit0= recursion
+*/
+int Mx1_substitute(struct Mx1 *m, char line_in[256], char line_out[256],
+                   int raw, int upto, int flag)
+{
+ char *rpt, *wpt, *found;
+ int ret, typ= 0;

 wpt= line_out;
- for(rpt= line_in; *rpt != 0; rpt++) {
+ for(rpt= line_in; rpt - line_in < upto && *rpt != 0; rpt++) {
   if(rpt - line_in < raw) {
     *(wpt++)= *rpt;
 continue;
   } 
   if(*rpt == '@') {
-     if(strncmp(rpt, "@strong{", 8) == 0) {
-       /* @strong{-...} gets mapped to \fB\-...\fR . */;
-       /* @strong{... } gets mapped to \fB...\fR . */
-       ept= strchr(rpt, '}');
-       if(ept == NULL) {
-         Mx1_report_error(m, "No closing bracket found for '@strong{'", 0);
-         return(-1);
-       }
-       l= ept - rpt - 8;
-       if((wpt - line_out) + l + 6 + (rpt[8] == '-') > 255)
-         goto overflow;
-       strcpy(wpt, "\\fB");
-       wpt+= 3;
-       if(rpt[8] == '-')
-         *(wpt++)= '\\';
-       strncpy(wpt, rpt + 8, l);
-       wpt+= l;
-       strcpy(wpt, "\\fR");
-       wpt+= 3;
-       rpt+= ept - rpt;
+     typ= 0;
+     if(!(flag & 1))
+       typ= Mx1_is_any_wrap(m, rpt, &found, 0);
+     if(typ == 1) {
+       /* @b{...}, @command{...}, @dfn{...}, @emph{...}, @strong{...}
+            get mapped to \fB...\fR .
+       */
+       rpt+= strlen(found);
+       ret= Mx1_rewrap(m, &rpt, &wpt, line_out,
+                        found , "\\fB", "\\fR", flag & 1);
+       if(ret <= 0)
+         return(ret);
+
+     } else if(typ == 2) {
+       /*  @abbr{...}, @code{...}, @file{...}, @i{...}, @option{...}, @r{...},
+             @ref{...}, @samp{...},@var{...}, get mapped to ... .
+       */
+       rpt+= strlen(found);
+       ret= Mx1_rewrap(m, &rpt, &wpt, line_out, found, "", "", flag & 1);
+       if(ret <= 0)
+         return(ret);
+
+     } else if(typ == 3) {
+       /* @ref{...}, @xref{...} get mapped to empty text.
+       */
+       rpt+= strlen(found);
+       ret= Mx1_rewrap(m, &rpt, &wpt, line_out, found , "", "",
+                       (flag & 1) | 2);
+       if(ret <= 0)
+         return(ret);
+
+     } else if(strncmp(rpt, "@email{", 7) == 0 && !(flag & 1)) {
+       /* @email{...} gets mapped to <...> . */
+       rpt+= 7;
+       ret= Mx1_rewrap(m, &rpt, &wpt, line_out, "@email{", "<", ">", 0);
+       if(ret <= 0)
+         return(ret);
+
     } else if(strncmp(rpt, "@minus{}", 8) == 0) {
       /* @minus{} will become "-". */
       if((wpt - line_out) + 1 > 255)
         goto overflow;
       *(wpt++)= '-';
       rpt+= 7;
+
     } else if(strncmp(rpt, "@@", 2) == 0 ||
               strncmp(rpt, "@{", 2) == 0 ||
               strncmp(rpt, "@}", 2) == 0) {
       /* @@ , @{, @} will get stripped of their first @. */
+       if((wpt - line_out) + 1 > 255)
+         goto overflow;
       *(wpt++)= *(rpt + 1);
       rpt++;
-     }  
+
+     } else {
+       if((wpt - line_out) + 1 > 255)
+         goto overflow;
+       *(wpt++)= *(rpt);
+
+     }
+
   } else if(*rpt == '\\') {
     /* "\" becomes "\\" */
     if((wpt - line_out) + 2 > 255)
       goto overflow;
     *(wpt++)= '\\';
     *(wpt++)= '\\';
+
   } else if((wpt - line_out) + 1 > 255) {
 overflow:;
     Mx1_report_error(m, "Line length overflow while text substitution", 0);
     return(-1);
   } else
     *(wpt++)= *rpt;
+
 }
 *wpt= 0;
 return(1);
@ -142,8 +300,8 @@ overflow:;
 */
 int Mx1_convert(struct Mx1 *m, char line_in[256], char line_out[256], int flag)
 {
- int l, num, keep= 0, ret, raw;
- char word[256], buf[256], *remainder;
+ int l, num, keep= 0, ret, raw, i, backslash_count;
+ char word[256], buf[256], *remainder, *wpt;

 m->count_in++;
 l= strlen(line_in);
@ -224,30 +382,42 @@ int Mx1_convert(struct Mx1 *m, char line_in[256], char line_out[256], int flag)
     }
     strcat(buf, "\\");
   }
+
+   /* Substitute option text */
+   raw= strlen(buf);
   strcat(buf, word);
+   ret= Mx1_substitute(m, buf, line_out, raw, strlen(buf), 0);
+   if(ret <= 0)
+     return(-1);
+   strcpy(buf, line_out);
+
   strcat(buf, "\\fR");
   raw= strlen(buf);
   strcat(buf, remainder);
-   ret= Mx1_substitute(m, buf, line_out, raw, 0);
+
+   /* Substitute arguments text */
+   ret= Mx1_substitute(m, buf, line_out, raw, strlen(buf), 0);
   if(ret <= 0)
     return(-1);
   m->count_out++;
   return(1);
 }

- /* @strong{-...} gets mapped to \fB\-...\fR . */
 /* @strong{... } gets mapped to \fB...\fR . */
+ /* @command{... } gets mapped to \fB...\fR . */
 /* @minus{} will become "-". */
+ /* Mapped {...} content is subject to the rules except {...} mapping. */
 /* @@ , @{, @} will get stripped of their first @. */
 /* "\" becomes "\\" */
+
 if(line_in[0] != '@' ||
-    strncmp(line_in, "@strong{", 8) == 0 ||
+    Mx1_is_any_wrap(m, line_in, NULL, 0) > 0 ||
    strncmp(line_in, "@minus{}", 8) == 0 ||
    strncmp(line_in, "@@", 2) == 0 ||
    strncmp(line_in, "@{", 2) == 0 ||
-    strncmp(line_in, "@}", 2) == 0) {
+    strncmp(line_in, "@}", 2) == 0 ) {
   keep= 1;
-   ret= Mx1_substitute(m, line_in, line_out, 0, 0);
+   ret= Mx1_substitute(m, line_in, line_out, 0, strlen(line_in), 0);
   if(ret <= 0)
     return(-1);
 }
@ -258,6 +428,26 @@ int Mx1_convert(struct Mx1 *m, char line_in[256], char line_out[256], int flag)
     return(0);
   strcpy(line_out, line_in);
 }
+
+ /* "-" which are not preceded by an uneven number of "\"  will get
+    prepended one "\".
+ */
+ l= strlen(line_out);
+ backslash_count= 0;
+ wpt= buf;
+ for(i= 0; i < l; i++) {
+   if(line_out[i] == '\\')
+     backslash_count++;
+   else if(line_out[i] == '-') {
+     if(backslash_count % 2 == 0)
+       *(wpt++)= '\\';
+     backslash_count= 0;
+   } else
+     backslash_count= 0;
+   *(wpt++)= line_out[i];
+ }
+ *wpt= 0;
+ strcpy(line_out, buf);
 m->count_out++;
 return(1);
 }
@ -267,8 +457,8 @@ int main(int argc, char **argv)
 {
 int ret, l, as_filter= 0, i;
 char line_in[256], line_out[256], *got;
- static char name_in[]= {"xorriso/xorriso.texi"};
- static char name_out[]= {"xorriso/xorriso.1"};
+ static char name_in[1024]= {"xorriso/xorriso.texi"};
+ static char name_out[1024]= {"xorriso/xorriso.1"};
 struct Mx1 m;
 FILE *fp_in= stdin, *fp_out= stdout;
 
@ -276,17 +466,25 @@ int main(int argc, char **argv)

 if(argc < 2) {
 usage:;
-   fprintf(stderr, "usage:  %s -auto|-filter\n", argv[0]);
-   fprintf(stderr, "  -auto     xorriso/xorriso.texi -> xorriso/xorriso.1\n");
-   fprintf(stderr, "  -filter   stdin                -> stdout\n");
+   fprintf(stderr, "usage:  %s -auto|-filter [-xorrisofs]\n", argv[0]);
+   fprintf(stderr, "  -auto       xorriso/xorriso.texi -> xorriso/xorriso.1\n");
+   fprintf(stderr, "  -filter     stdin                -> stdout\n");
+   fprintf(stderr, "  -xorrisofs  process xorriso/xorrisofs.texi\n");
+   fprintf(stderr, "  -xorrecord  process xorriso/xorrecord.texi\n");
   exit(2);
 }
 for(i= 1; i < argc; i++) {
-   if(strcmp(argv[i], "-filter") == 0)
+   if(strcmp(argv[i], "-filter") == 0) {
     as_filter= 1;
-   else if(strcmp(argv[i], "-auto") == 0)
+   } else if(strcmp(argv[i], "-auto") == 0) {
     as_filter= 0;
-   else {
+   } else if(strcmp(argv[i], "-xorrisofs") == 0) {
+     strcpy(name_in, "xorriso/xorrisofs.texi");
+     strcpy(name_out, "xorriso/xorrisofs.1");
+   } else if(strcmp(argv[i], "-xorrecord") == 0) {
+     strcpy(name_in, "xorriso/xorrecord.texi");
+     strcpy(name_out, "xorriso/xorrecord.1");
+   } else {
     fprintf(stderr, "%s : unknown option %s\n", argv[0], argv[i]);
     goto usage;
   }
--- a/xorriso/make_xorriso_standalone.sh
+++ b/xorriso/make_xorriso_standalone.sh
@ -1,16 +1,16 @@
 #!/bin/sh

 # make_xorriso_standalone.sh
-# Copyright 2008 - 2010 Thomas Schmitt, scdbackup@gmx.net, GPLv2+
+# Copyright 2008 - 2013 Thomas Schmitt, scdbackup@gmx.net, GPLv2+
 #
 # Not intended for general use in production installations !
 # 
 # This is a development tool which expects a special setup of directories.
 # It is to be executed in a common parent of the directories 
-#   nglibisofs-develop libburn-develop libisoburn-develop
+#   nglibisofs-develop jte-develop libburn-develop libisoburn-develop
 # where tarballs or repository copies have been installed of
-#   libisofs           libburn         libisoburn
-# obtained by following instructions on http://libburnia-project.org.
+#   libisofs           jte         libburn         libisoburn
+# obtained according to instructions on http://libburnia-project.org.
 #
 # It creates a new directory tree
 #   xorriso-standalone
@ -40,7 +40,7 @@ create_gnu_xorriso="yes"
 current_dir=$(pwd)
 lone_dir="$current_dir"/"xorriso-standalone"

-xorriso_rev=0.5.2
+xorriso_rev=1.2.8
 # For unstable uploads and patch level 0 of stable releases:
 xorriso_pl=""
 # For higher patch levels of stable releases:
@ -78,6 +78,16 @@ copy_files() {
  fi
 }

+copy_tree() {
+  if cp -a "$@"
+  then
+    dummy=dummy
+  else
+    echo "Failed to : cp -a " "$@" >&2
+    exit 1
+  fi
+}
+
 if test -e "$lone_dir"
 then
  echo "Already existing : $lone_dir" >&2
@ -96,6 +106,7 @@ copy_files \
 CONTRIBUTORS \
 COPYRIGHT \
 COPYING \
+ ChangeLog \
 INSTALL \
 acinclude.m4 \
 aclocal.m4 \
@ -114,14 +125,12 @@ copy_files \
 \
 "$lone_dir"

+copy_files xorriso/xorriso_bootstrap.txt    "$lone_dir"/bootstrap
+
 copy_files xorriso/configure_ac.txt         "$lone_dir"/configure.ac

 copy_files xorriso/xorriso_makefile_am.txt  "$lone_dir"/Makefile.am

-# copy_files xorriso/xorriso_pc_in.txt        "$lone_dir"/xorriso.pc.in
-
-# echo "See end of xorriso/changelog.txt" >"$lone_dir"/TODO
-

 # libisoburn

@ -129,48 +138,129 @@ create_dir "$lone_dir"/libisoburn
 copy_files \
 libisoburn/*.[ch] \
 "$lone_dir"/libisoburn
+copy_files COPYRIGHT "$lone_dir"/libisoburn

 xorriso/convert_man_to_html.sh

 create_dir "$lone_dir"/xorriso
 copy_files \
- xorriso/xorrisoburn.[ch] \
- xorriso/xorriso.[ch] \
+ xorriso/xorriso.h \
 xorriso/xorriso_private.h \
+ xorriso/sfile.h \
+ xorriso/sfile.c \
+ xorriso/aux_objects.h \
+ xorriso/aux_objects.c \
+ xorriso/findjob.h \
+ xorriso/findjob.c \
+ xorriso/check_media.h \
+ xorriso/check_media.c \
+ xorriso/misc_funct.h \
+ xorriso/misc_funct.c \
+ xorriso/text_io.h \
+ xorriso/text_io.c \
+ xorriso/match.h \
+ xorriso/match.c \
+ xorriso/emulators.h \
+ xorriso/emulators.c \
+ xorriso/disk_ops.h \
+ xorriso/disk_ops.c \
+ xorriso/cmp_update.h \
+ xorriso/cmp_update.c \
+ xorriso/parse_exec.h \
+ xorriso/parse_exec.c \
+ xorriso/opts_a_c.c \
+ xorriso/opts_d_h.c \
+ xorriso/opts_i_o.c \
+ xorriso/opts_p_z.c \
 \
+ xorriso/xorrisoburn.h \
+ xorriso/base_obj.h \
+ xorriso/base_obj.c \
+ xorriso/lib_mgt.h \
+ xorriso/lib_mgt.c \
+ xorriso/sort_cmp.h \
+ xorriso/sort_cmp.c \
+ xorriso/drive_mgt.h \
+ xorriso/drive_mgt.c \
+ xorriso/iso_img.h \
+ xorriso/iso_img.c \
+ xorriso/iso_tree.h \
+ xorriso/iso_tree.c \
+ xorriso/iso_manip.h \
+ xorriso/iso_manip.c \
+ xorriso/write_run.h \
+ xorriso/write_run.c \
+ xorriso/read_run.h \
+ xorriso/read_run.c \
+ xorriso/filters.h \
+ xorriso/filters.c \
+ \
+ xorriso/xorriso_main.c \
 xorriso/xorriso_timestamp.h \
 \
 xorriso/changelog.txt \
 xorriso/xorriso_eng.html \
+ xorriso/make_docs.sh \
 xorriso/xorriso.texi \
 xorriso/xorriso.info \
+ xorriso/xorrisofs.texi \
+ xorriso/xorrisofs.info \
+ xorriso/xorrecord.texi \
+ xorriso/xorrecord.info \
 xorriso/make_xorriso_1.c \
 xorriso/xorriso.1 \
+ xorriso/xorrisofs.1 \
+ xorriso/xorrecord.1 \
 xorriso/man_1_xorriso.html \
+ xorriso/man_1_xorrisofs.html \
+ xorriso/man_1_xorrecord.html \
 "$lone_dir"/xorriso
+copy_files COPYRIGHT "$lone_dir"/xorriso

 copy_files xorriso/xorriso_buildstamp_none.h \
           "$lone_dir"/xorriso/xorriso_buildstamp.h
 copy_files xorriso/xorriso_buildstamp_none.h \
           "$lone_dir"/xorriso/xorriso_buildstamp_none.h

+create_dir "$lone_dir"/doc
+copy_files doc/partition_offset.wiki \
+           doc/startup_file.txt \
+           doc/qemu_xorriso.wiki \
+           "$lone_dir"/doc
+
 create_dir "$lone_dir"/test
 copy_files \
 test/compare_file.c \
- "$lone_dir"/test/compare_file.c
+ "$lone_dir"/test
+
+create_dir "$lone_dir"/frontend
+copy_files \
+ frontend/frontend_pipes_xorriso.c \
+ frontend/README-tcltk \
+ frontend/xorriso-tcltk \
+ "$lone_dir"/frontend
+
+
+# releng
+
+copy_tree releng "$lone_dir"/releng
+
+rm "$lone_dir"/releng/auto_cxx
+rm -r "$lone_dir"/releng/releng_generated_data
+create_dir "$lone_dir"/releng/releng_generated_data


 # nglibisofs

 create_dir "$lone_dir"/libisofs
 create_dir "$lone_dir"/libisofs/filters
-create_dir "$lone_dir"/doc
 goto_dir   "$current_dir"/nglibisofs-develop
 copy_files libisofs/*.[ch] "$lone_dir"/libisofs
 copy_files libisofs/filters/*.[ch] "$lone_dir"/libisofs/filters
 copy_files doc/susp_aaip*.txt "$lone_dir"/doc
 copy_files doc/zisofs_format.txt "$lone_dir"/doc
 copy_files doc/checksums.txt "$lone_dir"/doc
+copy_files doc/boot_sectors.txt "$lone_dir"/doc
 copy_files COPYRIGHT "$lone_dir"/libisofs
 test -e CONTRIBUTORS && cat CONTRIBUTORS >>"$lone_dir"/CONTRIBUTORS

@ -178,35 +268,17 @@ test -e CONTRIBUTORS && cat CONTRIBUTORS >>"$lone_dir"/CONTRIBUTORS
 cat version.h.in >> "$lone_dir"/version.h.in


-# <<< obsoleted patchings
-
-if test 1 = 0
-then
-
-# Change GNU macro name to POSIX name
-sed -e 's/FNM_FILE_NAME/FNM_PATHNAME/g' \
-  <libisofs/tree.c >"$lone_dir"/libisofs/tree.c
-
-# Filter out the semi-illegal TODO comments 
-( cd "$lone_dir"/libisofs && grep '^[[:space:]]*//' *.[ch] | less )
-echo "Is it ok delete all shown //-lines ?"
-read yesno
-if test "$yesno" = "y" -o "$yesno" = "1"
-then
-  for i in "$lone_dir"/libisofs/*.[ch]
-  do
-    # first copy attributes
-    cp "$i" "$lone_dir"/libisofs/tmpfile
-    # now filter away // lines
-    grep -v '^[[:space:]]*//' <"$i" >"$lone_dir"/libisofs/tmpfile && \
-      mv "$lone_dir"/libisofs/tmpfile "$i"
-  done
-fi
-echo "Remaining // lines:"
-( cd "$lone_dir"/libisofs && grep '//' *.[ch] )
-
-fi
+# libjte

+create_dir "$lone_dir"/libjte
+goto_dir   "$current_dir"/jte-develop
+copy_files *.[ch] "$lone_dir"/libjte
+copy_files COPYRIGHT "$lone_dir"/libjte
+#
+# Now using libisoburn/releng/jigdo-gen-md5-list because in jigit it is
+# restricted to Linux and FreeBSD.
+goto_dir   "$current_dir"/libisoburn-develop/releng
+copy_files jigdo-gen-md5-list jigdo-gen-md5-list.1 "$lone_dir"/libjte


 # libburn
@ -234,10 +306,10 @@ then
  copy_files xorriso/COPYING_gnu_xorriso      "$lone_dir"/COPYING
  copy_files xorriso/AUTHORS_gnu_xorriso      "$lone_dir"/AUTHORS

-  # patch xorriso/xorriso.c to be GNU xorriso
+  # patch xorriso/xorriso.h to be GNU xorriso
  sed -e's/define Xorriso_libburnia_xorrisO/define Xorriso_GNU_xorrisO/' \
      -e's/This may be changed to Xorriso_GNU_xorrisO in order to c/C/' \
-      <xorriso/xorriso.c  >"$lone_dir"/xorriso/xorriso.c
+      <xorriso/xorriso.h  >"$lone_dir"/xorriso/xorriso.h

 else

--- a/xorriso/makefile_libxorriso_am.txt
+++ b/xorriso/makefile_libxorriso_am.txt
@ -1,197 +0,0 @@
-
-# ts A90315 : LIBBURNIA_PKGCONFDIR is defined OS specific in acinclude.m4
-# was: pkgconfigdir=$(libdir)/pkgconfig
-pkgconfigdir=$(LIBBURNIA_PKGCONFDIR)
-
-libincludedir=$(includedir)/libisoburn
-
-lib_LTLIBRARIES = libisoburn/libisoburn.la libxorriso/libxorriso.la
-
-## ========================================================================= ##
-
-# Build libraries
-libisoburn_libisoburn_la_LDFLAGS = \
-	-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
-libisoburn_libisoburn_la_SOURCES = \
-	libisoburn/burn_wrap.c \
-	libisoburn/data_source.c \
-	libisoburn/isoburn.c \
-	libisoburn/isoburn.h \
-	libisoburn/isofs_wrap.c \
-	libisoburn/libisoburn.h \
-	version.h
-
-libisoburn_libisoburn_la_LIBADD = \
-	-lisofs \
-	-lburn
-
-libxorriso_libxorriso_la_LDFLAGS = \
-	-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
-libxorriso_libxorriso_la_SOURCES = \
-	xorriso/xorriso.h \
-	xorriso/xorriso_private.h \
-	xorriso/xorriso.c \
-	xorriso/xorrisoburn.h \
-	xorriso/xorrisoburn.c \
-	xorriso/xorriso_timestamp.h \
-	xorriso/xorriso_buildstamp.h \
-	version.h
-
-libxorriso_libxorriso_la_LIBADD = \
-	-lisofs \
-	-lburn \
-	-lisoburn
-
-libinclude_HEADERS = \
-	libisoburn/libisoburn.h \
-	xorriso/xorriso.h
-
-## ========================================================================= ##
-
-
-# This is the reference application of libisoburn. See man xorriso/xorriso.1
-# 
-bin_PROGRAMS = \
-	xorriso/xorriso
-
-# This looks quite ugly with make install: xorriso.c is compiled twice again
-#
-# Trying to create a build timestamp file
-#
-# BUILT_SOURCES = xorriso/xorriso_buildstamp.h
-#
-# phony targets get rebuilt every time
-#
-# .PHONY: xorriso/xorriso_buildstamp.h
-# xorriso/xorriso_buildstamp.h:
-# 	date -u '+#define Xorriso_build_timestamP "%Y.%m.%d.%H%M%S"' >xorriso/xorriso_buildstamp.h
-# 	cat xorriso/xorriso_buildstamp.h
-
-xorriso_xorriso_CPPFLAGS = -Ilibisoburn
-xorriso_xorriso_CFLAGS = -DXorriso_with_maiN -DXorriso_without_subS \
-                         $(READLINE_DEF) $(LIBACL_DEF) $(XATTR_DEF) \
-                         $(EXTF_DEF) $(EXTF_SUID_DEF) $(ZLIB_DEF) \
-                         $(XORRISO_DVD_OBS_64K)
-
-xorriso_xorriso_LDADD = libisoburn/libisoburn.la -lisofs -lburn \
-                        libxorriso/libxorriso.la \
-                        $(THREAD_LIBS) $(LIBBURN_ARCH_LIBS)
-
-xorriso_xorriso_SOURCES = \
-	xorriso/xorriso.h \
-	xorriso/xorriso_private.h \
-	xorriso/xorriso.c \
-	xorriso/xorrisoburn.h \
-	xorriso/xorriso_timestamp.h \
-	xorriso/xorriso_buildstamp.h
-
-#	xorriso/xorrisoburn.c \
-#
-
-# Install symbolic links to the xorriso binary
-#
-install-exec-hook:
-	if test -e "$(DESTDIR)$(bindir)"/xorrisofs ; then rm "$(DESTDIR)$(bindir)"/xorrisofs ; else echo ; fi
-	ln -s xorriso "$(DESTDIR)$(bindir)"/xorrisofs
-	if test -e "$(DESTDIR)$(bindir)"/osirrox ; then rm "$(DESTDIR)$(bindir)"/osirrox ; else echo ; fi
-	ln -s xorriso "$(DESTDIR)$(bindir)"/osirrox
-	if test -e "$(DESTDIR)$(bindir)"/xorrecord ; then rm "$(DESTDIR)$(bindir)"/xorrecord ; else echo ; fi
-	ln -s xorriso "$(DESTDIR)$(bindir)"/xorrecord
-
-
-# Alternative to the disabled .PHONY above.
-# Trying to create a build timestamp file semi-manually:  make buildstamped
-#
-buildstamp:
-	date -u '+#define Xorriso_build_timestamP "%Y.%m.%d.%H%M%S"' >xorriso/xorriso_buildstamp.h
-	cat xorriso/xorriso_buildstamp.h
-
-# For now   make buildstamped  has to be performed explicitely.
-buildstamped: buildstamp
-	make
-
-
-
-## Build test applications
-noinst_PROGRAMS = \
-	test/compare_file
-
-# A program to compare two files in mirrored trees in mounted filesystems
-# To compare tree /media/dvd and /original/dir :
-#   find /media/dvd -exec test/compare_file '{}' /media/dvd /original/dir ';'
-#
-test_compare_file_CPPFLAGS =
-test_compare_file_CFLAGS =
-test_compare_file_LDADD =
-test_compare_file_SOURCES = test/compare_file.c
-
-
-## ========================================================================= ##
-
-## Build documentation (You need Doxygen for this to work)
-webhost = http://libburn-api.pykix.org
-webpath = /
-docdir = $(DESTDIR)$(prefix)/share/doc/$(PACKAGE)-$(VERSION)
-
-doc:	doc/html
-
-doc/html: doc/doxygen.conf
-	if [ -f ./doc/doc.lock ]; then \
-		$(RM) -r doc/html; \
-		doxygen doc/doxygen.conf; \
-	fi
-
-doc-upload: doc/html
-	scp -r $</* $(webhost):$(webpath)
-
-all: doc
-
-install-data-local: 
-	if [ -f ./doc/doc.lock ]; then \
-		$(mkinstalldirs) $(docdir)/html; \
-		$(INSTALL_DATA) doc/html/* $(docdir)/html; \
-	fi
-
-uninstall-local:
-	rm -rf $(docdir)
-
-## ========================================================================= ##
-
-# Indent source files
-indent_files = \
-	$(libisoburn_libisoburn_la_SOURCES)
-	
-
-indent: $(indent_files)
-	indent -bad -bap -nbbb -nbbo -nbc -bli0 -br -bls   \
-		-cdw -ce -cli0 -ncs -nbfda -i8 -l79 -lc79   \
-		-lp -saf -sai -nprs -npsl -saw -sob -ss -ut \
-		-sbi0 -nsc -ts8 -npcs -ncdb -fca            \
-		$^
-
-.PHONY: indent
-
-## ========================================================================= ##
-
-# Extra things
-nodist_pkgconfig_DATA = \
-	libisoburn-1.pc
-
-man_MANS = xorriso/xorriso.1
-
-EXTRA_DIST = \
-	libisoburn-1.pc.in \
-	version.h.in \
-	doc/comments \
-	doc/doxygen.conf.in \
-	README \
-	AUTHORS \
-	CONTRIBUTORS \
-	COPYRIGHT \
-	COPYING \
-	INSTALL \
-	xorriso/changelog.txt \
-	xorriso/xorriso_buildstamp_none.h \
-	xorriso/README \
-	$(man_MANS)
-
--- a/xorriso/man_xorrecord_to_html.sh
+++ b/xorriso/man_xorrecord_to_html.sh
@ -0,0 +1,73 @@
+#!/bin/sh
+
+#
+# man_xorrecord_to_html.sh - ts A80118 , B10309
+#
+# Generates a HTML version of man page xorrecord.1
+#
+# To be executed in the libisoburn toplevel directory (eg. ./libisoburn-0.1.0)
+#
+
+# set -x
+
+man_dir=$(pwd)"/xorriso"
+export MANPATH="$man_dir"
+manpage="xorrecord"
+raw_html=$(pwd)/"xorriso/raw_man_1_xorrecord.html"
+htmlpage=$(pwd)/"xorriso/man_1_xorrecord.html"
+
+if test -r "$man_dir"/"$manpage".1
+then
+  dummy=dummy
+else
+  echo "Cannot find readable man page source $1" >&2
+  exit 1
+fi
+
+if test -e "$man_dir"/man1
+then
+  dummy=dummy
+else
+  ln -s . "$man_dir"/man1
+fi
+
+if test "$1" = "-work_as_filter"
+then
+
+#  set -x
+
+  sed \
+  -e 's/<meta name="generator" content="groff -Thtml, see www.gnu.org">/<meta name="generator" content="groff -Thtml, via man -H, via xorriso\/convert_man_to_html.sh">/' \
+  -e 's/<meta name="Content-Style" content="text\/css">/<meta name="Content-Style" content="text\/css"><META NAME="description" CONTENT="man page of xorriso"><META NAME="keywords" CONTENT="man xorrecord, manual, xorrecord, CD, DVD, BD, cdrecord, compatible"><META NAME="robots" CONTENT="follow">/' \
+  -e 's/<title>XORRECORD<\/title>/<title>man 1 xorrecord<\/title>/' \
+  -e 's/<h1 align=center>XORRECORD<\/h1>/<h1 align=center>man 1 xorrecord<\/h1>/' \
+  -e 's/<body>/<body BGCOLOR="#F5DEB3" TEXT=#000000 LINK=#0000A0 VLINK=#800000>/' \
+  -e 's/<b>MMC, Session, Track, Media types:<\/b>/\&nbsp;<BR><b>MMC, Session, Track, Media types:<\/b>/' \
+  -e 's/<b>MMC, Session, Track, Media types:<\/b>/\&nbsp;<BR><b>MMC, Session, Track, Media types:<\/b>/' \
+  -e 's/<b>Relation to program xorriso:<\/b>/\&nbsp;<BR><b>Relation to program xorriso:<\/b>/' \
+  -e 's/EXAMPLES):<br>/<A HREF="#EXAMPLES">EXAMPLES<\/A>):<br>/' \
+  -e 's/<b>Drive addressing:<\/b>/\&nbsp;<BR><b>Drive addressing:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Inquiring drive and media:<\/b>/\&nbsp;<BR><b>Inquiring drive and media:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Settings for the burn run<\/b>/\&nbsp;<BR><b>Settings for the burn run:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Program version and verbosity:<\/b>/\&nbsp;<BR><b>Program version and verbosity:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Options not compatible to cdrecord:<\/b>/\&nbsp;<BR><b>Options not compatible to cdrecord:<\/b><BR>\&nbsp;<BR>/' \
+\
+  -e 's/<\/body>/<BR><HR><FONT SIZE=-1><CENTER>(HTML generated from '"$manpage"'.1 on '"$(date)"' by '$(basename "$0")' )<\/CENTER><\/FONT><\/body>/' \
+  -e 's/&minus;/-/g' \
+  <"$2" >"$htmlpage"
+
+  set +x
+
+  chmod u+rw,go+r,go-w "$htmlpage"
+  echo "Emerged file:"
+  ls -lL "$htmlpage"
+
+else
+
+  export BROWSER='cp "%s" '"$raw_html"
+  man -H "$manpage"
+  "$0" -work_as_filter "$raw_html"
+  rm "$raw_html"
+  rm "$man_dir"/man1
+
+fi
--- a/xorriso/man_xorriso_to_html.sh
+++ b/xorriso/man_xorriso_to_html.sh
@ -0,0 +1,127 @@
+#!/bin/sh
+
+#
+# man_xorriso_to_html.sh - ts A80118 , B10309
+#
+# Generates a HTML version of man page xorriso.1
+#
+# To be executed in the libisoburn toplevel directory (eg. ./libisoburn-0.1.0)
+#
+
+# set -x
+
+man_dir=$(pwd)"/xorriso"
+export MANPATH="$man_dir"
+manpage="xorriso"
+raw_html=$(pwd)/"xorriso/raw_man_1_xorriso.html"
+htmlpage=$(pwd)/"xorriso/man_1_xorriso.html"
+
+if test -r "$man_dir"/"$manpage".1
+then
+  dummy=dummy
+else
+  echo "Cannot find readable man page source $1" >&2
+  exit 1
+fi
+
+if test -e "$man_dir"/man1
+then
+  dummy=dummy
+else
+  ln -s . "$man_dir"/man1
+fi
+
+if test "$1" = "-work_as_filter"
+then
+
+#  set -x
+
+  sed \
+  -e 's/<meta name="generator" content="groff -Thtml, see www.gnu.org">/<meta name="generator" content="groff -Thtml, via man -H, via xorriso\/convert_man_to_html.sh">/' \
+  -e 's/<meta name="Content-Style" content="text\/css">/<meta name="Content-Style" content="text\/css"><META NAME="description" CONTENT="man page of xorriso"><META NAME="keywords" CONTENT="man xorriso, manual, xorriso, CD, CD-RW, CD-R, burning, cdrecord, compatible"><META NAME="robots" CONTENT="follow">/' \
+  -e 's/<title>XORRISO<\/title>/<title>man 1 xorriso<\/title>/' \
+  -e 's/<h1 align=center>XORRISO<\/h1>/<h1 align=center>man 1 xorriso<\/h1>/' \
+  -e 's/<body>/<body BGCOLOR="#F5DEB3" TEXT=#000000 LINK=#0000A0 VLINK=#800000>/' \
+  -e 's/<b>Overview of features:<\/b>/\&nbsp;<BR><A NAME="Overview"><\/A><b>Overview of features:<\/b>/' \
+  -e 's/<b>General information paragraphs:<\/b>/\&nbsp;<BR><A NAME="General"><\/A><b>General information paragraphs:<\/b>/' \
+  -e 's/^<p>Session model<br>/<p><A HREF="#Model">Session model<\/A><br>/' \
+  -e 's/^Media types and states/<A HREF="#Media">Media types and states/' \
+  -e 's/^Creating, Growing, Modifying, Blind Growing/<A HREF="#Methods">Creating, Growing, Modifying, Blind Growing<\/A>/' \
+  -e 's/^Libburn drives/<A HREF="#Drives">Libburn drives<\/A>/' \
+  -e 's/^Rock Ridge, POSIX, X\/Open, El Torito, ACL, xattr/<A HREF="#Extras">Rock Ridge, POSIX, X\/Open, El Torito, ACL, xattr<\/A>/' \
+  -e 's/^Command processing/<A HREF="#Processing">Command processing<\/A>/' \
+  -e 's/^Dialog, Readline, Result pager/<A HREF="#Dialog">Dialog, Readline, Result pager<\/A>/' \
+  -e 's/have a look at section EXAMPLES/have a look at section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
+  -e 's/<b>Session model:<\/b>/\&nbsp;<BR><A NAME="Model"><\/A><b>Session model:<\/b>/' \
+  -e 's/<b>Media types and states:<\/b>/\&nbsp;<BR><A NAME="Media"><\/A><b>Media types and states:<\/b>/' \
+  -e 's/<b>Creating, Growing, Modifying, Blind/\&nbsp;<BR><A NAME="Methods"><\/A><b>Creating, Growing, Modifying, Blind/' \
+  -e 's/<b>Libburn drives:<\/b>/\&nbsp;<BR><b>Libburn drives:<\/b><A NAME="Drives"><\/A>/' \
+  -e 's/^-dev /\&nbsp;\&nbsp;-dev /' \
+  -e 's/^-devices /\&nbsp;\&nbsp;-devices /' \
+  -e 's/<b>Rock Ridge, POSIX, X\/Open, El Torito, ACL,/\&nbsp;<BR><A NAME="Extras"><\/A><b>Rock Ridge, POSIX, X\/Open, El Torito, ACL,/' \
+  -e 's/<b>Command processing:<\/b>/\&nbsp;<BR><A NAME="Processing"><\/A><b>Command processing:<\/b>/' \
+  -e 's/<b>Dialog, Readline, Result pager:<\/b>/\&nbsp;<BR><A NAME="Dialog"><\/A<b>Dialog, Readline, Result pager:<\/b>/' \
+  -e 's/<b>Execution order of program arguments:<\/b>/\&nbsp;<BR><A NAME="ArgSort"><\/A><b>Execution order of program arguments:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Acquiring source and target drive:<\/b>/\&nbsp;<BR><A NAME="AqDrive"><\/A><b>Acquiring source and target drive:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Influencing the behavior of image/\&nbsp;<BR><A NAME="Loading"><\/A><b>Influencing the behavior of image/' \
+  -e 's/<b>Inserting files into ISO image:<\/b>/\&nbsp;<BR><A NAME="Insert"><\/A><b>Inserting files into ISO image:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Settings for file insertion:<\/b>/\&nbsp;<BR><A NAME="SetInsert"><\/A><b>Settings for file insertion:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>File manipulations:<\/b>/\&nbsp;<BR><A NAME="Manip"><\/A><b>File manipulations:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Tree traversal command -find:<\/b>/\&nbsp;<BR><A NAME="CmdFind"><\/A><b>Tree traversal command -find:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/^<p><b>&minus;iso_rr_pattern/<p>\&nbsp;<BR><b>\&minus;iso_rr_pattern/' \
+  -e 's/EXAMPLES):<br>/<A HREF="#EXAMPLES">EXAMPLES<\/A>):<br>/' \
+  -e 's/<b>Filters for data file content:<\/b>/\&nbsp;<BR><A NAME="Filter"><\/A><b>Filters for data file content:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Writing the result, drive control:<\/b>/\&nbsp;<BR><A NAME="Writing"><\/A><b>Writing the result, drive control:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/^-find \/ /\&nbsp;\&nbsp;-find \/ /' \
+  -e 's/^$<\/b> ln -s/\&nbsp;\&nbsp;$<\/b> ln -s/' \
+  -e 's/<b>Settings for result writing:<\/b>/\&nbsp;<BR><A NAME="SetWrite"><\/A><b>Settings for result writing:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/^706k = 706kB/\&nbsp;\&nbsp;706k = 706kB/' \
+  -e 's/^5540k = 5540kB/\&nbsp;\&nbsp;5540k = 5540kB/' \
+  -e 's/<b>Bootable ISO images:<\/b>/\&nbsp;<BR><A NAME="Bootable"><\/A><b>Bootable ISO images:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Jigdo Template Extraction:<\/b>/\&nbsp;<BR><A NAME="Jigdo"><\/A><b>Jigdo Template Extraction:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Character sets:<\/b>/\&nbsp;<BR><A NAME="Charset"><\/A><b>Character sets:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Exception processing:<\/b>/\&nbsp;<BR><A NAME="Exception"><\/A><b>Exception processing:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Dialog mode control:<\/b>/\&nbsp;<BR><A NAME="DialogCtl"><\/A><b>Dialog mode control:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Drive and media related inquiry actions:<\/b>/\&nbsp;<BR><A NAME="Inquiry"><\/A><b>Drive and media related inquiry actions:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Navigation in ISO image/\&nbsp;<BR><A NAME="Navigate"><\/A><b>Navigation in ISO image/' \
+  -e 's/^filesystem:<\/b>/filesystem:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Evaluation of readability and recovery:<\/b>/\&nbsp;<BR><A NAME="Verify"><\/A><b>Evaluation of readability and recovery:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>osirrox ISO-to-disk restore commands:<\/b>/\&nbsp;<BR><A NAME="Restore"><\/A><b>osirrox ISO-to-disk restore commands:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Command compatibility emulations:<\/b>/\&nbsp;<BR><A NAME="Emulation"><\/A><b>Command compatibility emulations:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/^<p><b>&minus;as</<p>\&nbsp;<BR><b>\&minus;as</' \
+  -e 's/<b>Scripting, dialog and/\&nbsp;<BR><A NAME="Scripting"><\/A><b>Scripting, dialog and/' \
+  -e 's/^features:<\/b>/features:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Support for frontend/\&nbsp;<BR><A NAME="Frontend"><\/A><b>Support for frontend/' \
+  -e 's/^listening at stdout:<\/b>/listening at stdout:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/xorriso -outdev \/dev\/sr2 \\ -blank fast \\ -pathspecs on/xorriso -outdev \/dev\/sr2 -blank fast -pathspecs on/' \
+  -e 's/\\ -add \\ \/sounds=\/home\/me\/sounds \\ \/pictures \\ -- \\ -rm_r \\/ -add \/sounds=\/home\/me\/sounds \/pictures -- -rm_r /' \
+  -e 's/\/sounds\/indecent \\ \&rsquo;\/pictures\/\*private\*\&rsquo; \\/\/sounds\/indecent \&rsquo;\/pictures\/*private*\&rsquo; /' \
+  -e 's/\/pictures\/confidential \\ -- \\ -add \\/\/pictures\/confidential -- -add/' \
+  -e 's/xorriso -dev \/dev\/sr2 \\ -rm_r \/sounds -- \\ -mv \\/xorriso -dev \/dev\/sr2 -rm_r \/sounds -- -mv /' \
+  -e 's/\/pictures\/confidential \\ \/pictures\/restricted \\ -- \\ -chmod/\/pictures\/confidential \/pictures\/restricted -- -chmod/' \
+  -e 's/go-rwx \/pictures\/restricted -- \\ -pathsspecs on \\ -add \\/go-rwx \/pictures\/restricted -- -pathsspecs on -add /' \
+  -e 's/\/sounds=\/home\/me\/prepared_for_dvd\/sounds_dummy /\/sounds=\/home\/me\/prepared_for_dvd\/sounds_dummy/' \
+  -e 's/\/movies=\/home\/me\/prepared_for_dvd\/movies \\ -- \\ -commit/\/movies=\/home\/me\/prepared_for_dvd\/movies -- -commit/' \
+  -e 's/xorriso -indev \/dev\/sr2 \\ -rm_r \/sounds -- \\/xorriso -indev \/dev\/sr2 -rm_r \/sounds -- /' \
+  -e 's/-outdev \/dev\/sr0 -blank fast \\ -commit -eject all/-outdev \/dev\/sr0 -blank fast -commit -eject all/' \
+  -e 's/See section FILES/See section <A HREF="#FILES">FILES<\/A>/' \
+  -e 's/See section EXAMPLES/See section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
+  -e 's/<\/body>/<BR><HR><FONT SIZE=-1><CENTER>(HTML generated from '"$manpage"'.1 on '"$(date)"' by '$(basename "$0")' )<\/CENTER><\/FONT><\/body>/' \
+  -e 's/&minus;/-/g' \
+  <"$2" >"$htmlpage"
+
+  set +x
+
+  chmod u+rw,go+r,go-w "$htmlpage"
+  echo "Emerged file:"
+  ls -lL "$htmlpage"
+
+else
+
+  export BROWSER='cp "%s" '"$raw_html"
+  man -H "$manpage"
+  "$0" -work_as_filter "$raw_html"
+  rm "$raw_html"
+  rm "$man_dir"/man1
+
+fi
--- a/xorriso/man_xorrisofs_to_html.sh
+++ b/xorriso/man_xorrisofs_to_html.sh
@ -0,0 +1,80 @@
+#!/bin/sh
+
+#
+# man_xorrisofs_to_html.sh - ts A80118 , B10309
+#
+# Generates a HTML version of man page xorrisofs.1
+#
+# To be executed in the libisoburn toplevel directory (eg. ./libisoburn-0.1.0)
+#
+
+# set -x
+
+man_dir=$(pwd)"/xorriso"
+export MANPATH="$man_dir"
+manpage="xorrisofs"
+raw_html=$(pwd)/"xorriso/raw_man_1_xorrisofs.html"
+htmlpage=$(pwd)/"xorriso/man_1_xorrisofs.html"
+
+if test -r "$man_dir"/"$manpage".1
+then
+  dummy=dummy
+else
+  echo "Cannot find readable man page source $1" >&2
+  exit 1
+fi
+
+if test -e "$man_dir"/man1
+then
+  dummy=dummy
+else
+  ln -s . "$man_dir"/man1
+fi
+
+if test "$1" = "-work_as_filter"
+then
+
+#  set -x
+
+  sed \
+  -e 's/<meta name="generator" content="groff -Thtml, see www.gnu.org">/<meta name="generator" content="groff -Thtml, via man -H, via xorriso\/convert_man_to_html.sh">/' \
+  -e 's/<meta name="Content-Style" content="text\/css">/<meta name="Content-Style" content="text\/css"><META NAME="description" CONTENT="man page of xorriso"><META NAME="keywords" CONTENT="man xorrisofs, manual, xorrisofs, ISO 9660, mkisofs, compatible"><META NAME="robots" CONTENT="follow">/' \
+  -e 's/<title>XORRISOFS<\/title>/<title>man 1 xorrisofs<\/title>/' \
+  -e 's/<h1 align=center>XORRISOFS<\/h1>/<h1 align=center>man 1 xorrisofs<\/h1>/' \
+  -e 's/<body>/<body BGCOLOR="#F5DEB3" TEXT=#000000 LINK=#0000A0 VLINK=#800000>/' \
+  -e 's/<b>ISO 9660, Rock Ridge, Joliet, HFS+:<\/b>/\&nbsp;<BR><b>ISO 9660, Rock Ridge, Joliet, HFS+:<\/b>/' \
+  -e 's/<b>Inserting files into the ISO image:<\/b>/\&nbsp;<BR><b>Inserting files into the ISO image:<\/b>/' \
+  -e 's/<b>Relation to program xorriso:<\/b>/\&nbsp;<BR><b>Relation to program xorriso:<\/b>/' \
+  -e 's/EXAMPLES):<br>/<A HREF="#EXAMPLES">EXAMPLES<\/A>):<br>/' \
+  -e 's/<b>Image loading:<\/b>/\&nbsp;<BR><b>Image loading:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Settings for file insertion:<\/b>/\&nbsp;<BR><b>Settings for file insertion:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Settings for image production:<\/b>/\&nbsp;<BR><b>Settings for image production:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Settings for standards compliance:<\/b>/\&nbsp;<BR><b>Settings for standards compliance:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Settings for standards extensions:<\/b>/\&nbsp;<BR><b>Settings for standards extensions:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Settings for file hiding:<\/b>/\&nbsp;<BR><b>Settings for file hiding:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>ISO image ID strings:<\/b>/\&nbsp;<BR><b>ISO image ID strings:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>El Torito Bootable ISO images:<\/b>/\&nbsp;<BR><b>El Torito Bootable ISO images:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>System Area, MBR, other boot blocks:<\/b>/\&nbsp;<BR><b>System Area, MBR, other boot blocks:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Character sets:<\/b>/\&nbsp;<BR><b>Character sets:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Jigdo Template Extraction:<\/b>/\&nbsp;<BR><b>Jigdo Template Extraction:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Miscellaneous options:<\/b>/\&nbsp;<BR><b>Miscellaneous options:<\/b><BR>\&nbsp;<BR>/' \
+\
+  -e 's/<\/body>/<BR><HR><FONT SIZE=-1><CENTER>(HTML generated from '"$manpage"'.1 on '"$(date)"' by '$(basename "$0")' )<\/CENTER><\/FONT><\/body>/' \
+  -e 's/&minus;/-/g' \
+  <"$2" >"$htmlpage"
+
+  set +x
+
+  chmod u+rw,go+r,go-w "$htmlpage"
+  echo "Emerged file:"
+  ls -lL "$htmlpage"
+
+else
+
+  export BROWSER='cp "%s" '"$raw_html"
+  man -H "$manpage"
+  "$0" -work_as_filter "$raw_html"
+  rm "$raw_html"
+  rm "$man_dir"/man1
+
+fi
--- a/xorriso/match.c
+++ b/xorriso/match.c
@ -0,0 +1,786 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2013 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains the implementation of functions for pattern matching.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <time.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include "xorriso.h"
+#include "xorriso_private.h"
+#include "xorrisoburn.h"
+
+
+/* @param flag bit0= do not augment relative structured search by xorriso->wdi
+               bit1= return 2 if bonked at start point by .. 
+                     (caller then aborts or retries without bit0)
+               bit2= eventually prepend wdx rather than wdi
+   @return <=0 error, 1= ok, 2= with bit1: relative pattern exceeds start point
+*/
+int Xorriso_prepare_regex(struct XorrisO *xorriso, char *adr, int flag)
+{
+ int l,ret,i,count,bonked= 0,is_constant,is_still_relative= 0, adr_size;
+ char *cpt,*npt,*adr_part= NULL, *absolute_adr= NULL, *adr_start,*wd;
+
+ adr_size= 2 * SfileadrL;
+ Xorriso_alloc_meM(adr_part, char, adr_size);
+ Xorriso_alloc_meM(absolute_adr, char, adr_size);
+
+ if(flag&4)
+   wd= xorriso->wdx;
+ else
+   wd= xorriso->wdi;
+
+ if(xorriso->search_mode>=2 && xorriso->search_mode<=4) {
+   if(xorriso->search_mode==3 || xorriso->search_mode==4) {
+     l= strlen(adr)+strlen(wd)+1;
+     if(l * 2 + 2 > ((int) sizeof(xorriso->reg_expr)) || l * 2 + 2 > adr_size){
+       sprintf(xorriso->info_text,"Search pattern too long");
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+       {ret= 0; goto ex;}
+     }
+   }
+   Xorriso_destroy_re(xorriso,0);
+   if(xorriso->structured_search && xorriso->search_mode==3) {
+     if(adr[0]!='/')
+       is_still_relative= 1;
+     if(is_still_relative && !(flag&1)) {
+       /* relative expression : prepend working directory */
+       sprintf(absolute_adr,"%s/%s",wd,adr);
+       adr_start= absolute_adr;
+       xorriso->prepended_wd= 1;
+       is_still_relative= 0;
+     } else
+       adr_start= adr;
+     /* count slashes */;
+     cpt= adr_start;
+     while(*cpt=='/')
+       cpt++;
+     for(i= 0;1;i++) {
+       cpt= strchr(cpt,'/');
+       if(cpt==NULL)
+     break;
+       while(*cpt=='/')
+         cpt++;
+     }
+     count= i+1;
+     xorriso->re= TSOB_FELD(regex_t,count);
+     if(xorriso->re==NULL)
+       {ret= -1; goto ex;}
+     xorriso->re_constants= TSOB_FELD(char *,count);
+     if(xorriso->re_constants==NULL)
+       {ret= -1; goto ex;}
+     for(i= 0;i<count;i++)
+       xorriso->re_constants[i]= NULL;
+     xorriso->re_count= count;
+     xorriso->re_fill= 0;
+       
+     /* loop over slash chunks*/;
+     cpt= adr_start;
+     xorriso->re_fill= 0;
+     while(*cpt=='/')
+       cpt++;
+     for(i= 0;i<count;i++) {
+       npt= strchr(cpt,'/');
+       if(npt==NULL) {
+         if((int) strlen(cpt) >= adr_size)
+           {ret= -1; goto ex;}
+         strcpy(adr_part,cpt);
+       } else {
+         if(npt-cpt >= adr_size)
+           {ret= -1; goto ex;}
+         strncpy(adr_part,cpt,npt-cpt);
+         adr_part[npt-cpt]= 0;
+       }
+
+       if(adr_part[0]==0)
+         goto next_adr_part;
+       if(adr_part[0]=='.' && adr_part[1]==0 &&
+          (xorriso->re_fill>0 || i<count-1))
+         goto next_adr_part;
+       if(adr_part[0]=='.' && adr_part[1]=='.' && adr_part[2]==0) {
+         /* delete previous part */
+         if(xorriso->re_fill <= 0) {
+           bonked= 1;
+           goto next_adr_part;
+         } 
+         if(xorriso->re_constants[xorriso->re_fill-1]!=NULL) {
+           free(xorriso->re_constants[xorriso->re_fill-1]);
+           xorriso->re_constants[xorriso->re_fill-1]= NULL;
+         } else
+           regfree(&(xorriso->re[xorriso->re_fill-1]));
+         (xorriso->re_fill)--;
+         goto next_adr_part;
+       }
+       if(strcmp(adr_part,"*")==0) {
+         adr_part[0]= 0;
+         ret= 2;
+       } else
+         ret= Xorriso__bourne_to_reg(adr_part,xorriso->reg_expr,0);
+       if(ret==2) {
+         if(Sregex_string(&(xorriso->re_constants[xorriso->re_fill]),adr_part,0)
+            <=0)
+           {ret= -1; goto ex;}
+       } else {
+         if(regcomp(&(xorriso->re[xorriso->re_fill]),xorriso->reg_expr,0)!=0)
+           goto cannot_compile;
+       }
+       xorriso->re_fill++;
+next_adr_part:;
+       if(i==count-1)
+     break;
+       cpt= npt+1;
+       while(*cpt=='/')
+         cpt++;
+     }
+     if(bonked) {
+       if(flag&2)
+         {ret= 2; goto ex;}
+       sprintf(xorriso->info_text, "Your '..' bonked at the %s directory.",
+               is_still_relative ? "working" : "root");
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE",0);
+       {ret= 0; goto ex;}
+     }
+
+     Xorriso__bourne_to_reg(adr_start,xorriso->reg_expr,0); /* just for show */
+
+   } else { 
+     is_constant= 0;
+     if(strcmp(adr,"*")==0 || adr[0]==0) {
+       is_constant= 1;
+     } else if(xorriso->search_mode==3 || xorriso->search_mode==4) {
+       ret= Xorriso__bourne_to_reg(adr,xorriso->reg_expr,0);
+       is_constant= (ret==2);
+     } else {
+       if(strlen(adr)>=sizeof(xorriso->reg_expr))
+         {ret= -1; goto ex;}
+       strcpy(xorriso->reg_expr,adr);
+     }
+     xorriso->re_count= 0; /* tells matcher that this is not structured */
+     xorriso->re_constants= TSOB_FELD(char *,1);
+     if(xorriso->re_constants==NULL)
+       {ret= -1; goto ex;}
+     xorriso->re_constants[0]= NULL;
+     if(is_constant) {
+       if(strcmp(adr,"*")==0) {
+         if(Sregex_string(&(xorriso->re_constants[0]),"",0)<=0)
+           {ret= -1; goto ex;}
+       } else {
+         if(Sregex_string(&(xorriso->re_constants[0]),adr,0)<=0)
+           {ret= -1; goto ex;}
+       }
+       xorriso->re_fill= 1;
+     } else { 
+       xorriso->re= TSOB_FELD(regex_t,1);
+       if(xorriso->re==NULL)
+         {ret= -1; goto ex;}
+       if(regcomp(&(xorriso->re[0]),xorriso->reg_expr,0)!=0) {
+cannot_compile:;
+         sprintf(xorriso->info_text, "Cannot compile regular expression : %s",
+                 xorriso->reg_expr);
+         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE",0);
+         {ret= 0; goto ex;}
+       }
+     }
+
+   }
+ }
+ ret= 1;
+ex:;
+ Xorriso_free_meM(adr_part);
+ Xorriso_free_meM(absolute_adr);
+ return(ret);
+}
+
+
+/* @param flag bit0= do not shortcut last component of to_match
+               bit1= consider match if regex matches parent of path
+               bit2= retry beginning at failed last component 
+
+ @return 0=match , else no match 
+*/
+int Xorriso_regexec(struct XorrisO *xorriso, char *to_match, int *failed_at,
+                    int flag)
+{
+ int ret,i,re_start= 0,reg_nomatch= -1;
+ char *cpt,*npt, *adr_part= NULL, *mpt;
+
+ Xorriso_alloc_meM(adr_part, char, SfileadrL);
+
+ reg_nomatch= REG_NOMATCH;
+
+ *failed_at= 0;
+ if(!(xorriso->structured_search && xorriso->re_count>0)) {
+   if(xorriso->re_constants!=NULL)
+     if(xorriso->re_constants[0]!=NULL) {
+       if(xorriso->re_constants[0][0]==0)
+         {ret= 0; goto ex;}
+       if(strcmp(xorriso->re_constants[0],to_match)!=0)
+         {ret= reg_nomatch; goto ex;}
+       {ret= 0; goto ex;}
+     }  
+   ret= regexec(&(xorriso->re[0]),to_match,1,xorriso->match,0);
+   goto ex;
+ }
+
+ cpt= to_match;
+ while(*cpt=='/')
+  cpt++;
+ if(flag&4)
+   re_start= xorriso->re_failed_at;
+ if(re_start<0)
+   re_start= 0;
+ for(i= re_start;i<xorriso->re_fill;i++) {
+   *failed_at= i;
+   npt= strchr(cpt,'/');
+   if(npt==NULL) {
+     if(i<xorriso->re_fill-1 && !(flag&1)) 
+       {ret= reg_nomatch; goto ex;} /* this must be the last expression part */
+     mpt= cpt;
+   } else {
+     strncpy(adr_part,cpt,npt-cpt);
+     adr_part[npt-cpt]= 0;
+     mpt= adr_part;
+   }
+   if(xorriso->re_constants[i]!=NULL) {
+     if(xorriso->re_constants[i][0]!=0) /* empty constant matches anything */
+       if(strcmp(xorriso->re_constants[i],mpt)!=0)
+         {ret= reg_nomatch; goto ex;}
+   } else {
+     ret= regexec(&(xorriso->re[i]),mpt,1,xorriso->match,0);
+     if(ret!=0)
+       goto ex;
+   }
+   if(npt==NULL) {
+     if(i>=xorriso->re_fill-1)
+       {ret= 0; goto ex;} /* MATCH */
+     *failed_at= i+1;
+     {ret= reg_nomatch; goto ex;}
+   }
+   cpt= npt+1;
+   while(*cpt=='/')
+     cpt++; 
+ }
+ *failed_at= xorriso->re_fill;
+ if(flag & 2)
+   {ret= 0; goto ex;} /* MATCH */
+ ret= reg_nomatch;
+ex:;
+ Xorriso_free_meM(adr_part);
+ return(ret);
+}
+
+
+int Xorriso_is_in_patternlist(struct XorrisO *xorriso,
+                              struct Xorriso_lsT *patternlist, char *path,
+                              int flag)
+{
+ int ret, failed_at, i= 0;
+ struct Xorriso_lsT *s;
+
+ xorriso->search_mode= 3;
+ xorriso->structured_search= 1;
+
+ for(s= patternlist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
+   ret= Xorriso_prepare_regex(xorriso, Xorriso_lst_get_text(s, 0), 0);
+   if(ret <= 0)
+     return(-1);
+   /* Match path or parent of path */
+   ret= Xorriso_regexec(xorriso, path, &failed_at, 2);
+   if(ret == 0)
+     return(i + 1);
+   i++;
+ }
+ return(0);
+}
+
+
+char *Xorriso_get_pattern(struct XorrisO *xorriso,
+                          struct Xorriso_lsT *patternlist, int index, int flag)
+{
+ int i= 0;
+ struct Xorriso_lsT *s;
+
+ for(s= patternlist; s != NULL; s= Xorriso_lst_get_next(s, 0)) {
+   if(i == index)
+     return(Xorriso_lst_get_text(s, 0));
+   i++;
+ }
+ return(NULL);
+}
+
+
+
+/* @param flag bit2= this is a disk_pattern
+   @return <=0 failure , 1 pattern ok , 2 pattern needed prepended wd */
+int Xorriso_prepare_expansion_pattern(struct XorrisO *xorriso, char *pattern,
+                                      int flag)
+{
+ int ret, prepwd= 0;
+
+ ret= Xorriso_prepare_regex(xorriso, pattern, 1|2|(flag&4));
+ if(ret==2) {
+   ret= Xorriso_prepare_regex(xorriso, pattern, flag&4);
+   prepwd= 1;
+ }
+ if(ret<=0) {
+   sprintf(xorriso->info_text,
+           "Cannot compile pattern to regular expression:  %s", pattern);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   return(0);
+ }
+ return(1+prepwd);
+}
+
+
+/* @param flag bit0= count results rather than storing them
+               bit1= unexpected change of number is a FATAL event
+   @return <=0 error , 1 is root (end processing) ,
+                       2 is not root (go on processing)
+*/
+int Xorriso_check_for_root_pattern(struct XorrisO *xorriso, 
+               int *filec, char **filev, int count_limit, off_t *mem, int flag)
+{
+ if(xorriso->re_fill!=0)
+   return(2);
+ /* This is the empty pattern representing root */
+ if(flag&1) {
+   (*filec)++;
+   (*mem)+= 8;
+ } else {
+   if(*filec >= count_limit) {
+     sprintf(xorriso->info_text,
+            "Number of matching files changed unexpectedly (> %d)",
+             count_limit);
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
+                         (flag&2 ? "FATAL" : "WARNING"), 0);
+     return(flag&2 ? -1 : 0);
+   }
+   filev[*filec]= strdup("/");
+   if(filev[*filec]==NULL) {
+     Xorriso_no_pattern_memory(xorriso, (off_t) 2, 0);
+     return(-1);
+   }
+   (*filec)++;
+ }
+ return(1);
+}
+
+
+/* @param flag bit0= count result rather than storing it
+               bit1= unexpected change of number is a FATAL event
+*/
+int Xorriso_register_matched_adr(struct XorrisO *xorriso,
+                                char *adr, int count_limit,
+                                int *filec, char **filev, off_t *mem, int flag)
+{
+ int l;
+
+ if(flag&1) {
+   (*filec)++;
+   l= strlen(adr)+1;
+   (*mem)+= sizeof(char *)+l;
+   if(l % sizeof(char *))
+     (*mem)+= sizeof(char *)-(l % sizeof(char *));
+ } else {
+   if(*filec >= count_limit) {
+     sprintf(xorriso->info_text,
+         "Number of matching files changed unexpectedly (> %d)",
+         count_limit);
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
+                         (flag&2 ? "FATAL" : "WARNING"), 0);
+     return(flag&2 ? -1 : 0);
+   }
+   filev[*filec]= strdup(adr);
+   if(filev[*filec]==NULL) {
+     Xorriso_no_pattern_memory(xorriso, (off_t) (strlen(adr)+1), 0);
+     return(-1);
+   }
+   (*filec)++;
+ }
+ return(1);
+}
+
+
+/* @param flag bit0= count results rather than storing them
+               bit1= this is a recursion
+               bit2= prepend wd (automatically done if wd[0]!=0)
+   @return <=0 error , 1 ok , 2 could not open directory
+*/
+int Xorriso_obtain_pattern_files_x(
+       struct XorrisO *xorriso, char *wd, char *dir_adr,
+       int *filec, char **filev, int count_limit, off_t *mem,
+       int *dive_count, int flag)
+{
+ int ret, failed_at, follow_mount, follow_links;
+ struct DirseQ *dirseq= NULL;
+ struct stat stbuf;
+ dev_t dir_dev;
+ char *path;
+ char *adr= NULL, *name= NULL, *path_data= NULL;
+
+ adr= malloc(SfileadrL);
+ name= malloc(SfileadrL);
+ path_data= malloc(SfileadrL);
+ if(adr==NULL || name==NULL || path_data==NULL) {
+   Xorriso_no_malloc_memory(xorriso, &adr, 0);
+   {ret= -1; goto ex;}
+ }
+ follow_mount= (xorriso->do_follow_mount || xorriso->do_follow_pattern);
+ follow_links= (xorriso->do_follow_links || xorriso->do_follow_pattern);
+ if(!(flag&2))
+   *dive_count= 0;
+ else
+   (*dive_count)++;
+
+ ret= Xorriso_check_for_root_pattern(xorriso, filec, filev, count_limit,
+                                     mem, flag&1);
+ if(ret!=2)
+   goto ex;
+
+ if(lstat(dir_adr, &stbuf)==-1)
+   {ret= 2; goto ex;}
+ dir_dev= stbuf.st_dev;
+ if(S_ISLNK(stbuf.st_mode)) {
+   if(stat(dir_adr, &stbuf)==-1)
+     {ret= 2; goto ex;}
+   if(dir_dev != stbuf.st_dev && !follow_mount)
+     {ret= 2; goto ex;}
+ }
+ ret= Dirseq_new(&dirseq, dir_adr, 1);
+ if(ret<0) {
+   sprintf(xorriso->info_text, "Cannot obtain disk directory iterator");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   {ret= -1; goto ex;}
+ }
+ if(ret==0)
+   {ret= 2; goto ex;}
+
+ while(1) {
+   ret= Dirseq_next_adr(dirseq,name,0);
+   if(ret==0)
+ break;
+   if(ret<0) {
+     sprintf(xorriso->info_text,"Failed to obtain next directory entry");
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+     {ret= -1; goto ex;}
+   }
+
+   ret= Xorriso_make_abs_adr(xorriso, wd, name, adr, flag&4);
+   if(ret<=0)
+     goto ex;
+
+   ret= Xorriso_regexec(xorriso, adr, &failed_at, 1);
+   if(ret>0) { /* no match */
+     if(failed_at <= *dive_count) /* no hope for a match */
+ continue;
+     path= adr;
+     if(adr[0]!='/') {
+       path= path_data;
+       ret= Xorriso_make_abs_adr(xorriso, xorriso->wdx, adr, path, 1|4);
+       if(ret<=0)
+         goto ex;
+     }
+
+     if(follow_links)
+       ret= stat(path,&stbuf);
+     else
+       ret= lstat(path,&stbuf);
+     if(ret==-1)
+ continue;
+     if(!S_ISDIR(stbuf.st_mode))
+ continue;
+     if(dir_dev != stbuf.st_dev && !follow_mount)
+ continue;
+
+     /* dive deeper */
+     ret= Xorriso_obtain_pattern_files_x(xorriso, adr, path,
+                           filec, filev, count_limit, mem, dive_count, flag|2);
+     if(ret<=0)
+       goto ex;
+   } else {
+     ret= Xorriso_register_matched_adr(xorriso, adr, count_limit,
+                                       filec, filev, mem, flag&1);
+     if(ret<0)
+       goto ex;
+     if(ret==0)
+ break;
+   }
+ } 
+ ret= 1;
+ex:;
+ if(adr!=NULL)
+   free(adr);
+ if(name!=NULL)
+   free(name);
+ if(path_data!=NULL)
+   free(path_data);
+ Dirseq_destroy(&dirseq,0);
+ if(flag&2)
+   (*dive_count)--;
+ return(ret);
+}
+
+
+int Xorriso_eval_nonmatch(struct XorrisO *xorriso, char *pattern,
+                          int *nonconst_mismatches, off_t *mem, int flag)
+{
+ int k,l;
+
+ /* Is this a constant pattern ? */
+ for(k= 0; k<xorriso->re_fill; k++) {
+   if(xorriso->re_constants[k]==NULL)
+ break;
+   if(xorriso->re_constants[k][0]==0)
+ break;
+ }
+ if(k<xorriso->re_fill)
+   (*nonconst_mismatches)++; /* it is not */
+
+ l= strlen(pattern)+1;
+ (*mem)+= sizeof(char *)+l;
+ if(l % sizeof(char *))
+   (*mem)+= sizeof(char *)-(l % sizeof(char *));
+ return(1);
+}
+
+
+/* @param flag bit0= a match count !=1 is a SORRY event
+               bit1= a match count !=1 is a FAILURE event
+*/
+int Xorriso_check_matchcount(struct XorrisO *xorriso,
+                int count, int nonconst_mismatches, int num_patterns,
+                char **patterns, int flag)
+{
+
+ if((flag&1) && (count!=1 || nonconst_mismatches)){
+   if(count-nonconst_mismatches>0)
+     sprintf(xorriso->info_text,
+             "Pattern match with more than one file object");
+   else
+     sprintf(xorriso->info_text, "No pattern match with any file object");
+   if(num_patterns==1)
+     sprintf(xorriso->info_text+strlen(xorriso->info_text), ": ");
+   Text_shellsafe(patterns[0], xorriso->info_text, 1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, 
+                       (flag&2 ? "FAILURE" : "SORRY"), 0);
+   return(0);
+ }
+ return(1);
+}
+
+
+int Xorriso_no_pattern_memory(struct XorrisO *xorriso, off_t mem, int flag)
+{
+ char mem_text[80];
+
+ Sfile_scale((double) mem, mem_text,5,1e4,1);
+ sprintf(xorriso->info_text,
+         "Cannot allocate enough memory (%s) for pattern expansion",
+         mem_text);
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+ return(1);
+}
+
+
+int Xorriso_alloc_pattern_mem(struct XorrisO *xorriso, off_t mem, 
+                              int count, char ***filev, int flag)
+{
+ char mem_text[80], limit_text[80];
+
+ Sfile_scale((double) mem, mem_text,5,1e4,0);
+ sprintf(xorriso->info_text,
+         "Temporary memory needed for pattern expansion : %s", mem_text);
+ if(!(flag&1))
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
+ if(mem > xorriso->temp_mem_limit) {
+   Sfile_scale((double) xorriso->temp_mem_limit, limit_text,5,1e4,1);
+   sprintf(xorriso->info_text,
+           "List of matching file addresses exceeds -temp_mem_limit (%s > %s)",
+           mem_text, limit_text);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   return(0);
+ }
+
+ (*filev)= (char **) calloc(count, sizeof(char *));
+ if(*filev==NULL) {
+   Xorriso_no_pattern_memory(xorriso, mem, 0);
+   return(-1);
+ }
+ return(1);
+}
+
+
+/* @param flag bit0= a match count !=1 is a FAILURE event
+               bit1= with bit0 tolerate 0 matches if pattern is a constant
+*/
+int Xorriso_expand_disk_pattern(struct XorrisO *xorriso,
+                           int num_patterns, char **patterns, int extra_filec,
+                           int *filec, char ***filev, off_t *mem, int flag)
+{
+ int ret, count= 0, abs_adr= 0, i, was_count, was_filec;
+ int nonconst_mismatches= 0, dive_count= 0;
+ char *dir_adr= NULL;
+
+ Xorriso_alloc_meM(dir_adr, char, SfileadrL);
+
+ *filec= 0;
+ *filev= NULL;
+
+ xorriso->search_mode= 3;
+ xorriso->structured_search= 1;
+
+ for(i= 0; i<num_patterns; i++) {
+
+   ret= Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 4);
+   if(ret<=0)
+     goto ex;
+   if(ret==2)
+     abs_adr= 4;
+
+   if(patterns[i][0]=='/' || abs_adr) {
+     strcpy(dir_adr, "/");
+     abs_adr= 4;
+   } else {
+     strcpy(dir_adr, xorriso->wdx);
+     if(dir_adr[0]==0)
+       strcpy(dir_adr, "/");
+     ret= Sfile_type(dir_adr, 1|4);
+     if(ret!=2) {
+       Xorriso_msgs_submit(xorriso, 0, dir_adr, 0, "ERRFILE", 0);
+       sprintf(xorriso->info_text, "Address set by -cdx is not a directory: ");
+       Text_shellsafe(dir_adr, xorriso->info_text, 1);
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+       ret= 0; goto ex;
+     }
+   }
+
+   /* count the matches */
+   was_count= count;
+   ret= Xorriso_obtain_pattern_files_x(xorriso, "", dir_adr, &count, NULL, 0,
+                                       mem, &dive_count, 1 | abs_adr);
+   if(ret<=0)
+     goto ex;
+   if(was_count==count && strcmp(patterns[i],"*")!=0 && (flag&3)!=1) {
+     count++;
+     ret= Xorriso_eval_nonmatch(xorriso, patterns[i],
+                                &nonconst_mismatches, mem, 0);
+     if(ret<=0)
+       goto ex;
+   }
+ }
+
+ ret= Xorriso_check_matchcount(xorriso, count, nonconst_mismatches,
+                               num_patterns, patterns, (flag&1)|2);
+ if(ret<=0)
+   goto ex;
+
+ count+= extra_filec;
+ mem+= extra_filec*sizeof(char *);
+
+ if(count<=0)
+   {ret= 0; goto ex;}
+
+ ret= Xorriso_alloc_pattern_mem(xorriso, *mem, count, filev, 0);
+ if(ret<=0)
+   goto ex;
+
+ /* now store addresses */
+ for(i= 0; i<num_patterns; i++) {
+
+   ret= Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 4);
+   if(ret<=0)
+     goto ex;
+
+   if(patterns[i][0]=='/' || abs_adr) {
+     strcpy(dir_adr, "/");
+     abs_adr= 4;
+   } else {
+     strcpy(dir_adr, xorriso->wdx);
+     if(dir_adr[0]==0)
+       strcpy(dir_adr, "/");
+   }
+
+   was_filec= *filec;
+   ret= Xorriso_obtain_pattern_files_x(xorriso, "", dir_adr, filec, *filev,
+                                       count, mem, &dive_count, abs_adr);
+   if(ret<=0)
+     goto ex;
+
+   if(was_filec == *filec && strcmp(patterns[i],"*")!=0) {
+     (*filev)[*filec]= strdup(patterns[i]);
+     if((*filev)[*filec]==NULL) {
+       (*mem)= strlen(patterns[i])+1;
+       Xorriso_no_pattern_memory(xorriso, *mem, 0);
+       ret= -1; goto ex;
+     }
+     (*filec)++;
+   } 
+ }
+
+ ret= 1;
+ex:;
+ if(ret<=0) {
+   if(filev!=NULL)
+     Sfile_destroy_argv(&count, filev, 0);
+   *filec= 0;
+ }
+ Xorriso_free_meM(dir_adr);
+ return(ret);
+}
+
+
+/* @param flag bit0= command without pattern capability
+               bit1= disk_pattern rather than iso_rr_pattern
+*/
+int Xorriso_warn_of_wildcards(struct XorrisO *xorriso, char *path, int flag)
+{
+ static int count_iso= 0, count_disk= 0, max_iso= 3, max_disk= 3;
+
+ if(strchr(path,'*')!=NULL || strchr(path,'?')!=NULL ||
+    strchr(path,'[')!=NULL) {
+   if(flag & 2) {
+     count_disk++;
+     if(count_disk > max_disk)
+       return(1);
+   } else {
+     count_iso++;
+     if(count_iso > max_iso)
+       return(1);
+   }
+   if(flag&1) {
+     sprintf(xorriso->info_text,
+      "Pattern expansion of wildcards \"*?[\" does not apply to this command");
+   } else {
+     sprintf(xorriso->info_text,
+            "Pattern expansion of wildcards \"*?[\" is disabled by command %s",
+            (flag&2) ? "-disk_pattern or -pathspecs" : "-iso_rr_pattern");
+   }
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
+   sprintf(xorriso->info_text,"Pattern seen: ");
+   Text_shellsafe(path, xorriso->info_text, 1);
+   strcat(xorriso->info_text, "\n");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
+   return(1);
+ }
+ return(0);
+}
+
--- a/xorriso/match.h
+++ b/xorriso/match.h
@ -0,0 +1,74 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains the implementation of functions for pattern matching.
+*/
+
+
+#ifndef Xorriso_pvt_match_includeD
+#define Xorriso_pvt_match_includeD yes
+
+
+int Xorriso_prepare_regex(struct XorrisO *xorriso, char *adr, int flag);
+
+/* @return 0=match , else no match
+*/
+int Xorriso_regexec(struct XorrisO *xorriso, char *to_match, int *failed_at,
+                    int flag);
+
+int Xorriso_is_in_patternlist(struct XorrisO *xorriso,
+                        struct Xorriso_lsT *patternlist, char *path, int flag);
+
+char *Xorriso_get_pattern(struct XorrisO *xorriso,
+                         struct Xorriso_lsT *patternlist, int index, int flag);
+
+int Xorriso_prepare_expansion_pattern(struct XorrisO *xorriso, char *pattern,
+                                      int flag);
+
+/* @param flag bit0= count results rather than storing them
+   @return <=0 error , 1 is root (end processing) ,
+                       2 is not root (go on processing) 
+*/
+int Xorriso_check_for_root_pattern(struct XorrisO *xorriso,
+              int *filec, char **filev, int count_limit, off_t *mem, int flag);
+
+/* @param flag bit0= count result rather than storing it
+               bit1= unexpected change of number is a FATAL event
+*/
+int Xorriso_register_matched_adr(struct XorrisO *xorriso,
+                               char *adr, int count_limit,
+                               int *filec, char **filev, off_t *mem, int flag);
+
+int Xorriso_eval_nonmatch(struct XorrisO *xorriso, char *pattern,
+                          int *nonconst_mismatches, off_t *mem, int flag);
+
+/* @param flag bit0= a match count !=1 is a SORRY event
+*/
+int Xorriso_check_matchcount(struct XorrisO *xorriso,
+                int count, int nonconst_mismatches, int num_patterns,
+                char **patterns, int flag);
+
+int Xorriso_no_pattern_memory(struct XorrisO *xorriso, off_t mem, int flag);
+
+int Xorriso_alloc_pattern_mem(struct XorrisO *xorriso, off_t mem,
+                              int count, char ***filev, int flag);
+
+/* @param flag bit0= command without pattern capability
+               bit1= disk_pattern rather than iso_rr_pattern
+*/
+int Xorriso_warn_of_wildcards(struct XorrisO *xorriso, char *path, int flag);
+
+/* @param flag bit0= a match count !=1 is a FAILURE event
+               bit1= with bit0 tolerate 0 matches if pattern is a constant
+*/
+int Xorriso_expand_disk_pattern(struct XorrisO *xorriso,
+                           int num_patterns, char **patterns, int extra_filec,
+                           int *filec, char ***filev, off_t *mem, int flag);
+
+
+#endif /* ! Xorriso_pvt_match_includeD */
+
--- a/xorriso/misc_funct.c
+++ b/xorriso/misc_funct.c
--- a/xorriso/misc_funct.h
+++ b/xorriso/misc_funct.h
@ -0,0 +1,99 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2012 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of cellaneous helper functions of xorriso.
+*/
+
+
+#ifndef Xorriso_pvt_misc_includeD
+#define Xorriso_pvt_misc_includeD yes
+
+#include <regex.h>
+
+
+char *Text_shellsafe(char *in_text, char *out_text, int flag);
+
+int Sort_argv(int argc, char **argv, int flag);
+
+/* @param flag bit0= single letters */
+char *Ftypetxt(mode_t st_mode, int flag);
+
+/* @param flag bit0=with year and seconds
+               bit1=timestamp format YYYY.MM.DD.hhmmss
+*/
+char *Ftimetxt(time_t t, char timetext[40], int flag);
+
+int System_uname(char **sysname, char **release, char **version, 
+                 char **machine, int flag);
+
+/** Convert a text into a number of type double and multiply it by unit code
+    [kmgtpe] (2^10 to 2^60) or [s] (2048). (Also accepts capital letters.)
+    @param text Input like "42", "2k", "3.14m" or "-1g"
+    @param flag Bitfield for control purposes:
+                bit0= return -1 rathern than 0 on failure
+    @return The derived double value
+*/
+double Scanf_io_size(char *text, int flag);
+
+/*
+   @flag        bit0= do not initialize *diff_count
+   @return  <0 error , 0 = mismatch , 1 = match
+*/
+int Compare_text_lines(char *text1, char *text2, int *diff_count, int flag);
+
+time_t Decode_timestring(char *code, time_t *date, int flag);
+
+int Decode_ecma119_format(struct tm *erg, char *text, int flag);
+
+int Wait_for_input(int fd, int microsec, int flag);
+
+int Fileliste__target_source_limit(char *line, char sep, char **limit_pt,
+                                    int flag);
+
+int Fileliste__escape_source_path(char *line, int size, int flag);
+
+int Hex_to_bin(char *hex,
+              int bin_size, int *bin_count, unsigned char *bin_data, int flag);
+
+
+/* bit0= append (text!=NULL) */
+int Sregex_string(char **handle, char *text, int flag);
+
+/* @param flag bit0= only test expression whether compilable
+*/
+int Sregex_match(char *pattern, char *text, int flag);
+
+/*
+  vars[][0] points to the variable names, vars[][1] to their contents.
+  start marks the begin of variable names. It must be non-empty. esc before
+  start disables this meaning. start and esc may be equal but else they must
+  have disjoint character sets.
+  end marks the end of a variable name. It may be empty but if non-empty it
+  must not appear in vars[][0].
+  @param flag bit0= Substitute unknown variables by empty text
+                    (else copy start,name,end unaltered to result).
+                    Parameter end must be non-empty for that.
+*/
+int Sregex_resolve_var(char *form, char *vars[][2], int num_vars,
+                       char *start, char *end, char *esc,
+                       char *result, int result_size, int flag);
+
+/* reg_expr should be twice as large as bourne_expr ( + 2 to be exact) */
+/* return: 2= bourne_expr is surely a constant */
+int Xorriso__bourne_to_reg(char bourne_expr[], char reg_expr[], int flag);
+
+
+int Xorriso__hide_mode(char *mode, int flag);
+
+char *Xorriso__hide_mode_text(int hide_mode, int flag);
+
+/* @return 0=truncated, 1=ok
+*/
+int Xorriso__to_upper(char *in, char *out, int out_size, int flag);
+
+#endif /* ! Xorriso_pvt_misc_includeD */
+
--- a/xorriso/opts_a_c.c
+++ b/xorriso/opts_a_c.c
--- a/xorriso/opts_d_h.c
+++ b/xorriso/opts_d_h.c
--- a/xorriso/opts_i_o.c
+++ b/xorriso/opts_i_o.c
--- a/xorriso/opts_p_z.c
+++ b/xorriso/opts_p_z.c
--- a/xorriso/parse_exec.c
+++ b/xorriso/parse_exec.c
--- a/xorriso/parse_exec.h
+++ b/xorriso/parse_exec.h
@ -0,0 +1,97 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which deal with parsing
+   and interpretation of command input.
+*/
+
+
+#ifndef Xorriso_pvt_cmd_includeD
+#define Xorriso_pvt_cmd_includeD yes
+
+
+/* @param flag bit0= do not warn of wildcards
+               bit1= these are disk_paths
+*/
+int Xorriso_end_idx(struct XorrisO *xorriso,
+                    int argc, char **argv, int idx, int flag);
+
+int Xorriso_opt_args(struct XorrisO *xorriso, char *cmd,
+                     int argc, char **argv, int idx,
+                     int *end_idx, int *optc, char ***optv, int flag);
+
+int Xorriso_get_problem_status(struct XorrisO *xorriso, char severity[80],
+                               int flag);
+
+int Xorriso_set_problem_status(struct XorrisO *xorriso, char *severity,
+                               int flag);
+
+/**
+    @param flag       bit0= do not issue own event messages
+                      bit1= take xorriso->request_to_abort as reason for abort
+    @return           Gives the advice:
+                        2= pardon was given, go on
+                        1= no problem, go on
+                        0= function failed but xorriso would not abort, go on
+                       <0= do abort
+                           -1 = due to problem_status
+                           -2 = due to xorriso->request_to_abort
+*/
+int Xorriso_eval_problem_status(struct XorrisO *xorriso, int ret, int flag);
+
+int Xorriso_cpmv_args(struct XorrisO *xorriso, char *cmd,
+                      int argc, char **argv, int *idx,
+                      int *optc, char ***optv, char eff_dest[SfileadrL],
+                      int flag);
+
+/* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high
+*/
+int Xorriso_decode_load_adr(struct XorrisO *xorriso, char *cmd,
+                            char *adr_mode, char *adr_value,
+                            int *entity_code, char entity_id[81],
+                            int flag);
+
+int Xorriso_check_name_len(struct XorrisO *xorriso, char *name, int size,
+                           char *cmd, int flag);
+
+/* @param flag bit0= prepend wd only if name does not begin by '/'
+               bit2= prepend wd (automatically done if wd[0]!=0)
+*/
+int Xorriso_make_abs_adr(struct XorrisO *xorriso, char *wd, char *name,
+                             char adr[], int flag);
+
+/* @param flag bit0= do not complain in case of error, but set info_text */
+int Xorriso_convert_datestring(struct XorrisO *xorriso, char *cmd,
+                               char *time_type, char *timestring,
+                               int *t_type, time_t *t, int flag);
+
+int Xorriso_check_temp_mem_limit(struct XorrisO *xorriso, off_t mem, int flag);
+
+/* @param flag bit0= use env_path to find the desired program
+*/
+int Xorriso_execv(struct XorrisO *xorriso, char *cmd, char *env_path,
+                  int *status, int flag);
+
+int Xorriso_path_is_excluded(struct XorrisO *xorriso, char *path, int flag);
+
+int Xorriso_path_is_hidden(struct XorrisO *xorriso, char *path, int flag);
+
+
+/* Normalize ACL and sort apart "access" ACL from "default" ACL.
+ */
+int Xorriso_normalize_acl_text(struct XorrisO *xorriso, char *in_text,
+                    char **access_acl_text, char **default_acl_text, int flag);
+
+int Xorriso_read_mkisofsrc(struct XorrisO *xorriso, int flag);
+
+/* @param flag bit0= list sorting order rather than looking for argv[idx]
+*/
+int Xorriso_cmd_sorting_rank(struct XorrisO *xorriso,
+                        int argc, char **argv, int idx, int flag);
+
+#endif /* ! Xorriso_pvt_cmd_includeD */
+
--- a/xorriso/read_run.c
+++ b/xorriso/read_run.c
--- a/xorriso/read_run.h
+++ b/xorriso/read_run.h
@ -0,0 +1,70 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which 
+*/
+
+
+#ifndef Xorriso_pvt_read_run_includeD
+#define Xorriso_pvt_read_run_includeD yes
+
+
+int Xorriso__read_pacifier(IsoImage *image, IsoFileSource *filesource);
+
+int Xorriso_restore_properties(struct XorrisO *xorriso, char *disk_path,
+                                IsoNode *node, int flag);
+
+int Xorriso_restore_implicit_properties(struct XorrisO *xorriso,
+         char *full_disk_path, char *disk_path, char *full_img_path, int flag);
+
+int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
+                              char *img_path, off_t img_offset,
+                              char *disk_path, off_t disk_offset, off_t bytes,
+                              int flag);
+
+int Xorriso_restore_overwrite(struct XorrisO *xorriso,
+                              IsoNode *node, char *img_path,
+                              char *path, char *nominal_path,
+                              struct stat *stbuf, int flag);
+
+int Xorriso_restore_target_hl(struct XorrisO *xorriso, IsoNode *node,
+                           char *disk_path, int *node_idx, int flag);
+
+int Xorriso_restore_prefix_hl(struct XorrisO *xorriso, IsoNode *node,
+                              char *disk_path, int node_idx, int flag);
+
+int Xorriso_register_node_target(struct XorrisO *xorriso, int node_idx,
+                                 char *disk_path, int flag);
+
+int Xorriso_restore_disk_object(struct XorrisO *xorriso,
+                                char *img_path, IsoNode *node,
+                                char *disk_path,
+                                off_t offset, off_t bytes, int flag);
+
+int Xorriso_handle_collision(struct XorrisO *xorriso,
+                             IsoNode *node, char *img_path,
+                             char *disk_path, char *nominal_disk_path,
+                             int *stbuf_ret, int flag);
+
+int Xorriso_restore_tree(struct XorrisO *xorriso, IsoDir *dir,
+                         char *img_dir_path, char *disk_dir_path,
+                         off_t boss_mem,
+                         struct LinkiteM *link_stack, int flag);
+
+int Xorriso_read_file_data(struct XorrisO *xorriso, IsoNode *node,
+                           char *img_path, char *disk_path,
+                           off_t img_offset, off_t disk_offset,
+                           off_t bytes, int flag);
+
+
+
+
+
+
+
+#endif /* ! Xorriso_pvt_read_run_includeD */
+
--- a/xorriso/sfile.c
+++ b/xorriso/sfile.c
@ -0,0 +1,938 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2012 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains the implementation of functions around files and strings.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <time.h>
+#include <pwd.h>
+#include <grp.h>
+
+
+#include "sfile.h"
+
+
+/* @param flag bit0= do not clip off carriage return at line end
+*/
+char *Sfile_fgets_n(char *line, int maxl, FILE *fp, int flag)
+{
+ int l;
+ char *ret;
+
+ ret= fgets(line,maxl,fp);
+ if(ret==NULL)
+   return(NULL);
+ l= strlen(line);
+ if(l > 0 && !(flag & 1)) if(line[l-1] == '\r') line[--l]= 0;
+ if(l > 0) if(line[l-1] == '\n') line[--l]= 0;
+ if(l > 0 && !(flag & 1)) if(line[l-1] == '\r') line[--l]= 0;
+ return(ret);
+}
+
+
+int Sfile_count_char(char *text, char to_count)
+{
+ int count= 0;
+ char *cpt;
+
+ for(cpt= text; *cpt != 0; cpt++)
+   if(*cpt == to_count)
+     count++;
+ return count;
+}
+
+
+int Sfile_count_components(char *path, int flag)
+/*
+ bit0= do not ignore trailing slash
+ bit1= do not ignore empty components (other than the empty root name)
+*/
+{
+ int l,count= 0;
+ char *cpt;
+
+ l= strlen(path);
+ if(l==0)
+   return(0);
+ count= 1;
+ for(cpt= path+l-1;cpt>=path;cpt--) { 
+   if(*cpt=='/') {
+     if(*(cpt+1)==0   && !(flag&1))
+ continue;
+     if(*(cpt+1)=='/' && !(flag&2))
+ continue;
+     count++;
+   }
+ }
+ return(count);
+}
+
+
+int Sfile_component_pointer(char *path, char **sourcept, int idx, int flag)
+/*
+ bit0= do not ignore trailing slash
+ bit1= do not ignore empty components (other than the empty root name)
+ bit2= accept 0 as '/'
+*/
+{
+ int count= 0;
+ char *spt;
+
+ for(spt= path;*spt!=0 || (flag&4);spt++) {
+   if(count>=idx) {
+     *sourcept= spt;
+     return(1);
+   }
+   if(*spt=='/' || *spt==0) {
+     if(*(spt+1)=='/' && !(flag&2))
+ continue;
+     if(*(spt+1)==0 && !(flag&1))
+ continue;
+     count++;
+   }
+ }
+ if((flag&1) && count>=idx)
+   return(1);
+ return(0);
+}
+
+
+int Sfile_leafname(char *path, char leafname[SfileadrL], int flag)
+{
+ int count, ret;
+ char *lpt;
+
+ leafname[0]= 0;
+ count= Sfile_count_components(path, 0);
+ if(count==0)
+   return(0);
+ ret= Sfile_component_pointer(path, &lpt, count-1, 0);
+ if(ret<=0)
+   return(ret);
+ if(Sfile_str(leafname, lpt, 0)<=0)
+   return(0);
+ lpt= strchr(leafname, '/');
+ if(lpt!=NULL)
+   *lpt= 0;
+ return(1);
+} 
+
+
+int Sfile_add_to_path(char path[SfileadrL], char *addon, int flag)
+{
+ int l;
+
+ l= strlen(path);
+ if(l+1>=SfileadrL)
+   return(0);
+ if(l==0) {
+   strcpy(path,"/");
+   l= 1;
+ } else if(path[l-1]!='/') {
+   path[l++]= '/';
+   path[l]= 0;
+ }
+ if(l+strlen(addon)>=SfileadrL)
+   return(0);
+ if(addon[0]=='/')
+   strcpy(path+l,addon+1);
+ else
+   strcpy(path+l,addon);
+ return(1);
+}
+
+
+int Sfile_prepend_path(char *prefix, char path[SfileadrL], int flag)
+{
+ int l, i, slashes, prefix_len, path_len;
+
+ l= strlen(prefix);
+ if(l == 0)
+   return(1);
+
+ /* Do not copy slashes between both parts */
+ for(prefix_len= l; prefix_len > 0; prefix_len--)
+   if(prefix[prefix_len - 1] != '/')
+ break;
+ if(prefix_len == 0)
+   prefix_len= strlen(prefix) - 1; 
+ path_len= strlen(path);
+ for(slashes= 0; slashes < path_len; slashes++)
+   if(path[slashes] != '/')
+ break;
+
+ l= (strlen(path) - slashes) + prefix_len + 1;
+ if(l>=SfileadrL) {
+
+#ifdef Not_yeT
+   /* >>> ??? how to transport messages to xorriso ? */
+   sprintf(xorriso->info_text,
+           "Combination of wd and relative address too long (%d > %d)",
+           l,SfileadrL-1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+#endif
+
+   return(-1);
+ }
+ l-= strlen(path);
+ if(l < 0) {
+   for(i= slashes; i <= path_len + 1; i++)
+     path[i+l]= path[i];
+ } else if(l > 0) {
+   for(i= path_len + 1; i >= slashes; i--)
+     path[i+l]= path[i];
+ }
+ if(prefix_len > 0)
+   memcpy(path, prefix, prefix_len);
+ path[l - 1 + slashes]= '/';
+ return(1);
+}
+
+int Sfile_being_group_member(struct stat *stbuf, int flag)
+{
+ int i, suppl_groups;
+ gid_t *suppl_glist;
+
+ if (getegid()==stbuf->st_gid)
+   return(1);
+ suppl_groups= getgroups(0, NULL);
+ suppl_glist= (gid_t *) malloc((suppl_groups + 1) * sizeof(gid_t));
+ if (suppl_glist==NULL)
+   return(-1);
+ suppl_groups= getgroups(suppl_groups+1,suppl_glist);
+ for (i= 0; i<suppl_groups; i++) {
+   if (suppl_glist[i]==stbuf->st_gid) {
+     free((char *) suppl_glist);
+     return(1);
+   }
+ }
+ free((char *) suppl_glist);
+ return(0);
+}
+
+
+int Sfile_type(char *filename, int flag)
+/*
+ bit0= return -1 if file is missing 
+ bit1= return a hardlink with siblings as type 5
+ bit2= evaluate eventual link target rather than the link object itself
+ bit3= return a socket or a char device as types 7 or 8 rather than 0
+*/
+/*
+ return:
+  0=unknown
+  1=regular
+  2=directory
+  3=symbolic link
+  4=named pipe
+  5=multiple hardlink (with bit1)
+  6=block device
+  7=socket (with bit3)
+  8=character device (with bit3)
+*/
+{
+ struct stat stbuf;
+ if(flag&4) {
+   if(stat(filename,&stbuf)==-1) {
+     if(flag&1) return(-1);
+     else       return(0);
+   }
+ } else {
+   if(lstat(filename,&stbuf)==-1) {
+     if(flag&1) return(-1);
+     else       return(0);
+   }
+ }
+ if(S_ISREG(stbuf.st_mode)) {
+   if(flag&2)
+     if(stbuf.st_nlink>1)
+       return(5);
+   return(1);
+ }
+ if(S_ISDIR(stbuf.st_mode))
+   return(2);
+ if((stbuf.st_mode&S_IFMT)==S_IFLNK)
+   return(3);
+ if(S_ISFIFO(stbuf.st_mode))
+   return(4);
+ if(S_ISBLK(stbuf.st_mode))
+   return(6);
+ if(flag&8)
+   if((stbuf.st_mode&S_IFMT)==S_IFSOCK)
+     return(7);
+ if(flag&8)
+   if(S_ISCHR(stbuf.st_mode))
+     return(8);
+ return(0);
+}
+
+
+char *Sfile_datestr(time_t tim, short int flag)
+/*
+ bit0=with hours+minutes  
+ bit1=with seconds
+
+ bit8= local time rather than UTC
+*/
+{
+ static char zeitcode[80]={"000000"};
+ char puff[80];
+ struct tm *azt;
+
+ if(flag&256) 
+   azt = localtime(&tim);
+ else
+   azt = gmtime(&tim);
+ 
+ if(azt->tm_year>99)
+   sprintf(zeitcode,"%c%1.1d%2.2d%2.2d",
+           'A'+(azt->tm_year-100)/10,azt->tm_year%10,
+           azt->tm_mon+1,azt->tm_mday);
+ else
+   sprintf(zeitcode,"%2.2d%2.2d%2.2d",
+           azt->tm_year,azt->tm_mon+1,azt->tm_mday);
+ if(flag&1){
+   sprintf(puff,".%2.2d%2.2d",azt->tm_hour,azt->tm_min);
+   strcat(zeitcode,puff);
+ }
+ if(flag&2){
+   sprintf(puff,"%2.2d",azt->tm_sec);
+   strcat(zeitcode,puff);
+ }
+
+ return(zeitcode);
+}
+
+
+int Sfile_scale(double value, char *result, int siz, double thresh, int flag)
+/*
+ bit0= eventually ommit 'b'
+ bit1= make text as short as possible
+ bit2= no fraction (if it would fit at all)
+*/
+{
+ char scale_c,scales[7],form[80], *negpt= NULL, *cpt;
+ int i,dec_siz= 0,avail_siz= 1;
+
+ if(value<0) {
+   value= -value;
+   siz--;
+   result[0]= '-';
+   negpt= result;
+   result++;
+ }
+ strcpy(scales,"bkmgtp");
+ scale_c= scales[0];
+ for(i=1;scales[i]!=0;i++) {
+   if(value<thresh-0.5) 
+ break;
+   value/= 1024.0;
+   scale_c= scales[i];
+ } 
+ if(scale_c!='b' && !(flag&4)) { /* is there room for fractional part ? */
+   avail_siz= siz-1;
+   sprintf(form,"%%.f");
+   sprintf(result,"%.f",value);
+   if(((int) strlen(result)) <= avail_siz - 2) 
+     dec_siz= 1;                                  /* we are very modest */
+ }
+ if(scale_c=='b' && (flag&1)) {
+   if(flag&2)
+     sprintf(form,"%%.f");
+   else
+     sprintf(form,"%%%d.f",siz);
+   sprintf(result,form,value);
+ } else {
+   if(flag&2)
+     sprintf(form,"%%.f%%c");
+   else if(dec_siz>0) 
+     sprintf(form,"%%%d.%df%%c",avail_siz,dec_siz);
+   else
+     sprintf(form,"%%%d.f%%c",siz-1);
+   sprintf(result,form,value,scale_c);
+ }
+ if(negpt != NULL) {
+   for(cpt= result; *cpt==' '; cpt++);
+   if(cpt > result) {
+     *negpt= ' ';
+     *(cpt - 1)= '-';
+   } 
+ }
+ return(1);
+}
+
+
+int Sfile_off_t_text(char text[80], off_t num, int flag)
+{
+ char *tpt;
+ off_t hnum, scale= 1;
+ int digits= 0, d, i;
+
+ tpt= text;
+ hnum= num;
+ if(hnum<0) {
+   *(tpt++)= '-';
+   hnum= -num;
+ }
+ if(hnum<0) { /* it can stay nastily persistent */
+   strcpy(text, "_overflow_");
+   return(0);
+ }
+ for(i= 0; i<23; i++) { /* good for up to 70 bit = 10 exp 21.07... */
+   if(hnum==0)
+ break;
+   hnum/= 10;
+   if(hnum)
+     scale*= 10;
+ }
+ if(i==0) {
+   strcpy(text, "0");
+   return(1);
+ }
+ if(i==23) {
+   strcpy(text, "_overflow_");
+   return(0);
+ }
+ digits= i;
+ hnum= num;
+ for(; i>0; i--) {
+   d= hnum/scale;
+   tpt[digits-i]= '0'+d;
+   hnum= hnum%scale;
+   scale/= 10;
+ }
+ tpt[digits]= 0;
+ return(1);
+}
+
+
+/* Converts backslash codes into single characters:
+    \a BEL 7 , \b BS 8 , \e ESC 27 , \f FF 12 , \n LF 10 , \r CR 13 ,
+    \t  HT 9 , \v VT 11 , \\ \ 92 
+    \[0-9][0-9][0-9] octal code , \x[0-9a-f][0-9a-f] hex code ,
+    \cX control-x (ascii(X)-64)
+   @param upto  maximum number of characters to examine for backslash.
+                The scope of a backslash (0 to 3 characters) is not affected.
+   @param eaten returns the difference in length between input and output
+   @param flag bit0= only determine *eaten, do not convert
+               bit1= allow to convert \000 to binary 0 
+*/
+int Sfile_bsl_interpreter(char *text, int upto, int *eaten, int flag)
+{
+ char *rpt, *wpt, num_text[8], wdummy[8];
+ unsigned int num= 0;
+
+ *eaten= 0;
+ wpt= text;
+ for(rpt= text; *rpt != 0 && rpt - text < upto; rpt++) {
+   if(flag & 1)
+     wpt= wdummy;
+   if(*rpt == '\\') {
+     rpt++;
+     (*eaten)++;
+     if(*rpt == 'a') {
+       *(wpt++)= 7;
+     } else if(*rpt == 'b') {
+       *(wpt++)= 8;
+     } else if(*rpt == 'e') {
+       *(wpt++)= 27;
+     } else if(*rpt == 'f') {
+       *(wpt++)= 12;
+     } else if(*rpt == 'n') {
+       *(wpt++)= 10;
+     } else if(*rpt == 'r') {
+       *(wpt++)= 13;
+     } else if(*rpt == 't') {
+       *(wpt++)= 9;
+     } else if(*rpt == 'v') {
+       *(wpt++)= 11;
+     } else if(*rpt == '\\') {
+       *(wpt++)= '\\';
+     } else if(rpt[0] >= '0' && rpt[0] <= '7' &&
+               rpt[1] >= '0' && rpt[1] <= '7' &&
+               rpt[2] >= '0' && rpt[2] <= '7') {
+       num_text[0]= '0';
+       num_text[1]= *(rpt + 0);
+       num_text[2]= *(rpt + 1);
+       num_text[3]= *(rpt + 2);
+       num_text[4]= 0;
+       sscanf(num_text, "%o", &num);
+       if((num > 0 || (flag & 2)) && num <= 255) {
+         rpt+= 2;
+         (*eaten)+= 2;
+         *(wpt++)= num;
+       } else
+         goto not_a_code;
+     } else if(rpt[0] == 'x' &&
+               ((rpt[1] >= '0' && rpt[1] <= '9') ||
+                (rpt[1] >= 'A' && rpt[1] <= 'F') ||
+                (rpt[1] >= 'a' && rpt[1] <= 'f'))
+               &&
+               ((rpt[2] >= '0' && rpt[2] <= '9') ||
+                (rpt[2] >= 'A' && rpt[2] <= 'F') ||
+                (rpt[2] >= 'a' && rpt[2] <= 'f'))
+               ) {
+       num_text[0]= *(rpt + 1);
+       num_text[1]= *(rpt + 2);
+       num_text[2]= 0;
+       sscanf(num_text, "%x", &num);
+       if(num > 0 && num <= 255) {
+         rpt+= 2;
+         (*eaten)+= 2;
+         *(wpt++)= num;
+       } else
+         goto not_a_code;
+     } else if(*rpt == 'c') {
+       if(rpt[1] > 64 && rpt[1] < 96) {
+         *(wpt++)= rpt[1] - 64;
+         rpt++;
+         (*eaten)++;
+       } else
+         goto not_a_code;
+     } else {
+not_a_code:;
+       *(wpt++)= '\\';
+       rpt--;
+       (*eaten)--;
+     }
+   } else
+     *(wpt++)= *rpt;
+ }
+ *wpt= *rpt;
+ return(1);
+}
+
+
+int Sfile_argv_bsl(int argc, char ***argv, int flag)
+{
+ int i, ret, eaten;
+ char **new_argv= NULL;
+
+ if(argc <= 0)
+   return(0);
+ new_argv= (char **) Smem_malloC(argc * sizeof(char *));
+ if(new_argv == NULL)
+   return(-1);
+ for(i= 0; i < argc; i++) {
+   new_argv[i]= strdup((*argv)[i]);
+   if(new_argv[i] == NULL)
+     {ret= -1; goto ex;}
+   ret= Sfile_bsl_interpreter(new_argv[i], strlen(new_argv[i]), &eaten, 0);
+   if(ret <= 0)
+     goto ex;
+ }
+ ret= 1;
+ex:;
+ if(ret <= 0) {
+   if(new_argv != NULL)
+     free((char *) new_argv);
+ } else
+   *argv= new_argv;
+ return(ret);
+}
+
+
+/* @param flag bit0= only encode inside quotes
+               bit1= encode < 32 outside quotes except 7, 8, 9, 10, 12, 13
+               bit2= encode in any case above 126
+               bit3= encode in any case shellsafe and name-value-safe:
+                     <=42 , 59, 60, 61, 62, 63, 92, 94, 96, >=123
+*/
+int Sfile_bsl_encoder(char **result, char *text, size_t text_len, int flag)
+{
+ signed char *rpt;
+ char *wpt;
+ int count, sq_open= 0, dq_open= 0;
+
+ count= 0;
+ for(rpt= (signed char *) text; (size_t) (((char *) rpt) - text) < text_len;
+     rpt++) {
+   count++;
+   if(flag & 8) {
+      if(!(*rpt <= 42 || (*rpt >= 59 && *rpt <= 63) ||
+           *rpt == 92 || *rpt == 94 || *rpt == 96 || *rpt >= 123))
+ continue;
+   } else if(*rpt >= 32 && *rpt <= 126 && *rpt != '\\')
+ continue;
+   if(((*rpt >= 7 && *rpt <= 13) || *rpt == 27 || *rpt == '\\') && !(flag & 8))
+     count++;
+   else
+     count+= 3;
+ }
+ (*result)= wpt= calloc(count + 1, 1);
+ if(wpt == NULL)
+   return(-1);
+ for(rpt= (signed char *) text; (size_t) (((char *) rpt) - text) < text_len;
+     rpt++) {
+   if(*rpt == '\'')
+     sq_open= !(sq_open || dq_open);
+   if(*rpt == '"')
+     dq_open= !(sq_open || dq_open);
+ 
+   if(flag & 8) {
+     if(!(*rpt <= 42 || (*rpt >= 59 && *rpt <= 63) ||
+          *rpt == 92 || *rpt == 94 || *rpt == 96 || *rpt >= 123)) {
+       *(wpt++)= *rpt; 
+ continue;
+     }  
+   } else if(*rpt >= 32 && *rpt <= 126 && *rpt != '\\') {
+     *(wpt++)= *rpt;
+ continue;
+   } else if( ((flag & 1) && !(sq_open || dq_open)) &&
+             !((flag & 2) && (*rpt >= 1 && * rpt <= 31 &&
+               !(*rpt == 7 || *rpt == 8 || *rpt == 9 || *rpt == 10 ||
+                 *rpt == 12 || *rpt == 13))) &&
+             !((flag & 4) && (*rpt > 126 || *rpt < 0)) &&
+             !((flag & 6) && *rpt == '\\')) {
+     *(wpt++)= *rpt;
+ continue;
+   }
+   *(wpt++)= '\\';
+   if(((*rpt >= 7 && *rpt <= 13) || *rpt == 27 || *rpt == '\\') && !(flag&8)) {
+     if(*rpt == 7)
+       *(wpt++)= 'a';
+     else if(*rpt == 8)
+       *(wpt++)= 'b';
+     else if(*rpt == 9)
+       *(wpt++)= 't';
+     else if(*rpt == 10) {
+       *(wpt++)= 'n';
+     } else if(*rpt == 11)
+       *(wpt++)= 'v';
+     else if(*rpt == 12)
+       *(wpt++)= 'f';
+     else if(*rpt == 13)
+       *(wpt++)= 'c';
+     else if(*rpt == 27)
+       *(wpt++)= 'e';
+     else if(*rpt == '\\')
+       *(wpt++)= '\\';
+   } else {
+     sprintf(wpt, "%-3.3o", (unsigned int) *((unsigned char *) rpt));
+     wpt+= 3;
+   }
+ }
+ *wpt= 0;
+ return(1);
+}
+
+
+int Sfile_destroy_argv(int *argc, char ***argv, int flag)
+{
+ int i;
+
+ if(*argc>0 && *argv!=NULL){
+   for(i=0;i<*argc;i++){
+     if((*argv)[i]!=NULL)
+       Smem_freE((*argv)[i]);
+   }
+   Smem_freE((char *) *argv);
+ }
+ *argc= 0;
+ *argv= NULL;
+ return(1);
+}
+
+
+int Sfile_sep_make_argv(char *progname, char *line, char *separators,
+                        int max_words, int *argc, char ***argv, int flag)
+/*
+ bit0= read progname as first argument from line
+ bit1= just release argument list argv and return
+ bit2= abort with return(0) if incomplete quotes are found
+ bit3= eventually prepend missing '-' to first argument read from line
+ bit4= like bit2 but only check quote completeness, do not allocate memory
+ bit5+6= interpretation of backslashes:
+       0= no interpretation, leave unchanged
+       1= only inside double quotes
+       2= outside single quotes
+       3= everywhere
+ bit7= append a NULL element to argv
+*/
+{
+ int i,pass,maxl=0,l,argzaehl=0,bufl,line_start_argc, bsl_mode, ret= 0, eaten;
+ char *cpt,*start;
+ char *buf= NULL;
+
+ Sfile_destroy_argv(argc,argv,0);
+ if(flag&2)
+   {ret= 1; goto ex;}
+
+ if(flag & 16)
+   flag|= 4;
+ bsl_mode= (flag >> 5) & 3;
+
+ buf= calloc(strlen(line) + SfileadrL, 1);
+ if(buf == NULL)
+   {ret= -1; goto ex;}
+ for(pass=0;pass<2;pass++) {
+   cpt= line-1;
+   if(!(flag&1)){
+     argzaehl= line_start_argc= 1;
+     if(pass==0)
+       maxl= strlen(progname);
+     else
+       strcpy((*argv)[0],progname);
+   } else {
+     argzaehl= line_start_argc= 0;
+     if(pass==0) maxl= 0;
+   }
+   while(*(++cpt)!=0){
+     if(*separators) {
+       if(strchr(separators, *cpt) != NULL)
+   continue;
+     } else if(isspace(*cpt))
+   continue;
+     start= cpt;
+     buf[0]= 0;
+     cpt--;
+
+     if(max_words > 0 && argzaehl >= max_words && *cpt != 0) {
+       /* take uninterpreted up to the end */
+       cpt+= strlen(cpt) - 1;
+     }
+
+     while(*(++cpt)!=0) {
+       if(*separators) {
+         if(strchr(separators, *cpt) != NULL)
+     break;
+       } else if(isspace(*cpt))
+     break;
+       if(*cpt=='"'){
+         l= cpt-start; bufl= strlen(buf);
+         if(l>0) {
+           strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
+           if(bsl_mode >= 3) {
+             ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
+             if(ret <= 0)
+               goto ex;
+           }
+         }
+         l= strlen(buf);
+         start= cpt+1;
+         while(*(++cpt)!=0) if(*cpt=='"') break;
+         if((flag&4) && *cpt==0)
+           {ret= 0; goto ex;}
+         l= cpt-start; bufl= strlen(buf);
+         if(l>0) {
+           strncpy(buf + bufl, start, l);
+           buf[bufl + l]= 0;
+           if(bsl_mode >= 1) {
+             ret= Sfile_bsl_interpreter(buf + bufl, l, &eaten, 0);
+             if(ret <= 0)
+               goto ex;
+           }
+         }
+         start= cpt+1;
+       }else if(*cpt=='\''){
+         l= cpt-start; bufl= strlen(buf);
+         if(l>0) {
+           strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
+           if(bsl_mode >= 3) {
+             ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
+             if(ret <= 0)
+               goto ex;
+           }
+         }
+         l= strlen(buf);
+         start= cpt+1;
+         while(*(++cpt)!=0) if(*cpt=='\'') break;
+         if((flag&4) && *cpt==0)
+           {ret= 0; goto ex;}
+         l= cpt-start; bufl= strlen(buf);
+         if(l>0) {
+           strncat(buf,start,l);buf[bufl+l]= 0;
+           if(bsl_mode >= 2) {
+             ret= Sfile_bsl_interpreter(buf + bufl, l, &eaten, 0);
+             if(ret <= 0)
+               goto ex;
+           }
+         }
+         start= cpt+1;
+       }
+     if(*cpt==0) break;
+     }
+     l= cpt-start;
+     bufl= strlen(buf);
+     if(l>0) {
+       strncpy(buf + bufl, start, l); buf[bufl + l]= 0;
+       if(bsl_mode >= 3) {
+         ret= Sfile_bsl_interpreter(buf, l, &eaten, 0);
+         if(ret <= 0)
+           goto ex;
+       }
+     }
+     l= strlen(buf);
+     if(pass==0){
+       if(argzaehl==line_start_argc && (flag&8))
+         if(buf[0]!='-' && buf[0]!=0 && buf[0]!='#')
+           l++;
+       if(l>maxl) maxl= l;
+     }else{
+       strcpy((*argv)[argzaehl],buf);
+       if(argzaehl==line_start_argc && (flag&8))
+         if(buf[0]!='-' && buf[0]!=0 && buf[0]!='#')
+           sprintf((*argv)[argzaehl],"-%s", buf);
+     }
+     argzaehl++;
+   if(*cpt==0) break;
+   }
+   if(pass==0){
+     if(flag & 16)
+       {ret= 1; goto ex;}
+     *argc= argzaehl;
+     if(argzaehl>0 || (flag & 128)) {
+       *argv= (char **) Smem_malloC((argzaehl + !!(flag & 128))
+                                    * sizeof(char *));
+       if(*argv==NULL)
+         {ret= -1; goto ex;}
+     }
+     for(i=0;i<*argc;i++) {
+       (*argv)[i]= (char *) Smem_malloC((maxl+1));
+       if((*argv)[i]==NULL)
+         {ret= -1; goto ex;}
+     }
+     if(flag & 128)
+       (*argv)[*argc]= NULL;
+   }
+ }
+ ret= 1;
+ex:
+ if(buf != NULL)
+   free(buf);
+ return(ret);
+}
+
+
+int Sfile_make_argv(char *progname, char *line, int *argc, char ***argv,
+                    int flag)
+{
+ return Sfile_sep_make_argv(progname, line, "", 0, argc, argv, flag);
+}
+
+
+/* @param flag bit0= append */
+int Sfile_str(char target[SfileadrL], char *source, int flag)
+{
+ int l;
+
+ l= strlen(source);
+ if(flag&1)
+   l+= strlen(target);
+ if(l>=SfileadrL) {
+   fprintf(stderr, "--- Path string overflow (%d > %d). Malicious input ?\n",
+           l,SfileadrL-1);
+   return(0);
+ }
+ if(flag&1)
+   strcat(target, source);
+ else
+   strcpy(target, source);
+ return(1);
+}
+
+
+/** Combine environment variable HOME with given filename
+    @param filename Address relative to $HOME
+    @param fileadr Resulting combined address
+    @param fa_size Size of array fileadr
+    @param flag Unused yet
+    @return 1=ok , 0=no HOME variable , -1=result address too long
+*/
+int Sfile_home_adr_s(char *filename, char *fileadr, int fa_size, int flag)
+{
+ char *home;
+
+ strcpy(fileadr,filename);
+ home= getenv("HOME");
+ if(home==NULL)
+   return(0);
+ if((int) (strlen(home) + strlen(filename) + 1) >= fa_size)
+   return(-1);
+ strcpy(fileadr,home);
+ if(filename[0]!=0){
+   strcat(fileadr,"/");
+   strcat(fileadr,filename);
+ }
+ return(1);
+}
+
+
+/** Return a double representing seconds and microseconds since 1 Jan 1970 */
+double Sfile_microtime(int flag)
+{
+ struct timeval tv;
+ struct timezone tz;
+ gettimeofday(&tv,&tz);
+ return((double) (tv.tv_sec+1.0e-6*tv.tv_usec));
+}
+
+
+int Sfile_decode_datestr(struct tm *reply, char *text, int flag)
+/* YYMMDD[.hhmm[ss]] */
+{
+ int i,l;
+ time_t current_time;
+ struct tm *now;
+
+ current_time= time(0);
+ now= localtime(&current_time);
+ for(i=0; i < (int) sizeof(struct tm); i++)
+   ((char *) reply)[i]= ((char *) now)[i];
+
+ if(text[0]<'0'|| (text[0]>'9' && text[0]<'A') || text[0]>'Z')
+   return(0);
+ l= strlen(text);
+ for(i=1;i<l;i++)
+   if(text[i]<'0'||text[i]>'9')
+     break;
+ if(i!=6)
+   return(0);
+ if(text[i]==0)
+   goto decode;
+ if(text[i]!='.' || (l!=11 && l!=13))
+   return(0);
+ for(i++;i<l;i++)
+   if(text[i]<'0'||text[i]>'9')
+     break;
+ if(i!=l)
+   return(0);
+
+decode:;
+ reply->tm_hour= 0;
+ reply->tm_min= 0;
+ reply->tm_sec= 0;
+ i= 0;
+ if(text[0]>='A') 
+   reply->tm_year= 100+(text[i]-'A')*10+text[1]-'0';
+ else
+   reply->tm_year= 10*(text[0]-'0')+text[1]-'0';
+ reply->tm_mon=  10*(text[2]-'0')+text[3]-'0'-1;
+ reply->tm_mday= 10*(text[4]-'0')+text[5]-'0';
+ if(l==6)
+   return(1);
+ reply->tm_hour= 10*(text[7]-'0')+text[8]-'0';
+ reply->tm_min=  10*(text[9]-'0')+text[10]-'0';
+ if(l==11)
+   return(1);
+ reply->tm_sec=  10*(text[11]-'0')+text[12]-'0';
+ return(1);
+}
+
+
--- a/xorriso/sfile.h
+++ b/xorriso/sfile.h
@ -0,0 +1,140 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2012 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions around files and strings.
+*/
+
+
+#ifndef Xorriso_pvt_sfile_includeD
+#define Xorriso_pvt_sfile_includeD yes
+
+#define TSOB_FELD(typ, count) (typ *) calloc(1, (count)*sizeof(typ));
+#define Smem_malloC malloc
+#define Smem_freE free
+
+#define Xorriso_alloc_meM(pt, typ, count) { \
+  pt= (typ *) calloc(1, (count) * sizeof(typ)); \
+  if(pt == NULL) { \
+    Xorriso_no_malloc_memory(xorriso, NULL, 0); \
+    ret= -1; \
+    goto ex; \
+  } }
+
+#define Xorriso_free_meM(pt) { \
+  if(pt != NULL) \
+    free((char *) pt); \
+  }
+
+
+#define SfileadrL 4096
+
+
+int Sfile_str(char target[SfileadrL], char *source, int flag); 
+ 
+double Sfile_microtime(int flag);
+  
+int Sfile_add_to_path(char path[SfileadrL], char *addon, int flag);
+  
+int Sfile_scale(double value, char *result, int siz, double thresh, int flag);
+  
+int Sfile_destroy_argv(int *argc, char ***argv, int flag);
+
+int Sfile_count_char(char *text, char to_count);
+
+ 
+/*
+ bit0= do not ignore trailing slash
+ bit1= do not ignore empty components (other than the empty root name)
+*/
+int Sfile_count_components(char *path, int flag);
+
+/*
+ @param flag
+ bit0= return -1 if file is missing
+ bit1= return a hardlink with siblings as type 5
+ bit2= evaluate eventual link target rather than the link object itself
+ bit3= return a socket or a char device as types 7 or 8 rather than 0
+ @return
+  0=unknown
+  1=regular
+  2=directory
+  3=symbolic link
+  4=named pipe
+  5=multiple hardlink (with bit1)
+  6=block device
+  7=socket (with bit3)
+  8=character device (with bit3)
+*/
+int Sfile_type(char *filename, int flag);
+
+/* @param flag bit0= only encode inside quotes
+               bit1= encode < 32 outside quotes except 7, 8, 9, 10, 12, 13
+               bit2= encode in any case above 126
+               bit3= encode in any case shellsafe:
+                     <=42 , 59, 60, 62, 63, 92, 94, 96, >=123
+*/
+int Sfile_bsl_encoder(char **result, char *text, size_t text_len, int flag);
+
+int Sfile_argv_bsl(int argc, char ***argv, int flag);
+
+/*
+ bit0= read progname as first argument from line
+ bit1= just release argument list argv and return
+ bit2= abort with return(0) if incomplete quotes are found
+ bit3= eventually prepend missing '-' to first argument read from line
+ bit4= like bit2 but only check quote completeness, do not allocate memory
+ bit5+6= interpretation of backslashes:
+       0= no interpretation, leave unchanged
+       1= only inside double quotes
+       2= outside single quotes
+       3= everywhere
+ bit7= append a NULL element to argv
+*/
+int Sfile_make_argv(char *progname, char *line, int *argc, char ***argv,
+                    int flag);
+int Sfile_sep_make_argv(char *progname, char *line, char *separators,
+                        int max_argc, int *argc, char ***argv, int flag);
+
+/* YYMMDD[.hhmm[ss]] */
+int Sfile_decode_datestr(struct tm *reply, char *text, int flag);
+
+int Sfile_off_t_text(char text[80], off_t num, int flag);
+
+int Sfile_leafname(char *path, char leafname[SfileadrL], int flag);
+
+/* @param flag bit0= do not clip of carriage return at line end
+*/
+char *Sfile_fgets_n(char *line, int maxl, FILE *fp, int flag);
+
+/*
+ bit0=with hours+minutes
+ bit1=with seconds
+
+ bit8= local time rather than UTC
+*/
+char *Sfile_datestr(time_t tim, short int flag);
+
+/* Converts backslash codes into single characters:
+    \a BEL 7 , \b BS 8 , \e ESC 27 , \f FF 12 , \n LF 10 , \r CR 13 ,
+    \t  HT 9 , \v VT 11 , \\ \ 92
+    \[0-9][0-9][0-9] octal code , \x[0-9a-f][0-9a-f] hex code ,
+    \cX control-x (ascii(X)-64)
+   @param upto  maximum number of characters to examine for backslash.
+                The scope of a backslash (0 to 3 characters) is not affected.
+   @param eaten returns the difference in length between input and output
+   @param flag bit0= only determine *eaten, do not convert
+               bit1= allow to convert \000 to binary 0
+*/
+int Sfile_bsl_interpreter(char *text, int upto, int *eaten, int flag);
+
+int Sfile_prepend_path(char *prefix, char path[SfileadrL], int flag);
+
+int Sfile_home_adr_s(char *filename, char *fileadr, int fa_size, int flag);
+
+
+#endif /* ! Xorriso_pvt_sfile_includeD */
+
--- a/xorriso/sort_cmp.c
+++ b/xorriso/sort_cmp.c
@ -0,0 +1,722 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2011 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains functions which sort and compare tree nodes.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <time.h>
+#include <errno.h>
+
+
+#include "base_obj.h"
+#include "lib_mgt.h"
+#include "sort_cmp.h"
+#include "iso_tree.h"
+#include "iso_manip.h"
+
+
+int Xorriso__findi_sorted_ino_cmp(const void *p1, const void *p2)
+{
+ int ret;
+ IsoNode *n1, *n2;
+
+ n1= *((IsoNode **) p1);
+ n2= *((IsoNode **) p2);
+
+ ret= Xorriso__node_lba_cmp(&n1, &n2);
+ if(ret)
+   return (ret > 0 ? 1 : -1);
+ ret= iso_node_cmp_ino(n1, n2, 0);
+ return(ret);
+}
+
+
+/* Not suitable for qsort() but for cross-array comparisons.
+   p1 and p2 are actually IsoNode *p1, IsoNode *p2
+*/
+int Xorriso__hln_cmp(const void *p1, const void *p2)
+{
+ int ret;
+
+ ret= Xorriso__findi_sorted_ino_cmp(&p1, &p2);
+ if(ret)
+   return (ret > 0 ? 1 : -1);
+ if(p1 != p2)
+   return(p1 < p2 ? -1 : 1);
+ return(0);
+}
+
+
+/* 
+   p1 and p2 are actually IsoNode **p1, IsoNode **p2
+*/
+int Xorriso__findi_sorted_cmp(const void *p1, const void *p2)
+{
+ int ret;
+
+ ret= Xorriso__findi_sorted_ino_cmp(p1, p2);
+ if(ret)
+   return (ret > 0 ? 1 : -1);
+ if(p1 != p2)
+   return(p1 < p2 ? -1 : 1);
+ return(0);
+}
+
+
+int Xorriso_sort_node_array(struct XorrisO *xorriso, int flag)
+{
+ if(xorriso->node_counter <= 0)
+   return(0);
+ qsort(xorriso->node_array, xorriso->node_counter, sizeof(IsoNode *),
+       Xorriso__findi_sorted_cmp);
+ return(1);
+}
+
+
+int Xorriso__search_node(void *node_array[], int n,
+                         int (*cmp)(const void *p1, const void *p2),
+                         void *node, int *idx, int flag)
+{
+ int ret, l, r, p, pos;
+
+ if(n == 0)
+   return(0);
+ l= 0;
+ r= n + 1;
+ while(1) {
+   p= (r - l) / 2;
+   if(p == 0)
+ break;
+   p+= l;
+
+   /* NULL elements may indicate invalid nodes. Their first valid right neigbor
+      will serve as proxy. If none exists, then the test pushes leftwards.
+    */
+   for(pos= p - 1; pos < n; pos++)
+     if(node_array[pos] != NULL)
+   break;
+   if(pos < n)
+     ret= (*cmp)(&(node_array[pos]), &node);
+   else
+     ret= 1;
+
+   if(ret < 0)
+     l= p;
+   else if(ret > 0)
+     r= p;
+   else {
+     *idx= pos;
+     return(1);
+   }
+ }
+ return(0);
+}
+
+
+int Xorriso_search_in_hln_array(struct XorrisO *xorriso,
+                                 void *node, int *idx, int flag)
+{
+ int ret;
+
+ if(xorriso->hln_array == NULL || xorriso->hln_count <= 0)
+   return(0);
+ ret= Xorriso__search_node(xorriso->hln_array, xorriso->hln_count, 
+                           Xorriso__findi_sorted_ino_cmp, node, idx, 0);
+ return ret;
+}
+
+
+int Xorriso__get_di(IsoNode *node, dev_t *dev, ino_t *ino, int flag)
+{
+ int ret, i, i_end, imgid, error_code;
+ size_t value_length= 0;
+ char *value= NULL, *msg= NULL, severity[80];
+ unsigned char *vpt;
+ static char *name= "isofs.di";
+
+#ifdef NIX
+ /* <<< */
+ Xorriso_get_di_counteR++;
+#endif /* NIX */
+
+ msg= TSOB_FELD(char, ISO_MSGS_MESSAGE_LEN);
+ if(msg == NULL)
+   {ret= -1; goto ex;}
+ *dev= 0;
+ *ino= 0;
+ ret= iso_node_lookup_attr(node, name, &value_length, &value, 0);
+ if(ret <= 0) {
+   /* Drop any pending messages because there is no xorriso to take them */
+   iso_obtain_msgs("NEVER", &error_code, &imgid, msg, severity);
+   goto ex;
+ }
+ vpt= (unsigned char *) value;
+ for(i= 1; i <= vpt[0] && i < (int) value_length; i++)
+   *dev= ((*dev) << 8) | vpt[i];
+ i_end= i + vpt[i] + 1;
+ for(i++; i < i_end && i < (int) value_length; i++)
+   *ino= ((*ino) << 8) | vpt[i];
+ free(value);
+ ret= 1;
+ex:;
+ if(msg != NULL)
+   free(msg);
+ return(ret);
+}
+
+
+int Xorriso__di_ino_cmp(const void *p1, const void *p2)
+{  
+ int ret; 
+ IsoNode *n1, *n2;
+ dev_t d1, d2;
+ ino_t i1, i2;
+ 
+ n1= *((IsoNode **) p1);
+ n2= *((IsoNode **) p2);
+
+ ret= Xorriso__get_di(n1, &d1, &i1, 0);
+ if(ret <= 0)
+   {d1= 0; i1= 0;}
+ ret= Xorriso__get_di(n2, &d2, &i2, 0);
+ if(ret <= 0)
+   {d2= 0; i2= 0;}
+
+ if(d1 < d2)
+   return(-1);
+ if(d1 > d2)
+   return(1);
+ if(i1 < i2)
+   return(-1);
+ if(i1 > i2)
+   return(1);
+ if(d1 == 0 && i1 == 0 && n1 != n2)
+   return(n1 < n2 ? -1 : 1);
+ return(0);
+} 
+
+
+int Xorriso__di_cmp(const void *p1, const void *p2)
+{  
+ int ret; 
+ IsoNode *n1, *n2;
+
+ ret= Xorriso__di_ino_cmp(p1, p2);
+ if(ret)
+   return(ret);
+ n1= *((IsoNode **) p1);
+ n2= *((IsoNode **) p2);
+ if(n1 != n2)
+   return(n1 < n2 ? -1 : 1);
+ return(0);
+} 
+
+
+int Xorriso__sort_di(void *node_array[], int count, int flag)
+{
+ if(count <= 0)
+   return(0);
+ qsort(node_array, count, sizeof(IsoNode *), Xorriso__di_cmp);
+ return(1);
+}
+
+
+int Xorriso_invalidate_di_item(struct XorrisO *xorriso, IsoNode *node,
+                               int flag)
+{
+ int ret, idx;
+
+ if(xorriso->di_array == NULL)
+   return(1);
+ ret= Xorriso__search_node(xorriso->di_array, xorriso->di_count,
+                           Xorriso__di_cmp, node, &idx, 0);
+ if(ret <= 0)
+   return(ret == 0);
+ if(xorriso->di_array[idx] != NULL)
+   iso_node_unref(xorriso->di_array[idx]);
+ xorriso->di_array[idx]= NULL;
+ return(1);
+}
+
+
+/* @param flag bit0= return 1 even if matching nodes were found but node is
+                     not among them
+               bit1= use Xorriso__di_cmp() rather than Xorriso__di_ino_cmp()
+*/
+int Xorriso_search_di_range(struct XorrisO *xorriso, IsoNode *node,
+                            int *idx, int *low, int *high, int flag)
+{
+ int ret, i, found;
+ int (*cmp)(const void *p1, const void *p2)= Xorriso__di_ino_cmp;
+
+ if(flag & 2)
+   cmp= Xorriso__di_cmp;
+
+ *high= *low= *idx= -1;                            
+ ret= Xorriso__search_node(xorriso->di_array, xorriso->di_count,
+                           cmp, node, &found, 0);
+ if(ret <= 0)
+   return(0);
+ *low= *high= found;
+ for(i= found + 1; i < xorriso->di_count; i++)
+   if(xorriso->di_array[i] != NULL) {
+     if((*cmp)(&node, &(xorriso->di_array[i])) != 0)
+ break;
+     *high= i;
+   }
+ for(i= found - 1; i >= 0; i--)
+   if(xorriso->di_array[i] != NULL) {
+     if((*cmp)(&node, &(xorriso->di_array[i])) != 0)
+ break;
+     *low= i;
+   }
+ for(i= *low; i <= *high; i++)
+   if(xorriso->di_array[i] == node) {
+     *idx= i;
+ break;
+   }
+ return(*idx >= 0 || (flag & 1));
+}
+
+
+int Xorriso__node_lba_cmp(const void *node1, const void *node2)
+{
+ int ret;
+ int lba1= 0, lba2= 0;
+
+ ret= Xorriso__file_start_lba(*((IsoNode **) node1), &lba1, 0);
+ if(ret!=1) 
+   lba1= 0;
+ ret= Xorriso__file_start_lba(*((IsoNode **) node2), &lba2, 0);
+ if(ret!=1)
+   lba2= 0;
+ return(lba1-lba2);  
+}
+
+
+int Xorriso__node_name_cmp(const void *node1, const void *node2)
+{
+ char *name1, *name2;
+
+ name1= (char *) iso_node_get_name(*((IsoNode **) node1));
+ name2= (char *) iso_node_get_name(*((IsoNode **) node2));
+ return(strcmp(name1,name2));
+}
+
+
+/* @param flag bit0= only accept directory nodes
+               bit1= do not report memory usage as DEBUG
+               bit2= do not apply search pattern but accept any node
+*/
+int Xorriso_sorted_node_array(struct XorrisO *xorriso, 
+                              IsoDir *dir_node,
+                              int *nodec, IsoNode ***node_array,
+                              off_t boss_mem, int flag)
+{
+ int i, ret, failed_at;
+ char *npt;
+ IsoDirIter *iter= NULL;
+ IsoNode *node;
+ off_t mem;
+
+ mem= ((*nodec)+1)*sizeof(IsoNode *);
+ ret= Xorriso_check_temp_mem_limit(xorriso, mem+boss_mem, flag&2);
+ if(ret<=0)
+   return(ret);
+
+ *node_array= calloc(sizeof(IsoNode *), (*nodec)+1);
+ if(*node_array==NULL) {
+   sprintf(xorriso->info_text,
+           "Cannot allocate memory for %d directory entries", *nodec); 
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+
+ ret= iso_dir_get_children(dir_node, &iter);
+ if(ret<0) {
+   Xorriso_cannot_create_iter(xorriso, ret, 0);
+   return(-1);
+ }
+ 
+ for(i= 0; iso_dir_iter_next(iter, &node) == 1 && i<*nodec; ) {
+   npt= (char *) iso_node_get_name(node);
+   if(!(flag&4)) {
+     ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
+     if(ret)
+ continue; /* no match */
+   }
+   if(flag&1)
+     if(!LIBISO_ISDIR(node))
+ continue;
+   (*node_array)[i++]= node;
+ }
+ iso_dir_iter_free(iter);
+ *nodec= i;
+ if(*nodec<=0)
+   return(1);
+ qsort(*node_array, *nodec, sizeof(IsoNode *), Xorriso__node_name_cmp);
+ return(1);
+}
+
+
+int Xorriso_remake_hln_array(struct XorrisO *xorriso, int flag)
+{  
+ int ret, addon_nodes= 0, i, old_count, old_pt, new_pt;
+ IsoNode **old_nodes;
+ char **old_targets;
+
+ /* Count hln_targets of which the node has been deleted meanwhile */
+ for(i= 0; i < xorriso->hln_count; i++) {
+   if(xorriso->hln_targets[i] == NULL)
+ continue;
+   if(Xorriso_node_is_valid(xorriso, xorriso->hln_array[i], 0))
+ continue;
+   addon_nodes++;
+ }
+ ret= Xorriso_all_node_array(xorriso, addon_nodes, 0);
+ if(ret <= 0)
+   goto ex;
+ if(addon_nodes > 0) {
+   /* Transfer delete nodes with hln_target to node array */
+   for(i= 0; i < xorriso->hln_count; i++) {
+     if(xorriso->hln_targets[i] == NULL)
+   continue;
+     if(Xorriso_node_is_valid(xorriso, xorriso->hln_array[i], 0))
+   continue;
+     if(xorriso->node_counter < xorriso->node_array_size) {
+       xorriso->node_array[xorriso->node_counter++]= xorriso->hln_array[i];
+       iso_node_ref(xorriso->node_array[xorriso->node_counter - 1]);
+     }
+   }
+ }
+
+ Xorriso_sort_node_array(xorriso, 0);
+ old_nodes= (IsoNode **) xorriso->hln_array;
+ old_targets= (char **) xorriso->hln_targets;
+ old_count= xorriso->hln_count;
+ xorriso->hln_array= 0;
+ xorriso->hln_targets= NULL;
+
+ /* Transfer node_array to di_array without unrefering nodes */
+ xorriso->hln_count= xorriso->node_counter;
+ xorriso->hln_array= xorriso->node_array;
+ xorriso->node_counter= 0;
+ xorriso->node_array_size= 0;
+ xorriso->node_array= NULL;
+
+ /* Allocate hln_targets */
+ ret= Xorriso_new_hln_array(xorriso, xorriso->temp_mem_limit, 1);
+ if(ret<=0)
+   goto ex;
+ xorriso->node_targets_availmem= xorriso->temp_mem_limit;
+ if(old_targets != NULL) {
+   /* Transfer targets from old target array */;
+   new_pt= old_pt= 0;
+   while(new_pt < xorriso->hln_count && old_pt < old_count) {
+     ret= Xorriso__hln_cmp(xorriso->hln_array[new_pt], old_nodes[old_pt]);
+     if(ret < 0) {
+       new_pt++;
+     } else if(ret > 0) {
+       old_pt++;
+     } else {
+       xorriso->hln_targets[new_pt]= old_targets[old_pt];
+       if(old_targets[old_pt] != NULL)
+         xorriso->temp_mem_limit-= strlen(old_targets[old_pt]) + 1;
+       old_targets[old_pt]= NULL;
+       new_pt++;
+       old_pt++;
+     }
+   }
+   for(old_pt= 0; old_pt < old_count; old_pt++)
+     if(old_targets[old_pt] != NULL) /* (should not happen) */
+       free(old_targets[old_pt]);
+   free((char *) old_targets);
+ }
+ if(old_nodes != NULL) {
+   for(old_pt= 0; old_pt < old_count; old_pt++)
+     if(old_nodes[old_pt] != NULL)
+       iso_node_unref(old_nodes[old_pt]);
+   free((char *) old_nodes);
+ }
+ xorriso->hln_change_pending= 0;
+ ret= 1;
+ex:;
+ return(ret);
+}
+
+
+/* @param flag bit0= overwrite existing hln_array (else return 2)
+*/
+int Xorriso_make_hln_array(struct XorrisO *xorriso, int flag)
+{  
+ int ret;
+
+ if(xorriso->hln_array != NULL && !(flag & 1)) {
+   /* If no fresh image manipulations occured: keep old array */
+   if(!xorriso->hln_change_pending)
+     return(2);
+   ret= Xorriso_remake_hln_array(xorriso, 0);
+   return(ret);
+ }
+ Xorriso_destroy_hln_array(xorriso, 0);
+
+ ret= Xorriso_all_node_array(xorriso, 0, 0);
+ if(ret <= 0)
+   goto ex;
+ Xorriso_sort_node_array(xorriso, 0);
+
+ /* Transfer node_array to di_array without unrefering nodes */
+ xorriso->hln_count= xorriso->node_counter;
+ xorriso->hln_array= xorriso->node_array;
+ xorriso->node_counter= 0;
+ xorriso->node_array_size= 0;
+ xorriso->node_array= NULL;
+
+ /* Allocate hln_targets */
+ ret= Xorriso_new_hln_array(xorriso, xorriso->temp_mem_limit, 1);
+ if(ret<=0) {
+   Xorriso_destroy_hln_array(xorriso, 0);
+   goto ex;
+ }
+ xorriso->node_targets_availmem= xorriso->temp_mem_limit;
+ xorriso->hln_change_pending= 0;
+ ret= 1;
+ex:;
+ return(ret);
+}
+
+
+/* @param flag bit0= overwrite existing di_array (else return 2)
+               bit1= make di_array despite xorriso->ino_behavior bit 3
+*/
+int Xorriso_make_di_array(struct XorrisO *xorriso, int flag)
+{  
+ int ret, bytes; 
+
+#ifdef NIX
+ /* <<< */
+ unsigned long old_gdic;
+ old_gdic= Xorriso_get_di_counteR;
+#endif /* NIX */
+
+ if((xorriso->ino_behavior & 8 ) && !(flag & 2))
+   return(2);
+ if(xorriso->di_array != NULL && !(flag & 1))
+   return(2);
+ Xorriso_finish_hl_update(xorriso, 0);
+
+ ret= Xorriso_all_node_array(xorriso, 0, 0);
+ if(ret <= 0)
+   goto ex;
+ bytes= xorriso->node_array_size / 8 + 1;
+ xorriso->di_do_widen= calloc(bytes, 1);
+ if(xorriso->di_do_widen == NULL) {
+   Xorriso_no_malloc_memory(xorriso, NULL, 0);
+   ret= -1; goto ex;
+ }
+
+ /* Transfer node_array to di_array without unrefering nodes */
+ xorriso->di_count= xorriso->node_counter;
+ xorriso->di_array= xorriso->node_array;
+ xorriso->node_counter= 0;
+ xorriso->node_array_size= 0;
+ xorriso->node_array= NULL;
+
+ Xorriso__sort_di((void *) xorriso->di_array, xorriso->di_count, 0);
+
+ ret= 1;
+ex:;
+
+#ifdef NIX
+/* <<< */
+ fprintf(stderr, "xorriso_DEBUG: sort_count= %lu\n",
+         Xorriso_get_di_counteR - old_gdic);
+#endif /* NIX */
+
+ return(ret);
+}
+
+
+/*
+   @param flag  bit0= iso_rr_path is freshly added and up to date
+                bit1= do not mark as changed content (implied by bit0 too)
+                bit2= -follow: this is not a command parameter
+   @return -1= severe error
+            0= not applicable for hard links
+            1= go on with processing
+            2= iso_rr_path is fully updated
+ */
+int Xorriso_hardlink_update(struct XorrisO *xorriso, int *compare_result,
+                            char *disk_path, char *iso_rr_path, int flag)
+{
+ int ret, hret, idx, low, high, i, do_overwrite= 0, did_fake_di= 0;
+ int follow_links, old_idx= -1;
+ IsoNode *node;
+ struct stat stbuf;
+ dev_t old_dev;
+ ino_t old_ino;
+
+ if(xorriso->di_array == NULL)
+   return(1);
+ follow_links= xorriso->do_follow_links ||
+               (xorriso->do_follow_param && !(flag & 4));
+ ret= Xorriso_node_from_path(xorriso, NULL, iso_rr_path, &node, 0);
+ if(ret <= 0)
+   return(ret);
+ if(LIBISO_ISDIR(node))
+   return(1);
+
+ /* Handle eventual hardlink split : */
+ /* This is achieved by setting the content change bit. Reason:
+    The node needs to be removed from di_array because its di is
+    not matching its array index any more. So it becomes invisible for
+    the join check of eventual later hardlink siblings. Therefore
+    it must be updated now, even if it has currently no siblings
+    which it leaves or which it joins.
+ */
+ if(!(flag & (1 | 2)))
+   do_overwrite= 1;
+
+ Xorriso__get_di(node, &old_dev, &old_ino, 0);
+ ret= Xorriso__search_node(xorriso->di_array, xorriso->di_count,
+                           Xorriso__di_cmp, node, &idx, 0);
+ if(ret < 0)
+   {ret= 0; goto ex;}
+ if(ret > 0)
+   old_idx= idx;
+
+ /* Handle eventual hardlink joining : */
+
+ if(follow_links)
+   ret= stat(disk_path, &stbuf);
+ else
+   ret= lstat(disk_path, &stbuf);
+ if(ret==-1)
+   {ret= 0; goto ex;}
+
+ /* Are there new dev-ino-siblings in the image ? */
+ /* Fake isofs.di */
+ if(!(flag & 1)) {
+   ret= Xorriso_record_dev_inode(xorriso, disk_path, stbuf.st_dev,
+                                 stbuf.st_ino, node, iso_rr_path, 1);
+   if(ret <= 0)
+     {ret= -1; goto ex;}
+   did_fake_di= 1;
+   /* temporarily remove node from di_array so it does not disturb 
+       search by its fake di info */;
+   if(old_idx >= 0)
+     xorriso->di_array[old_idx]= NULL;
+ }
+ ret= Xorriso_search_di_range(xorriso, node, &idx, &low, &high, 1);
+ if(did_fake_di) {
+   /* Revoke fake of isofs.di */
+   hret= Xorriso_record_dev_inode(xorriso, disk_path, old_dev, old_ino,
+                                  node, iso_rr_path, 1);
+   if(hret <= 0)
+     {ret= -1; goto ex;}
+   if(old_idx >= 0)
+     xorriso->di_array[old_idx]= node;
+ }
+ if(ret == 0)
+   {ret= 1; goto ex;}
+ if(ret < 0)
+   {ret= 0; goto ex;}
+
+
+#ifdef Xorriso_hardlink_update_debuG
+ /* <<< */
+ if(low < high || idx < 0) {
+   fprintf(stderr,
+   "xorriso_DEBUG: old_idx= %d , low= %d , high= %d , iso= '%s' , disk='%s'\n",
+   old_idx, low, high, iso_rr_path, disk_path);
+   fprintf(stderr,
+         "xorriso_DEBUG: old_dev= %lu , old_ino= %lu ,  dev= %lu , ino= %lu\n",
+         (unsigned long) old_dev, (unsigned long) old_ino,
+         (unsigned long) stbuf.st_dev, (unsigned long) stbuf.st_ino);
+
+   if(idx >= 0 && idx != old_idx)
+     fprintf(stderr, "xorriso_DEBUG: idx= %d , old_idx = %d\n", idx, old_idx);
+ }
+#endif /* Xorriso_hardlink_update_debuG */
+
+ /* Overwrite all valid siblings : */
+ for(i= low; i <= high; i++) {
+   if(i == idx || xorriso->di_array[i] == NULL)
+ continue;
+
+#ifdef Xorriso_hardlink_update_debuG
+ /* <<< */
+{
+ ino_t ino;
+ dev_t dev;
+
+ Xorriso__get_di(xorriso->di_array[i], &dev, &ino, 0);
+ fprintf(stderr, "xorriso_DEBUG: iso_sibling= '%s' , dev= %lu , ino= %lu\n",
+         node_path, (unsigned long) dev, (unsigned long) ino);
+}
+#endif /* Xorriso_hardlink_update_debuG */
+
+   xorriso->di_do_widen[i / 8]|= 1 << (i % 8);
+ }
+
+ ret= 1;
+ex:;
+ if(do_overwrite)
+   *compare_result|= (1<<15);
+ if(old_idx >= 0 && (*compare_result & (3 << 21))) {
+   /* The old di info is obsolete */
+   if(xorriso->di_array[old_idx] != NULL)
+     iso_node_unref(xorriso->di_array[old_idx]);
+   xorriso->di_array[old_idx]= NULL;
+ }
+ return(ret);
+}
+
+
+/* @param flag bit0= do not destroy di_array
+*/
+int Xorriso_finish_hl_update(struct XorrisO *xorriso, int flag)
+{
+ int ret, zero= 0;
+ char *argv[4];
+ struct Xorriso_lsT *disk_lst, *iso_lst;
+
+ if(xorriso->di_array == NULL)
+   {ret= 1; goto ex;}
+ disk_lst= xorriso->di_disk_paths;
+ iso_lst= xorriso->di_iso_paths;
+ while(disk_lst != NULL && iso_lst != NULL) {
+   argv[0]= Xorriso_lst_get_text(iso_lst, 0);
+   argv[1]= "-exec";
+   argv[2]= "widen_hardlinks";
+   argv[3]= Xorriso_lst_get_text(disk_lst, 0);
+   zero= 0;
+   ret= Xorriso_option_find(xorriso, 4, argv, &zero, 0); /* -findi */
+   if(ret < 0)
+     goto ex;
+   disk_lst= Xorriso_lst_get_next(disk_lst, 0);
+   iso_lst= Xorriso_lst_get_next(iso_lst, 0);
+ }
+ ret= 1;
+ex:;
+ if(!(flag & 1))
+   Xorriso_destroy_di_array(xorriso, 0);
+ return(ret);
+}
+
--- a/xorriso/sort_cmp.h
+++ b/xorriso/sort_cmp.h
@ -0,0 +1,62 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of functions which sort and compare
+   tree nodes.
+*/
+
+
+#ifndef Xorriso_pvt_sort_cmp_includeD
+#define Xorriso_pvt_sort_cmp_includeD yes
+
+
+int Xorriso__findi_sorted_ino_cmp(const void *p1, const void *p2);
+
+int Xorriso__hln_cmp(const void *p1, const void *p2);
+
+int Xorriso__findi_sorted_cmp(const void *p1, const void *p2);
+
+int Xorriso__search_node(void *node_array[], int n,
+                         int (*cmp)(const void *p1, const void *p2),
+                         void *node, int *idx, int flag);
+
+int Xorriso_search_in_hln_array(struct XorrisO *xorriso,
+                                 void *node, int *idx, int flag);
+
+int Xorriso__get_di(IsoNode *node, dev_t *dev, ino_t *ino, int flag);
+
+int Xorriso__di_ino_cmp(const void *p1, const void *p2);
+
+int Xorriso__di_cmp(const void *p1, const void *p2);
+
+int Xorriso__sort_di(void *node_array[], int count, int flag);
+
+int Xorriso_invalidate_di_item(struct XorrisO *xorriso, IsoNode *node,
+                               int flag);
+
+int Xorriso_search_di_range(struct XorrisO *xorriso, IsoNode *node,
+                            int *idx, int *low, int *high, int flag);
+
+int Xorriso__node_lba_cmp(const void *node1, const void *node2);
+
+int Xorriso__node_name_cmp(const void *node1, const void *node2);
+
+int Xorriso_sorted_node_array(struct XorrisO *xorriso,
+                              IsoDir *dir_node,
+                              int *nodec, IsoNode ***node_array,
+                              off_t boss_mem, int flag);
+
+int Xorriso_remake_hln_array(struct XorrisO *xorriso, int flag);
+
+int Xorriso_make_di_array(struct XorrisO *xorriso, int flag);
+
+int Xorriso_search_hardlinks(struct XorrisO *xorriso, IsoNode *node,
+                            int *node_idx, int *min_hl, int *max_hl, int flag);
+
+
+#endif /* ! Xorriso_pvt_sort_cmp_includeD */
+
--- a/xorriso/text_io.c
+++ b/xorriso/text_io.c
--- a/xorriso/text_io.h
+++ b/xorriso/text_io.h
@ -0,0 +1,103 @@
+
+/* xorriso - creates, loads, manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2 or later.
+
+   This file contains declarations of text i/o functions.
+*/
+
+
+#ifndef Xorriso_pvt_textio_includeD
+#define Xorriso_pvt_textio_includeD yes
+
+
+int Xorriso_dialog_input(struct XorrisO *xorriso, char line[], int linesize,
+                         int flag);
+
+/** @return -1= abort , 0= no , 1= yes
+*/
+int Xorriso_reassure(struct XorrisO *xorriso, char *cmd, char *which_will,
+                     int flag);
+
+int Xorriso_request_confirmation(struct XorrisO *xorriso, int flag);
+
+/* @param flag bit0= quoted multiline mode
+               bit1= release allocated memory and return 1
+               bit2= with bit0: warn of empty text arguments
+               bit3= deliver as single quoted text including all whitespace
+                     and without any backslash interpretation
+   @return -1=out of memory , 0=line format error , 1=ok, go on , 2=done
+*/
+int Xorriso_read_lines(struct XorrisO *xorriso, FILE *fp, int *linecount,
+                       int *argc, char ***argv, int flag);
+
+int Xorriso_write_to_channel(struct XorrisO *xorriso,
+                             char *in_text, int channel_no, int flag);
+
+int Xorriso_result(struct XorrisO *xorriso, int flag);
+
+int Xorriso_restxt(struct XorrisO *xorriso, char *text);
+
+int Xorriso_info(struct XorrisO *xorriso, int flag);
+
+int Xorriso_mark(struct XorrisO *xorriso, int flag);
+
+
+int Xorriso_write_session_log(struct XorrisO *xorriso, int flag);
+
+
+int Xorriso_status_result(struct XorrisO *xorriso, char *filter, FILE *fp,
+                          int flag);
+
+int Xorriso_status(struct XorrisO *xorriso, char *filter, FILE *fp, int flag);
+
+int Xorriso_pacifier_reset(struct XorrisO *xorriso, int flag);
+
+/* This call is to be issued by long running workers in short intervals.
+   It will check whether enough time has elapsed since the last pacifier
+   message and eventually issue an update message.
+   @param what_done  A sparse description of the action, preferrably in past
+                     tense. E.g. "done" , "files added".
+   @param count The number of objects processed so far.
+                Is ignored if <=0.
+   @param todo  The number of objects to be done in total.
+                Is ignored if <=0.
+   @param current_object A string telling the object currently processed.
+                         Ignored if "".
+   @param flag  bit0= report unconditionally, no time check
+*/
+int Xorriso_pacifier_callback(struct XorrisO *xorriso, char *what_done,
+                              off_t count, off_t todo, char *current_object,
+                              int flag);
+
+int Xorriso_reset_counters(struct XorrisO *xorriso, int flag);
+
+int Xorriso_no_malloc_memory(struct XorrisO *xorriso, char **to_free,
+                             int flag);
+
+int Xorriso_much_too_long(struct XorrisO *xorriso, int len, int flag);
+
+int Xorriso_no_findjob(struct XorrisO *xorriso, char *cmd, int flag);
+
+int Xorriso_report_md5_outcome(struct XorrisO *xorriso, char *severity,
+                               int flag);
+
+int Xorriso_protect_stdout(struct XorrisO *xorriso, int flag);
+
+int Xorriso_msg_op_parse(struct XorrisO *xorriso, char *line,
+                         char *prefix, char *separators,
+                         int max_words, int pflag, int input_lines,
+                         int flag);
+
+int Xorriso_msg_op_parse_bulk(struct XorrisO *xorriso,
+                              char *prefix, char *separators,
+                              int max_words, int pflag, int bulk_lines,
+                              int flag);
+
+int Xorriso_launch_frontend(struct XorrisO *xorriso, int argc, char **argv,
+                           char *cmd_pipe_adr, char *reply_pipe_adr, int flag);
+
+#endif /* ! Xorriso_pvt_textio_includeD */
+
--- a/Show More
+++ b/Show More