Promoted branch to tag

ChangeLog

@@ -0,0 +1,360 @@
+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 -copright_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.
+

Makefile.am

@@ -13,12 +13,65 @@ 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 \
+\
+	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 \
 	version.h
 
 libisoburn_libisoburn_la_LIBADD = \
@@ -26,7 +79,12 @@ libisoburn_libisoburn_la_LIBADD = \
 	-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
@@ -131,7 +183,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 \
@@ -179,6 +233,8 @@ EXTRA_DIST = \
 	COPYRIGHT \
 	COPYING \
 	INSTALL \
+	ChangeLog \
+	libisoburn/libisoburn.ver \
 	xorriso/changelog.txt \
 	xorriso/xorriso_buildstamp_none.h \
 	xorriso/README_gnu_xorriso \

README

@@ -4,7 +4,7 @@
 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.6.pl00.tar.gz
+http://files.libburnia-project.org/releases/libisoburn-0.6.2.pl00.tar.gz
 Copyright (C) 2006-2010 Vreixo Formoso, Thomas Schmitt.
 Provided under GPL version 2 or later.
 ------------------------------------------------------------------------------
@@ -18,10 +18,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 +34,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.6 :
-- libburn.so.4  , version libburn-0.7.8 or higher
-- libisofs.so.6 , version libisofs-0.6.32 or higher
+Dynamic library and compile time header requirements for libisoburn-0.6.2 :
+- libburn.so.4  , version libburn-0.8.4 or higher
+- libisofs.so.6 , version libisofs-0.6.36 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.6.pl00.tar.gz, take it to a directory of your choice
+Obtain libisoburn-0.6.2.pl00.tar.gz, take it to a directory of your choice
 and do:
 
-    tar xzf libisoburn-0.5.6.pl00.tar.gz
-    cd libisoburn-0.5.6
+    tar xzf libisoburn-0.6.2.pl00.tar.gz
+    cd libisoburn-0.6.2
 
 Within that directory execute:
 
@@ -52,11 +55,14 @@ 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
+
+By use of a version script, the libisoburn.so library exposes no other function
+names but those of the API definitions in <libsoburn/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
 
 
                               xorriso
@@ -100,12 +106,46 @@ 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
+
+
                        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()
 

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
 ])
 
@@ -81,7 +83,12 @@ 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])
 ])
@@ -131,16 +138,11 @@ iconv_close(cd);
 ])
 
 
-dnl LIBBURNIA_ASSERT_READLINE disables xorriso readline if not all needed
-dnl functions are present
-AC_DEFUN([LIBBURNIA_ASSERT_READLINE],
+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],
 [
-  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])
-    libburnia_save_LIBS="$LIBS"
-    LIBS="$LIBS -lreadline"
     AC_TRY_LINK([
 #include <ctype.h>
 #include <sys/types.h>
@@ -156,17 +158,58 @@ add_history("");
 hl= history_list();
 ], [readline_test="yes"], [readline_test="no"]
     )
-    AC_MSG_RESULT([$readline_test])
+])
+
+
+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 LIBBURNIA_SET_PKGCONFIG determines the install directory for the *.pc file.
+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],

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([libisoburn], [0.5.6], [http://libburnia-project.org])
+AC_INIT([libisoburn], [0.6.2], [http://libburnia-project.org])
 AC_PREREQ([2.50])
 dnl AC_CONFIG_HEADER([config.h])	
 
@@ -22,8 +22,8 @@ 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=6
+ISOBURN_MINOR_VERSION=6
+ISOBURN_MICRO_VERSION=2
 
 dnl ISOBURN_VERSION=$ISOBURN_MAJOR_VERSION.$ISOBURN_MINOR_VERSION.$ISOBURN_MICRO_VERSION
  
@@ -36,16 +36,16 @@ dnl Libtool versioning
 dnl Generate libisoburn.so.1.x.y
 dnl SONAME will become LT_CURRENT - LT_AGE
 dnl 
-dnl ts B00504
-dnl This is the release version 0.5.6 = libisoburn.so.1.45.0
+dnl ts B00918
+dnl This is the release version 0.6.2 = libisoburn.so.1.51.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 = 46 - 45 = 1 . Library name = libisoburn.so.1.45.0
+dnl SONAME = 52 - 51 = 1 . Library name = libisoburn.so.1.51.0
 LT_RELEASE=$ISOBURN_MAJOR_VERSION.$ISOBURN_MINOR_VERSION
-LT_CURRENT=46
-LT_AGE=45
+LT_CURRENT=52
+LT_AGE=51
 LT_REVISION=0
 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
 
@@ -251,16 +251,41 @@ else
 fi
 AC_SUBST(XORRISO_DVD_OBS_64K)
 
+# 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 "disabled strict symbol encapsulation (test failed)"
+    else
+        echo "enabled  strict symbol encapsulation"
+    fi
+else
+    echo "disabled strict symbol encapsulation"
+fi
 
 AC_CHECK_HEADER(libburn/libburn.h)
 AC_CHECK_HEADER(libisofs/libisofs.h)
 
+
+# ------- Visible mark in configure : Start of library check
+
 dnl Check for proper library versions
-LIBBURN_REQUIRED=0.7.8
-LIBISOFS_REQUIRED=0.6.32
+LIBBURN_REQUIRED=0.8.4
+LIBISOFS_REQUIRED=0.6.36
 PKG_CHECK_MODULES(LIBBURN, libburn-1 >= $LIBBURN_REQUIRED)
 PKG_CHECK_MODULES(LIBISOFS, libisofs-1 >= $LIBISOFS_REQUIRED)
 
+# ------- Visible mark in configure : End of library check
+
+
 if test x$LIBCDIO_DEF = x
 then
     if test x$enable_libcdio = xyes
@@ -295,6 +320,8 @@ else
     CFLAGS="$CFLAGS -DDEBUG"
 fi
 
+CFLAGS="$CFLAGS $READLINE_DEF $LIBACL_DEF $XATTR_DEF $EXTF_DEF $EXTF_SUID_DEF $ZLIB_DEF $XORRISO_DVD_OBS_64K"
+
 AC_CONFIG_FILES([
 	Makefile
 	doc/doxygen.conf

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.
+
 */

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. 

libisoburn/burn_wrap.c

@@ -10,6 +10,10 @@
    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
@@ -796,7 +800,8 @@ void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
        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) */
      }
    }
  }
@@ -1187,7 +1192,7 @@ int isoburn_emulate_toc(struct burn_drive *d, int flag)
    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;
@@ -1214,7 +1219,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.
      */

libisoburn/data_source.c

@@ -6,6 +6,10 @@
   Provided under GPL version 2 or later.
 */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 

libisoburn/isoburn.c

@@ -12,6 +12,10 @@
   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) {
@@ -133,8 +137,9 @@ int isoburn_new(struct isoburn **objpt, int flag)
  o->fabricated_disc_status= BURN_DISC_UNREADY;
  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->iso_data_source= NULL;
  o->read_pacifier= NULL;
@@ -144,9 +149,15 @@ int isoburn_new(struct isoburn **objpt, int flag)
  o->msgs_submit_flag= 0;
  o->prev= NULL;
  o->next= NULL;
+ 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", 0, "FATAL", 0);
+   isoburn_report_iso_error(ret, "Cannot create image object", 0, "FATAL", 0);
    goto failed;
  }
  isoburn_link(o, isoburn_list_start, 1);
@@ -184,6 +195,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 +355,36 @@ 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(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,
+      o->target_iso_head_size < new_size ? 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
@@ -411,16 +454,9 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
  iso_write_opts_set_rockridge(wopts, opts->rockridge);
  iso_write_opts_set_joliet(wopts, opts->joliet);
  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_omit_version_numbers(wopts, opts->omit_version_numbers);
  iso_write_opts_set_allow_deep_paths(wopts, opts->allow_deep_paths);
@@ -461,6 +497,19 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
                         opts->vol_expiration_time, opts->vol_effective_time,
                         opts->vol_uuid);
 
+ ret= isoburn_adjust_target_iso_head(out_o, opts->partition_offset, 0);
+ if(ret <= 0)
+   {ret= -1; goto ex;}
+ if(opts->no_emul_toc) {
+   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);
@@ -473,6 +522,9 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
  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);
 
  ret = iso_image_create_burn_source(in_o->image, wopts, &wsrc);
  if (ret < 0) {
@@ -570,6 +622,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;
@@ -863,6 +916,9 @@ int isoburn_igopt_new(struct isoburn_imgen_opts **new_o, int flag)
  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;
@@ -904,6 +960,7 @@ 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);
  return(1);
 }
 
@@ -912,7 +969,8 @@ 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);
  return(1);
 }
 
@@ -1141,3 +1199,26 @@ int isoburn_igopt_get_pvd_times(struct isoburn_imgen_opts *opts,
 }
 
 
+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;
+}
+

libisoburn/isoburn.h

@@ -36,11 +36,15 @@ 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)
 
+
 struct isoburn {
 
 
@@ -104,9 +108,14 @@ 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;
@@ -243,6 +252,12 @@ 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);
+
 /**
  * Options for image reading.
    (Comments here may be outdated. API getter/setter function descriptions
@@ -340,6 +355,11 @@ struct isoburn_imgen_opts {
      */
     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;
+
     /* relaxed constraints */
 
     /*
@@ -515,6 +535,16 @@ struct isoburn_imgen_opts {
        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;
+
 };
 
 
@@ -550,6 +580,9 @@ struct isoburn_imgen_opts {
    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))

libisoburn/isofs_wrap.c

@@ -11,6 +11,10 @@
   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]
 
@@ -295,12 +299,109 @@ 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[2048];
+ uint32_t offst, numsec;
+ struct ecma119_pri_vol_desc *pvm;
+ off_t data_count;
+ int ret;
+ char msg[160];
+ static int max_offst= 512 - 32;
+
+ mbr= o->target_iso_head;
+ part= mbr + 446;
+ if(mbr[510] != 0x55 || mbr[511] != 0xAA)
+   return(2); /* not an MBR */
+
+ /* Does the first partition entry look credible ? */
+ if(part[0] != 0x80 && part[0] != 0x00)
+   return(2); /* Invalid partition status */
+ if(part[1] == 0 && part[2] == 0 && part[3] == 0)
+   return(2); /* 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)
+   return(2); /* Zero or unusably small partition start */
+ if((offst % 4) || (numsec % 4))
+   return(2); /* Not aligned to 2k */
+ if(numsec < 72)
+   return(2); /* No room for volume descriptors */
+ offst/= 4;
+ numsec/= 4;
+ if(offst + numsec != img_size)
+   return(2); /* 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)
+   return(2);
+ pvm = (struct ecma119_pri_vol_desc *) buf;
+ if (strncmp((char*) pvm->std_identifier, "CD001", 5) != 0)
+   return(2); /* not a PVD */
+ if (pvm->vol_desc_type[0] != 1 || pvm->vol_desc_version[0] != 1 
+     || pvm->file_structure_version[0] != 1 )
+   return(2); /* failed sanity check */
+
+ if(iso_read_lsb(pvm->vol_space_size, 4) + offst != img_size)
+   return(2); /* 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 > 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);
+   return(3);
+ }
+
+ /* Accept partition start and adjust buffer size */
+ ret= isoburn_adjust_target_iso_head(o, offst, 0);
+ if(ret <= 0)
+   return(ret);
+
+ return(1);
+}
+
+
 /** 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
@@ -333,8 +434,8 @@ int isoburn_start_emulation(struct isoburn *o, int flag)
  if (capacity > 0 || role == 2) {
    /* 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, 
@@ -366,7 +467,7 @@ int isoburn_start_emulation(struct isoburn *o, int flag)
 
  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 */
@@ -379,6 +480,9 @@ int isoburn_start_emulation(struct isoburn *o, int flag)
 
    /* 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)
+     return ret;
    size *= (off_t) 2048; /* block size in bytes */
    isoburn_set_start_byte(o, size, 0);
    o->fabricated_disc_status= BURN_DISC_APPENDABLE;
@@ -391,6 +495,7 @@ int isoburn_start_emulation(struct isoburn *o, int flag)
    /* treat any disc in an unknown format as full */
    o->fabricated_disc_status= BURN_DISC_FULL;
  }
+
  return 1;
 }
 

libisoburn/libisoburn.h

@@ -1,10 +1,10 @@
 
 /*
-  API definition of libisoburn.
+  Lower level API definition of libisoburn.
 
   Copyright 2007-2010 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
                   and Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
+  Provided under GPL version 2 or later.
 */
 
 /**                           Overview
@@ -18,6 +18,9 @@ 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.
 
+Note that there is a higher level of API: xorriso.h. One should not mix it
+with the API calls of libisoburn.h, libisofs.h, and libburn.h.
+
 
                           Connector functions
 
@@ -143,6 +146,10 @@ size.
 
 */
 
+/* Important: If you add a public API function then add its name to file
+                  libisoburn/libisoburn.ver
+*/
+
 
                           /* API functions */
 
@@ -161,7 +168,7 @@ int isoburn_initialize(char msg[1024], int flag);
     major.minor.micro revision triple can be delivered by the library version
     which is performing this call.
     An application of libisoburn can easily memorize the version of the
-    libisofs.h header in its own code. Immediately after isoburn_initialize()
+    libisoburn.h header in its own code. Immediately after isoburn_initialize()
     it should simply do this check:
         if (! isoburn_is_compatible(isoburn_header_version_major,
                                     isoburn_header_version_minor,
@@ -217,15 +224,15 @@ void isoburn_version(int *major, int *minor, int *micro);
 */
 #define isoburn_libisofs_req_major  0
 #define isoburn_libisofs_req_minor  6
-#define isoburn_libisofs_req_micro 32 
+#define isoburn_libisofs_req_micro 36 
 
 /** The minimum version of libburn to be used with this version of libisoburn
     at compile time.
     @since 0.1.0
 */
 #define isoburn_libburn_req_major  0
-#define isoburn_libburn_req_minor  7
-#define isoburn_libburn_req_micro  8
+#define isoburn_libburn_req_minor  8
+#define isoburn_libburn_req_micro  4
 
 
 /** The minimum version of libisofs to be used with this version of libisoburn
@@ -260,8 +267,8 @@ int isoburn_libburn_req(int *major, int *minor, int *micro);
     @since 0.1.0
 */
 #define isoburn_header_version_major  0
-#define isoburn_header_version_minor  5
-#define isoburn_header_version_micro  6
+#define isoburn_header_version_minor  6
+#define isoburn_header_version_micro  2
 /** Note:
     Above version numbers are also recorded in configure.ac because libtool
     wants them as parameters at build time.
@@ -625,7 +632,7 @@ void isoburn_toc_disc_free(struct isoburn_toc_disc *disc);
     @since 0.1.6
     @param d     The drive with the media to inspect
     @param lba   The block number from where to read
-    @param image_blocks  The number of 2048 bytes blocks
+    @param image_blocks  Returns the number of 2048 bytes blocks in the session
     @param info  Caller provided memory, enough to take eventual info reply
     @param flag bit0-7: info return mode
                  0= do not return anything in info (do not even touch it)
@@ -942,6 +949,12 @@ int isoburn_igopt_get_level(struct isoburn_imgen_opts *o, int *level);
                  compare this with the MD5 of the actual copying. If they do
                  not match then issue MISHAP event.
                  See also libisofs.h  iso_write_opts_set_record_md5()
+           bit9= no_emul_toc
+                 @since 0.5.8
+                 On overwriteable media or random access files do not write
+                 the first session to LBA 32 and do not copy the first 64kB
+                 of the first session to LBA 0, but rather write the first
+                 session to LBA 0 directly.
     @return 1 success, <=0 failure
 */
 #define isoburn_igopt_rockridge         1
@@ -952,6 +965,7 @@ int isoburn_igopt_get_level(struct isoburn_imgen_opts *o, int *level);
 #define isoburn_igopt_session_md5      64
 #define isoburn_igopt_file_md5        128
 #define isoburn_igopt_file_stability  256
+#define isoburn_igopt_no_emul_toc     512
 int isoburn_igopt_set_extensions(struct isoburn_imgen_opts *o, int ext);
 int isoburn_igopt_get_extensions(struct isoburn_imgen_opts *o, int *ext);
 
@@ -1159,7 +1173,7 @@ int isoburn_igopt_get_data_start(struct isoburn_imgen_opts *o, int *lba);
 /** Set resp. get parameters "name" and "timestamp" for a scdbackup checksum
     tag. It will be appended to the libisofs session tag if the image starts at
     LBA 0. See isoburn_disc_track_lba_nwa. The scdbackup tag can be used
-    to verify the image by command scdbackup_verify <device> -auto_end.
+    to verify the image by command scdbackup_verify $device -auto_end.
     See scdbackup/README appendix VERIFY for its inner details.
     @since 0.4.4
     @param o          The option set to work on
@@ -1208,20 +1222,59 @@ int isoburn_igopt_set_system_area(struct isoburn_imgen_opts *o,
 int isoburn_igopt_get_system_area(struct isoburn_imgen_opts *o,
                                   char data[32768], int *options);
 
+/** Control production of a second set of volume descriptors (superblock)
+    and directory trees, together with a partition table in the MBR where the
+    first partition has non-zero start address and the others are zeroed.
+    The first partition stretches to the end of the whole ISO image.
+    The additional volume descriptor set and trees will allow to mount the
+    ISO image at the start of the first partition, while it is still possible
+    to mount it via the normal first volume descriptor set and tree at the
+    start of the image resp. storage device.
+    This makes few sense on optical media. But on USB sticks it creates a
+    conventional partition table which makes it mountable on e.g. Linux via
+    /dev/sdb and /dev/sdb1 alike.
+    @since 0.6.2
+    @param opts
+           The option set to be manipulated.
+    @param block_offset_2k
+           The offset of the partition start relative to device start.
+           This is counted in 2 kB blocks. The partition table will show the
+           according number of 512 byte sectors.
+           Default is 0 which causes no second set and trees.
+           If it is not 0 then it must not be smaller than 16.
+    @param secs_512_per_head
+           Number of 512 byte sectors per head. 1 to 63. 0=automatic.
+    @param heads_per_cyl
+           Number of heads per cylinder. 1 to 255. 0=automatic.
+    @return 1 success, <=0 failure
+ */
+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);
+
+
 /** Explicitely set the four timestamps of the emerging ISO image.
     Default with all parameters is 0.
     @since 0.5.4
-    ECMA-119 defines the timestamps in the Primary Volume Descriptor as:
+    @param opts
+           The option set to work on
     @param creation_time
+           ECMA-119 Volume Creation Date and Time
            When "the information in the volume was created."
            A value of 0 means that the timepoint of write start is to be used.
     @param modification_time
+           ECMA-119 Volume Modification Date and Time
            When "the informationin the volume was last modified."
            A value of 0 means that the timepoint of write start is to be used.
     @param expiration_time
+           ECMA-119 Volume Expiration Date and Time
            When "the information in the volume may be regarded as obsolete."
            A value of 0 means that the information never shall expire.
     @param effective_time
+           ECMA-119 Volume Effective Date and Time
            When "the information in the volume may be used."
            A value of 0 means that not such retention is intended.
     @param uuid
@@ -1241,6 +1294,7 @@ int isoburn_igopt_get_pvd_times(struct isoburn_imgen_opts *opts,
                       time_t *expiration_time, time_t *effective_time,
                       char uuid[17]);
 
+
 /* ----------------------------------------------------------------------- */
 /*                      End of Options for image generation                */
 /* ----------------------------------------------------------------------- */
@@ -1303,6 +1357,23 @@ int isoburn_set_read_pacifier(struct burn_drive *drive,
                               int (*read_pacifier)(IsoImage*, IsoFileSource*),
                               void *app_handle);
 
+/** Inquire the partition offset of the loaded image. The first 512 bytes of
+    the image get examined whether they bear an MBR signature and a first
+    partition table entry which matches the size of the image. In this case
+    the start address is recorded as partition offset and internal buffers
+    get adjusted.
+    See also isoburn_igopt_set_part_offset().
+    @since 0.6.2
+    @param drive           The drive with the loaded image
+    @param block_offset_2k returns the recognized partition offset
+    @return <0 = error
+             0 = no partition offset recognized
+             1 = acceptable non-zero offset, buffers are adjusted
+             2 = offset is credible but not acceptable for buffer size
+*/ 
+int isoburn_get_img_partition_offset(struct burn_drive *drive,
+                                     uint32_t *block_offset_2k);
+
 
 /** Set the IsoImage to be used with a drive. This eventually releases
     the reference to the old IsoImage attached to the drive.
@@ -1601,3 +1672,7 @@ void isoburn_finish(void);
 int isoburn_needs_emulation(struct burn_drive *d);
  
 
+/* ---------------------------- Test area ----------------------------- */
+
+/* no tests active, currently */
+

libisoburn/libisoburn.ver

@@ -0,0 +1,255 @@
+LIBISOBURN1 {
+global:
+isoburn_activate_session;
+isoburn_attach_image;
+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_fifo_status;
+isoburn_get_min_start_byte;
+isoburn_get_mount_params;
+isoburn_igopt_destroy;
+isoburn_igopt_get_data_start;
+isoburn_igopt_get_effective_lba;
+isoburn_igopt_get_extensions;
+isoburn_igopt_get_fifo_size;
+isoburn_igopt_get_level;
+isoburn_igopt_get_out_charset;
+isoburn_igopt_get_over_mode;
+isoburn_igopt_get_over_ugid;
+isoburn_igopt_get_pvd_times;
+isoburn_igopt_get_relaxed;
+isoburn_igopt_get_scdbackup_tag;
+isoburn_igopt_get_sort_files;
+isoburn_igopt_get_system_area;
+isoburn_igopt_new;
+isoburn_igopt_set_extensions;
+isoburn_igopt_set_fifo_size;
+isoburn_igopt_set_level;
+isoburn_igopt_set_out_charset;
+isoburn_igopt_set_over_mode;
+isoburn_igopt_set_over_ugid;
+isoburn_igopt_set_pvd_times;
+isoburn_igopt_set_relaxed;
+isoburn_igopt_set_scdbackup_tag;
+isoburn_igopt_set_sort_files;
+isoburn_igopt_set_system_area;
+isoburn_initialize;
+isoburn_is_compatible;
+isoburn_libburn_req;
+isoburn_libisofs_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_default_dirperms;
+isoburn_ropt_get_default_perms;
+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_default_dirperms;
+isoburn_ropt_set_default_perms;
+isoburn_ropt_set_extensions;
+isoburn_ropt_set_input_charset;
+isoburn_set_msc1;
+isoburn_set_msgs_submit;
+isoburn_set_read_pacifier;
+isoburn_sync_after_write;
+isoburn_toc_disc_free;
+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_change_is_pending;
+Xorriso_destroy;
+Xorriso_dialog;
+Xorriso_eval_problem_status;
+Xorriso_execute_option;
+Xorriso__get_patch_level_text;
+Xorriso_get_problem_status;
+Xorriso_interpreter;
+Xorriso__is_compatible;
+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_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_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_close;
+Xorriso_option_close_filter_list;
+Xorriso_option_commit;
+Xorriso_option_commit_eject;
+Xorriso_option_compare;
+Xorriso_option_compliance;
+Xorriso_option_copyright_file;
+Xorriso_option_cpri;
+Xorriso_option_cpx;
+Xorriso_option_cut_out;
+Xorriso_option_dev;
+Xorriso_option_devices;
+Xorriso_option_dialog;
+Xorriso_option_disk_dev_ino;
+Xorriso_option_disk_pattern;
+Xorriso_option_drive_class;
+Xorriso_option_dummy;
+Xorriso_option_dvd_obs;
+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_hide;
+Xorriso_option_history;
+Xorriso_option_iso_rr_pattern;
+Xorriso_option_joliet;
+Xorriso_option_list_delimiter;
+Xorriso_option_list_formats;
+Xorriso_option_list_profiles;
+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_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_rollback;
+Xorriso_option_rom_toc_scan;
+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_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_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_xattr;
+Xorriso_option_zisofs;
+Xorriso_prescan_args;
+Xorriso__preset_signal_behavior;
+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_startup_libraries;
+Xorriso__version;
+local: *;
+};
+

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>
@@ -250,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);
@@ -259,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);
    }
  }
 

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.6.tar.gz
+ftp://ftp.gnu.org/gnu/xorriso/xorriso-0.6.2.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.
 
@@ -40,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.6.tar.gz, take it to a directory of your choice and do:
+Obtain xorriso-0.6.2.tar.gz, take it to a directory of your choice and do:
 
-    tar xzf xorriso-0.5.6.tar.gz
-    cd xorriso-0.5.6
+    tar xzf xorriso-0.6.2.tar.gz
+    cd xorriso-0.6.2
 
 Within that directory execute:
 
@@ -100,8 +101,9 @@ Other deliberate dependency reduction options of ./configure are:
     --disable-zlib     avoid use of zlib functions like compress2()
 
 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
@@ -133,24 +135,29 @@ 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 Dependend 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. 
@@ -269,22 +276,23 @@ xorriso is based on libisofs which does ISO 9600 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.4 :
-- libburn.so.4  , version libburn-0.7.8 or higher
-- libisofs.so.6 , version libisofs-0.6.30 or higher
+Dynamic library and compile time header requirements for libisoburn-0.6.2 :
+- libburn.so.4  , version libburn-0.8.4 or higher
+- libisofs.so.6 , version libisofs-0.6.36 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.
@@ -292,6 +300,83 @@ setup unless you have reason to enforce a newer bug fix level.
 GNU xorriso has less runtime dependencies and can be moved more freely.
 
 
+                  System Dependend 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 aquired 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.
+
+
 ------------------------------------------------------------------------------
 
     This program is free software; you can redistribute it and/or modify

xorriso/aux_objects.h

@@ -0,0 +1,181 @@
+
+/* 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 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 */
+

xorriso/base_obj.c

@@ -0,0 +1,575 @@
+
+
+
+/* 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 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 "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[SfileadrL];
+ 
+ *xorriso= m= TSOB_FELD(struct XorrisO,1);
+ if(m==NULL)
+   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->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->do_joliet= 0;
+ m->do_aaip= 0;
+ m->do_md5= 0;
+ m->no_emul_toc= 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->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->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->drives_exclusive= 1;
+ 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->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->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->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_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->vol_creation_time= 0;
+ m->vol_modification_time= 0;
+ m->vol_expiration_time= 0;
+ m->vol_effective_time= 0;
+ m->vol_uuid[0]= 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->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->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;
+ 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->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,"FATAL");
+ Xorriso__text_to_sev(m->abort_on_text, &m->abort_on_severity, 0);
+ m->problem_status= 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= 2;         /* abort faulty image reading with FATAL */
+ 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->pacifier_style= 0;
+ m->pacifier_interval= 1.0;
+ m->pacifier_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->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->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;
+ 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 */
+
+ return(1);
+failure:;
+ Xorriso_destroy(xorriso, 0);
+ 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;
+
+ m= *xorriso;
+ if(m==NULL)
+   return(0);
+ 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);
+ 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);
+
+ Xorriso_detach_libraries(m, flag&1);
+
+ 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 > 1)
+   return(0);
+ Xorriso_signal_behavioR= behavior;
+ return(1);
+}
+
+
+int Xorriso__get_signal_behavior(int flag)
+{
+ return(Xorriso_signal_behavioR);
+}
+

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 */
+

xorriso/check_media.h

@@ -0,0 +1,181 @@
+
+/* 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 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 mode;           /* 0= track by track
+                        1= single sweep over libisoburn media capacity
+                        >>> 2= single sweep over libburn media capacity
+                     */
+ time_t start_time;  
+ int time_limit;     /* Number of seconds after which to abort */
+ 
+ int item_limit;     /* Maximum number of media 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 */
+

xorriso/cmp_update.c

@@ -0,0 +1,955 @@
+
+/* 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 actions which compare or update
+   files between disk filesystem and ISO filesystem.
+*/
+
+#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 <pwd.h>
+#include <grp.h>
+
+
+#include "xorriso.h"
+#include "xorriso_private.h"
+#include "xorrisoburn.h"
+
+
+/*
+   @param result  Bitfield indicationg type of mismatch
+              bit11= cannot open regular disk file
+              bit12= cannot open iso file
+              bit13= early eof of disk file
+              bit14= early eof of iso file
+              bit15= content bytes differ
+   @param flag bit0= mtimes of both file objects are equal
+              bit29= do not issue pacifier messages
+              bit31= do not issue result messages
+   @return    >0 ok , <=0 error
+*/
+int Xorriso_compare_2_contents(struct XorrisO *xorriso, char *common_adr,
+                               char *disk_adr, off_t disk_size,
+                               off_t offset, off_t bytes,
+                               char *iso_adr, off_t iso_size,
+                               int *result, int flag)
+{
+ int fd1= -1, ret, r1, r2, done, wanted, i, was_error= 0, use_md5= 0;
+ void *stream2= NULL;
+ off_t r1count= 0, r2count= 0, diffcount= 0, first_diff= -1;
+ char *respt, buf1[32*1024], buf2[32*1024], offset_text[80];
+ char disk_md5[16], iso_md5[16];
+ void *ctx= NULL;
+
+ respt= xorriso->result_line;
+
+ fd1= open(disk_adr, O_RDONLY);
+ if(fd1==-1) {
+   sprintf(respt, "- %s (DISK) : cannot open() : %s\n",
+           disk_adr, strerror(errno));
+cannot_address:;
+   if(!(flag&(1<<31)))
+     Xorriso_result(xorriso,0);
+   (*result)|= 2048;
+   {ret= 0; goto ex;}
+ }
+ if(offset>0)
+   if(lseek(fd1, offset, SEEK_SET)==-1) {
+     sprintf(respt, "- %s (DISK) : cannot lseek(%.f) : %s\n",
+             disk_adr, (double) offset, strerror(errno));
+     close(fd1);
+     goto cannot_address;
+   }
+
+ if(xorriso->do_md5 & 16) {
+   use_md5= 1;
+   ret= Xorriso_is_plain_image_file(xorriso, NULL, iso_adr, 0);
+   if(ret <= 0) 
+     ret= 0; /* (reverse) filtered files are likely not to match their MD5 */
+   else
+     ret= Xorriso_get_md5(xorriso, NULL, iso_adr, iso_md5, 1);
+   if(ret <= 0)
+     use_md5= 0;
+   else {
+     ret= Xorriso_md5_start(xorriso, &ctx, 0);
+     if(ret <= 0)
+       use_md5= 0;
+   }
+ }
+ if (! use_md5) {
+   ret= Xorriso_iso_file_open(xorriso, iso_adr, NULL, &stream2, 0);
+   if(ret<=0) {
+     sprintf(respt, "- %s  (ISO) : cannot open() file in ISO image\n",iso_adr);
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     close(fd1);
+     (*result)|= 4096;
+     {ret= 0; goto ex;}
+   }
+ }
+
+ done= 0;
+ while(!done) {
+
+   wanted= sizeof(buf1);
+   if(r1count+offset+wanted>disk_size)
+     wanted= disk_size-r1count-offset;
+   if(r1count+wanted>bytes)
+     wanted= bytes-r1count;
+   r1= 0;
+   while(wanted>0) {
+     ret= read(fd1, buf1, wanted);
+     if(ret<=0)
+   break;
+     wanted-= ret;
+     r1+= ret;
+   }
+
+   wanted= sizeof(buf2);
+   if(r2count+wanted>iso_size)
+     wanted= iso_size-r2count;
+/*
+   if(r2count+wanted>bytes)
+     wanted= bytes-r2count;
+*/
+   if(use_md5)
+     r2= r1;
+   else if(wanted>0)
+     r2= Xorriso_iso_file_read(xorriso, stream2, buf2, wanted, 0);
+   else
+     r2= 0;
+
+   if(r1<0 || r2<0)
+     was_error= 1;
+
+   if(r1<=0 && r2<=0)
+ break;
+   if(r1<=0) {
+     if(r1<0)
+       r1= 0;
+     if(disk_size > r1count + r1 + offset) {
+       sprintf(respt, "- %s (DISK) : early EOF after %.f bytes\n",
+               disk_adr, (double) r1count);
+       if(!(flag&(1<<31)))
+         Xorriso_result(xorriso,0);
+       (*result)|= 8196;
+     }
+     (*result)|= (1<<15);
+   }
+   r1count+= r1;
+   if(r2<=0 || r2<r1) {
+     if(r2<0)
+       r2= 0;
+     if(iso_size > r2count + r2) {
+       sprintf(respt, "- %s  (ISO) : early EOF after %.f bytes\n",
+               iso_adr, (double) r2count);
+       if(!(flag&(1<<31)))
+         Xorriso_result(xorriso,0);
+       (*result)|= (1<<14);
+     }
+     (*result)|= (1<<15);
+     done= 1;
+   }
+   if(r2>r1) {
+     if(disk_size > r1count + r1 + offset) {
+       sprintf(respt, "- %s (DISK) : early EOF after %.f bytes\n",
+               disk_adr, (double) r1count);
+       if(!(flag&(1<<31)))
+         Xorriso_result(xorriso,0);
+       (*result)|= 8196;
+     }
+     (*result)|= (1<<15);
+     done= 1;
+   }
+   r2count+= r2;
+   if(r1>r2)
+     r1= r2;
+
+   if(use_md5) {
+     Xorriso_md5_compute(xorriso, ctx, buf1, r1, 0);
+   } else {
+     for(i= 0; i<r1; i++) {
+       if(buf1[i]!=buf2[i]) {
+         if(first_diff<0)
+           first_diff= r1count - r1 + i;
+         diffcount++;
+       }
+     }
+   }
+   if(!(flag&(1<<29))) {
+     xorriso->pacifier_count+= r1;
+     xorriso->pacifier_byte_count+= r1;
+     if(flag&(1<<31))
+       Xorriso_pacifier_callback(xorriso, "content bytes read",
+                                 xorriso->pacifier_count, 0, "", 0);
+     else
+       Xorriso_pacifier_callback(xorriso, "bytes", xorriso->pacifier_count, 0,
+                                 "", 1<<6);
+   }
+ }
+
+ if(use_md5) {
+   ret= Xorriso_md5_end(xorriso, &ctx, disk_md5, 0);
+   if(ret <= 0) {
+     *result |= (1 << 15);
+     ret= -1; goto ex;
+   }
+   for(i= 0; i < 16; i++)
+     if(iso_md5[i] != disk_md5[i])
+   break;
+   if(i < 16 ) {
+     offset_text[0]= 0;
+     if(offset>0)
+       sprintf(offset_text, "%.f+", (double) offset);
+     sprintf(respt, "%s %s  :  differs by MD5 sums.\n",
+             common_adr, (flag&1 ?  "CONTENT": "content"));
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     (*result)|= (1<<15);
+   }
+ } else if(diffcount>0 || r1count!=r2count) {
+   if(first_diff<0)
+     first_diff= (r1count>r2count ? r2count : r1count);
+   offset_text[0]= 0;
+   if(offset>0)
+     sprintf(offset_text, "%.f+", (double) offset);
+   sprintf(respt, "%s %s  :  differs by at least %.f bytes. First at %s%.f\n",
+           common_adr, (flag&1 ?  "CONTENT": "content"),
+           (double) (diffcount + abs(r1count-r2count)),
+           offset_text, (double) first_diff);
+   if(!(flag&(1<<31)))
+     Xorriso_result(xorriso,0);
+   (*result)|= (1<<15);
+ }
+ if(fd1!=-1)
+   close(fd1);
+ if(! use_md5)
+   Xorriso_iso_file_close(xorriso, &stream2, 0);
+ if(was_error)
+   {ret= -1; goto ex;}
+ ret= 1;
+ex:;
+ if(ctx != NULL)
+   Xorriso_md5_end(xorriso, &ctx, disk_md5, 0);
+ return(ret);
+}
+
+
+/*
+   @param result  Bitfield indicationg type of mismatch
+               bit0= disk_adr not existing
+               bit1= iso_adr not existing
+               bit2= access permissions
+               bit3= file type 
+               bit4= user id
+               bit5= group id
+               bit6= minor, major with device file
+               bit7= size
+               bit8= mtime
+               bit9= atime
+              bit10= ctime
+              bit11= cannot open regular disk file
+              bit12= cannot open iso file
+              bit13= early eof of disk file
+              bit14= early eof of iso file
+              bit15= content bytes differ
+              bit16= symbolic link on disk pointing to dir, dir in iso
+              bit17= file chunks detected and compared
+              bit18= incomplete chunk collection encountered
+              bit19= ACL differs (this condition sets also bit2)
+              bit20= xattr differ
+              bit21= mismatch of recorded dev,inode
+              bit22= no recorded dev,inode found in node
+              bit23= timestamps younger than xorriso->isofs_st_in
+              bit24= hardlink split
+              bit25= hardlink fusion
+   @param flag bit0= compare atime
+               bit1= compare ctime
+               bit2= check only existence of both file objects
+                     count one or both missing as "difference"
+              bit27= for Xorriso_path_is_excluded(): bit0
+              bit28= examine eventual disk_path link target rather than link
+              bit29= do not issue pacifier messages
+              bit30= omit adr_common_tail in report messages
+              bit31= do not issue result messages
+   @return     1=files match properly , 0=difference detected , -1=error
+*/
+int Xorriso_compare_2_files(struct XorrisO *xorriso, char *disk_adr,
+                            char *iso_adr, char *adr_common_tail,
+                            int *result, int flag)
+{
+ struct stat s1, s2, stbuf;
+ int ret, missing= 0, is_split= 0, i, was_error= 0, diff_count= 0;
+ int content_shortcut= 0, mask;
+ char *respt;
+ char a[5*SfileadrL], sfe[5*SfileadrL];
+ char ttx1[40], ttx2[40];
+ char *a1_acl= NULL, *a2_acl= NULL, *d1_acl= NULL, *d2_acl= NULL;
+ char *attrlist1= NULL, *attrlist2= NULL;
+ struct SplitparT *split_parts= NULL;
+ int split_count= 0;
+ time_t stamp;
+
+ char part_path[SfileadrL], *part_name;
+ int partno, total_parts= 0;
+ off_t offset, bytes, total_bytes;
+
+ *result= 0;
+ respt= xorriso->result_line;
+
+ if(!(xorriso->disk_excl_mode&8)) {
+   ret= Xorriso_path_is_excluded(xorriso, disk_adr, 2 | !!(flag&(1<<27)));
+   if(ret>0) {
+     sprintf(respt , "? %s (DISK) : exluded by %s\n",
+             Text_shellsafe(disk_adr, sfe, 0),
+             (ret==1 ? "-not_paths" : "-not_leaf"));
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     missing= 1;
+     (*result)|= 1;
+   }
+ }
+ if(!missing) {
+   if(flag&(1<<28))
+     ret= stat(disk_adr, &s1);
+   else
+     ret= lstat(disk_adr, &s1);
+   if(ret==-1) {
+     sprintf(respt , "? %s (DISK) : cannot lstat() : %s\n",
+             Text_shellsafe(disk_adr, sfe, 0), strerror(errno));
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     missing= 1;
+     (*result)|= 1;
+   }
+ }
+ if(missing)
+   strcpy(a, "?");
+ else
+   strcpy(a, Ftypetxt(s1.st_mode, 1));  
+ strcat(a, " ");
+ if(adr_common_tail[0])
+   strcat(a, Text_shellsafe(adr_common_tail, sfe, 0));
+ else {
+   Text_shellsafe(disk_adr, a+strlen(a), 0);
+   strcat(a, " (DISK)");
+/*
+   strcat(a, "'.'");
+*/
+ }
+ strcat(a, " :");
+ if(flag&(1<<30))
+   a[0]= 0;
+
+ ret= Xorriso_iso_lstat(xorriso, iso_adr, &s2, 0);
+ if(ret<0) {
+   sprintf(respt, "? %s  (ISO) : cannot find this file in ISO image\n",
+           Text_shellsafe(iso_adr, sfe, 0));
+   if(!(flag&(1<<31)))
+     Xorriso_result(xorriso,0);
+   missing= 1;
+   (*result)|= 2;
+ }
+
+ if((flag&4)||missing)
+   {ret= !missing; goto ex;}
+
+
+ /* Splitfile parts */
+ if((S_ISREG(s1.st_mode) || S_ISBLK(s1.st_mode)) && S_ISDIR(s2.st_mode)) {
+   is_split= Xorriso_identify_split(xorriso, iso_adr, NULL, &split_parts,
+                                    &split_count, &s2, 0);
+   if(is_split>0)
+     (*result)|= (1<<17);
+   else
+     is_split= 0;
+ }
+
+ /* Attributes */
+ if(s1.st_mode != s2.st_mode) {
+   if((s1.st_mode&~S_IFMT)!=(s2.st_mode&~S_IFMT)) {
+     sprintf(respt, "%s st_mode  :  %7.7o  <>  %7.7o\n",
+             a, (unsigned int) (s1.st_mode & ~S_IFMT),
+                (unsigned int) (s2.st_mode & ~S_IFMT));
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     (*result)|= 4;
+   }
+
+   if((s1.st_mode&S_IFMT)!=(s2.st_mode&S_IFMT)) {
+     sprintf(respt, "%s type     :  %s  <>  %s\n",
+             a, Ftypetxt(s1.st_mode, 0), Ftypetxt(s2.st_mode, 0));
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     (*result)|= 8;
+     if((s1.st_mode&S_IFMT) == S_IFLNK) {
+       /* check whether link target type matches */
+       ret= stat(disk_adr, &stbuf);
+       if(ret!=-1)
+         if(S_ISDIR(stbuf.st_mode) && S_ISDIR(s2.st_mode))
+           (*result)|= (1<<16);
+     }
+   }
+ }
+
+ /* ACL */
+ if(xorriso->do_aaip & 3) {
+   Xorriso_local_getfacl(xorriso, disk_adr, &a1_acl,
+                         16 | ((flag & (1 << 28)) >> 23));
+   if(S_ISDIR(s1.st_mode))
+     Xorriso_local_getfacl(xorriso, disk_adr, &d1_acl, 1);
+   ret= Xorriso_getfacl(xorriso, NULL, iso_adr, &a2_acl, 1 | 4 | 16);
+   if(ret < 0)
+     goto ex;
+   if(S_ISDIR(s1.st_mode)) {
+     ret= Xorriso_getfacl(xorriso, NULL, iso_adr, &d2_acl, 1 | 8);
+     if(ret < 0)
+       goto ex;
+   }
+   ret= Compare_text_lines(a1_acl, a2_acl, &diff_count, 0);
+   if(ret < 0)
+     goto ex;
+   if(ret == 0)
+     (*result)|= 4 | (1 << 19);
+   ret= Compare_text_lines(d1_acl, d2_acl, &diff_count, 1);
+   if(ret < 0)
+     goto ex;
+   if(ret == 0)
+     (*result)|= 4 | (1 << 19);
+   if((*result) & (1 << 19)) {
+     sprintf(respt, "%s ACL      :  %d difference%s\n",
+             a, diff_count, diff_count == 1 ? "" : "s");
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+   }
+ }
+
+ /* xattr */
+ if(xorriso->do_aaip & 12) {
+   ret= Xorriso_getfattr(xorriso, NULL, disk_adr, &attrlist1,
+                         1 | 2 | ((flag & (1 << 28)) >> 23));
+   if(ret < 0)
+     goto ex;
+   ret= Xorriso_getfattr(xorriso, NULL, iso_adr, &attrlist2, 1);
+   if(ret < 0)
+     goto ex;
+   ret= Compare_text_lines(attrlist1, attrlist2, &diff_count, 0);
+   if(ret < 0)
+     goto ex;
+   if(ret == 0) {
+     (*result)|= (1 << 20);
+     sprintf(respt, "%s xattr    :  %d difference%s\n",
+             a, diff_count, diff_count == 1 ? "" : "s");
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+   }
+ }
+
+ if(s1.st_uid != s2.st_uid) {
+   sprintf(respt, "%s st_uid   :   %lu  <>  %lu\n", a,
+           (unsigned long) s1.st_uid, (unsigned long) s2.st_uid);
+   if(!(flag&(1<<31)))
+     Xorriso_result(xorriso,0);
+   (*result)|= 16;
+ }
+ if(s1.st_gid != s2.st_gid) {
+   sprintf(respt, "%s st_gid   :   %lu  <>  %lu\n", a,
+           (unsigned long) s1.st_gid, (unsigned long) s2.st_gid);
+   if(!(flag&(1<<31)))
+     Xorriso_result(xorriso,0);
+   (*result)|= 32;
+ }
+ if((S_ISCHR(s1.st_mode) && S_ISCHR(s2.st_mode)) ||
+    (S_ISBLK(s1.st_mode) && S_ISBLK(s2.st_mode))) {
+   if(s1.st_rdev != s2.st_rdev) {
+     sprintf(respt, "%s %s st_rdev  :  %lu  <>  %lu\n", a,
+            (S_ISCHR(s1.st_mode) ? "S_IFCHR" : "S_IFBLK"),
+            (unsigned long) s1.st_rdev, (unsigned long) s1.st_rdev);
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     (*result)|= 64;
+   }
+ }
+ if((!(xorriso->do_aaip & 32)) &&
+    S_ISREG(s2.st_mode) && s1.st_size != s2.st_size) {
+   sprintf(respt, "%s st_size  :  %.f  <>  %.f      diff= %.f\n",
+          a, (double) s1.st_size, (double) s2.st_size,
+          ((double) s1.st_size) - (double) s2.st_size);
+   if(!(flag&(1<<31)))
+     Xorriso_result(xorriso,0);
+   (*result)|= 128;
+ }
+ if(s1.st_mtime != s2.st_mtime) {
+   sprintf(respt, "%s st_mtime :  %s  <>  %s      diff= %.f s\n",
+           a, Ftimetxt(s1.st_mtime, ttx1, 0),
+              Ftimetxt(s2.st_mtime, ttx2, 0),
+              ((double) s1.st_mtime) - (double) s2.st_mtime);
+   if(!(flag&(1<<31)))
+     Xorriso_result(xorriso,0);
+   (*result)|= 256;
+ }
+ if(flag&1) {
+   if(s1.st_atime != s2.st_atime) {
+     sprintf(respt, "%s st_atime :  %s  <>  %s      diff= %.f s\n",
+             a, Ftimetxt(s1.st_atime, ttx1, 0), 
+                Ftimetxt(s2.st_atime, ttx2, 0),
+                ((double) s1.st_atime) - (double) s2.st_atime);
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     (*result)|= 512;
+   }
+ }
+ if(flag&2) {
+   if(s1.st_ctime != s2.st_ctime) {
+     sprintf(respt, "%s st_ctime :  %s  <>  %s      diff= %.f s\n",
+             a, Ftimetxt(s1.st_ctime, ttx1, 0),
+                Ftimetxt(s2.st_ctime, ttx2, 0),
+                ((double) s1.st_ctime) - (double) s2.st_ctime);
+     if(!(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     (*result)|= 1024;
+   }
+ }
+ if(xorriso->isofs_st_in > 0 &&
+    (xorriso->isofs_st_in <= s2.st_mtime ||
+     ((flag & 1) && xorriso->isofs_st_in <= s2.st_atime) ||
+     ((flag & 2) && xorriso->isofs_st_in <= s2.st_ctime)))
+   (*result)|= 1 << 23;
+
+ if((xorriso->do_aaip & 32) || !(xorriso->ino_behavior & 2)) {
+   /* dev,inode comparison.
+      For skipping content comparison or for hardlink detection.
+   */
+   ret= Xorriso_record_dev_inode(xorriso, "", s1.st_dev, s1.st_ino, NULL,
+       iso_adr, 1 | 2 | ((flag & (1 << 28)) >> 23) | (xorriso->do_aaip & 128));
+   if(ret < 0) {
+     ret= -1; goto ex;
+   } else if(ret == 0) { /* match */
+     if((xorriso->do_aaip & 64) && S_ISREG(s1.st_mode) && S_ISREG(s2.st_mode)){
+       if(xorriso->do_aaip & 32)
+         content_shortcut= 1;
+       if((*result) & (8 | 128 | 256 | 512 | 1024 | (1 << 23))) {
+         (*result)|= (1 << 15); /* content bytes differ */
+         if(((*result) & (1 << 23)) &&
+            !((*result) & (8 | 128 | 256 | 512 | 1024))) {
+           sprintf(respt,
+            "%s content  :  node timestamp younger than image timestamp\n", a);
+           if((xorriso->do_aaip & 32) && !(flag&(1<<31)))
+             Xorriso_result(xorriso,0);
+           stamp= s2.st_mtime;
+           if((flag & 1) && s2.st_atime >= stamp)
+             stamp= s2.st_atime;
+           if((flag & 2) && s2.st_ctime >= stamp)
+             stamp= s2.st_ctime;
+           sprintf(respt, "%s content  :  %s  >  %s    diff= %.f s\n",
+                   a, Ftimetxt(stamp, ttx1, 3 << 1),
+                   Ftimetxt(xorriso->isofs_st_in, ttx2, 3 << 1),
+                   ((double) stamp) - (double) xorriso->isofs_st_in);
+           if((xorriso->do_aaip & 32) && !(flag&(1<<31)))
+             Xorriso_result(xorriso,0);
+         }
+         sprintf(respt,
+          "%s content  :  assuming inequality due to size or timestamps\n", a);
+         if((xorriso->do_aaip & 32) && !(flag&(1<<31)))
+           Xorriso_result(xorriso,0);
+       }
+     }
+   } else if(ret == 1) { /* mismatch */
+     (*result)|= (1 << 21);
+     sprintf(respt, "%s dev_ino  :  differing\n", a);
+     if((xorriso->do_aaip & 32) && !(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+
+     if((xorriso->do_aaip & 64) && S_ISREG(s1.st_mode) && S_ISREG(s2.st_mode)){
+       if(xorriso->do_aaip & 32)
+         content_shortcut= 1;
+       (*result)|= (1 << 15); /* content bytes differ */
+       sprintf(respt,
+             "%s content  :  assuming inequality after dev_ino mismatch\n", a);
+       if((xorriso->do_aaip & 32) && !(flag&(1<<31)))
+         Xorriso_result(xorriso,0);
+     }
+   } else {
+     sprintf(respt, "%s dev_ino  :  no dev_ino stored with image node\n", a);
+     if((xorriso->do_aaip & 32) && !(flag&(1<<31)))
+       Xorriso_result(xorriso,0);
+     (*result)|= (1 << 22);
+   }
+ }
+
+ if(S_ISREG(s1.st_mode) && S_ISREG(s2.st_mode) && !content_shortcut) {
+   /* Content */
+   if(is_split) { 
+     for(i= 0; i<split_count; i++) {
+       Splitparts_get(split_parts, i, &part_name, &partno, &total_parts,
+                      &offset, &bytes, &total_bytes, 0);
+       strcpy(part_path, iso_adr);
+       if(Sfile_add_to_path(part_path, part_name, 0)<=0) {
+         Xorriso_much_too_long(xorriso, strlen(iso_adr)+strlen(part_name)+1,
+                               2);
+         {ret= -1; goto ex;}
+       }
+       ret= Xorriso_iso_lstat(xorriso, part_path, &stbuf, 0);
+       if(ret<0)
+     continue;
+       ret= Xorriso_compare_2_contents(xorriso, a, disk_adr, s1.st_size,
+                                       offset, bytes,
+                                       part_path, stbuf.st_size, result,
+                        (s1.st_mtime==s2.st_mtime) | (flag&((1<<29)|(1<<31))));
+       if(ret<0)
+         was_error= 1;
+     }
+     if(total_parts>0 && split_count!=total_parts) {
+       sprintf(xorriso->info_text,
+               "- %s/* (ISO) : Not all split parts present (%d of %d)\n",
+               iso_adr, split_count, total_parts);
+       if(!(flag&(1<<31)))
+         Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 1);
+       (*result)|= 1<<18;
+     }
+   } else {
+     ret= Xorriso_compare_2_contents(xorriso, a, disk_adr, s1.st_size,
+                                     (off_t) 0, s1.st_size,
+                                     iso_adr, s2.st_size, result,
+                        (s1.st_mtime==s2.st_mtime) | (flag&((1<<29)|(1<<31))));
+     if(ret<0)
+       was_error= 1;
+   }
+
+ }
+ if(was_error)
+   ret= -1;
+ else {
+   mask= ~((1 << 17) | (1 << 18) | (1 << 22) | (1 << 23));
+   if(xorriso->do_aaip & 32)
+     mask|= 1 << 22;
+   ret= (((*result) & mask)==0);
+ }
+ex:;
+ if(split_parts!=NULL)
+   Splitparts_destroy(&split_parts, split_count, 0);
+ Xorriso_local_getfacl(xorriso, disk_adr, &a1_acl, 1 << 15);
+ Xorriso_local_getfacl(xorriso, disk_adr, &d1_acl, 1 << 15);
+ if(a2_acl != NULL)
+   free(a2_acl);
+ if(d2_acl != NULL)
+   free(d2_acl);
+ return(ret);
+}
+
+
+int Xorriso_pfx_disk_path(struct XorrisO *xorriso, char *iso_path,
+                          char *iso_prefix, char *disk_prefix,
+                          char disk_path[SfileadrL], int flag)
+{
+ int ret;
+ char adrc[SfileadrL];
+
+ if(strncmp(iso_path, iso_prefix, strlen(iso_prefix))!=0)
+   return(-1);
+ if(strlen(disk_prefix) + strlen(iso_path) - strlen(iso_prefix)+1 >= SfileadrL)
+   return(-1);
+ if(iso_path[strlen(iso_prefix)] == '/')
+   strcpy(adrc, iso_path + strlen(iso_prefix) + 1);
+ else
+   strcpy(adrc, iso_path + strlen(iso_prefix));
+ ret= Xorriso_make_abs_adr(xorriso, disk_prefix, adrc, disk_path, 4 | 8);
+ if(ret <= 0)
+   return(ret);
+ return(1);
+}
+
+
+/* @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 flag bit0= update rather than compare
+               bit1= find[ix] is in recursion
+   @return <=0 error, 1= ok , 2= iso_path was deleted
+             3=ok, do not dive into directory (e.g. because it is a split file)
+*/
+int Xorriso_find_compare(struct XorrisO *xorriso, void *boss_iter,
+                         char *iso_path, char *iso_prefix, char *disk_prefix,
+                         int flag)
+{
+ int ret, result, uret, follow_links, deleted= 0;
+ char disk_path[SfileadrL];
+
+ ret= Xorriso_pfx_disk_path(xorriso, iso_path, iso_prefix, disk_prefix,
+                            disk_path, 0);
+ if(ret <= 0)
+   return(ret);
+
+ /* compare exclusions against disk_path resp. leaf name */
+ if(xorriso->disk_excl_mode&8)
+   ret= Xorriso_path_is_excluded(xorriso, disk_path, !(flag&2));
+ else
+   ret= 0;
+ if(ret<0)
+   return(ret);
+ if(ret>0)
+   return(3);
+
+ follow_links= (xorriso->do_follow_links ||
+               (xorriso->do_follow_param && !(flag&2))) <<28;
+ ret= Xorriso_compare_2_files(xorriso, disk_path, iso_path, "", &result,
+                        2 | follow_links | ((!(flag&2))<<27) | ((flag&1)<<31));
+                                            /* was once: | ((!(flag&1))<<29) */
+ if(ret<xorriso->find_compare_result)
+   xorriso->find_compare_result= ret;
+ if(flag&1) {
+   if(ret<=0) {
+     if(ret<0)
+       if(Xorriso_eval_problem_status(xorriso, ret, 1|2)<0)
+         return(ret);
+     uret= Xorriso_update_interpreter(xorriso, boss_iter, result,
+                                      disk_path, iso_path, (flag&2)<<1);
+     if(uret<=0)
+       ret= 0;
+     if(uret==2)
+       deleted= 1;
+   }
+ }
+ if(ret<0)
+   return(ret);
+ if(deleted)
+   return(2);
+ if(result&(1<<17))
+   return(3);
+ return(ret);
+}
+
+
+/* @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 flag      bit0= widen hardlink sibling:
+                          Do not call Xorriso_hardlink_update()
+                          Overwrite exactly if normal mode would not,
+                          else do nothing
+                    bit2= -follow: this is not a command parameter 
+   @return <=0 error, 1= ok , 2= iso_rr_path node object has been deleted ,
+                      3= no action taken
+*/
+int Xorriso_update_interpreter(struct XorrisO *xorriso, void *boss_iter,
+                               int compare_result, char *disk_path,
+                               char *iso_rr_path, int flag)
+{
+ int ret, deleted= 0, is_split= 0, i, loop_count, late_hardlink_update= 0;
+ char sfe[5*SfileadrL];
+ struct stat stbuf;
+ struct SplitparT *split_parts= NULL;
+ int split_count= 0;
+ char part_path[SfileadrL], *part_name;
+ int partno, total_parts, new_total_parts;
+ off_t offset, bytes, total_bytes, disk_size, first_bytes;
+
+ if((compare_result&3)==3) {
+   sprintf(xorriso->info_text, "Missing on disk and in ISO: disk_path %s",
+           Text_shellsafe(disk_path, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 1);
+   xorriso->find_compare_result= -1;
+   ret= 3; goto ex;
+ }
+
+ if(compare_result&((1<<11)|(1<<13))) {
+   if(flag & 1)
+     {ret= 3; goto ex;}
+   /* cannot open regular disk file, early eof of disk file */
+   sprintf(xorriso->info_text, "Problems with reading disk file %s",
+           Text_shellsafe(disk_path, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 1);
+   xorriso->find_compare_result= -1;
+   ret= 1; goto ex;
+ }
+ xorriso->info_text[0]= 0;
+ is_split= !!(compare_result & (1<<17));
+
+ if((!(xorriso->ino_behavior & 2)) && (compare_result & (2 | (3 << 21))) &&
+    !(flag & 1)) {
+   if(compare_result & 2) {
+     /* File is not yet in image */
+     late_hardlink_update= 1;
+   } else {
+     /* Hard link relation has changed resp. was not recorded. */
+     ret= Xorriso_hardlink_update(xorriso, &compare_result,
+                                  disk_path, iso_rr_path, flag & 4);
+     if(ret < 0)
+       goto ex;
+     if(ret == 2)
+       {ret= 1; goto ex;}
+   }
+ }
+
+ if(compare_result&(8|64)) {
+   /* file type, minor+major with device file */
+   if(flag & 1)
+     {ret= 3; goto ex;}
+   ret= Xorriso_rmi(xorriso, boss_iter, (off_t) 0, iso_rr_path, 1); /* rm_r */
+   if(ret>0) {
+     deleted= 1; 
+     ret= Xorriso_graft_in(xorriso, boss_iter, disk_path, iso_rr_path,
+                           (off_t) 0, (off_t) 0, 2|(flag&4));
+   }
+   sprintf(xorriso->info_text, "Deleted and re-added ");
+
+ } else if(compare_result&(1)) {
+delete:;
+   /* disk_adr not existing */
+   ret= Xorriso_rmi(xorriso, boss_iter, (off_t) 0, iso_rr_path, 1);
+   deleted= 1;
+   sprintf(xorriso->info_text, "Deleted ");
+
+ } else if(compare_result&(2|128|(1<<12)|(1<<14)|(1<<15))) {
+   /* iso_adr not existing, size, cannot open iso file, early eof of iso file
+      content bytes differ */
+
+   if(flag & 1)
+     {ret= 3; goto ex;}
+overwrite:;
+   if(is_split) {
+     ret= Xorriso_identify_split(xorriso, iso_rr_path, NULL,
+                                 &split_parts, &split_count, &stbuf, 0);
+     if(ret<=0)
+       {ret= -1; goto ex;}  /* (should not happen) */
+     ret= lstat(disk_path, &stbuf);
+     if(ret==-1)
+       goto delete;
+     disk_size= stbuf.st_size;
+     Splitparts_get(split_parts, 0, &part_name, &partno, &total_parts,
+                    &offset, &first_bytes, &total_bytes, 0);
+     new_total_parts= disk_size/first_bytes;
+     if(disk_size % first_bytes)
+       new_total_parts++;
+
+     loop_count= split_count;
+     /* If disk file grew over part limit and all parts are present:
+        add new parts */
+     if(new_total_parts > total_parts && split_count == total_parts)
+       loop_count= new_total_parts;
+
+     for(i= 0; i<loop_count; i++) {
+       if(i<split_count) {
+         /* Delete old part */
+         Splitparts_get(split_parts, i, &part_name, &partno, &total_parts,
+                       &offset, &bytes, &total_bytes, 0);
+         strcpy(part_path, iso_rr_path);
+         if(Sfile_add_to_path(part_path, part_name, 0)<=0) {
+           Xorriso_much_too_long(xorriso,
+                                 strlen(iso_rr_path)+strlen(part_path)+1, 2);
+           {ret= -1; goto ex;}
+         }
+         ret= Xorriso_rmi(xorriso, NULL, (off_t) 0, part_path, 1);
+         if(ret<=0)
+           goto ex;
+         deleted= 1;
+       } else {
+         partno= i+1;
+         offset= i*first_bytes;
+         bytes= first_bytes;
+       }
+       if(disk_size<=offset)
+     continue;
+       /* Insert new part */
+       if(strlen(part_path)+160>SfileadrL) {
+         Xorriso_much_too_long(xorriso, strlen(part_path)+160, 2);
+         ret= 0; goto ex;
+       }
+       Splitpart__compose(part_path+strlen(iso_rr_path)+1, partno,
+                          new_total_parts, offset, first_bytes, disk_size, 0);
+       ret= Xorriso_graft_in(xorriso, boss_iter, disk_path, part_path,
+                             offset, bytes, 2|(flag&4)|8|128);
+       if(ret<=0)
+         goto ex;
+     }
+     /* Copy file attributes to iso_rr_path, augment r-perms by x-perms */
+     ret= Xorriso_copy_properties(xorriso, disk_path, iso_rr_path, 2 | 4);
+     if(ret<=0)
+       goto ex;
+   } else {
+     ret= Xorriso_graft_in(xorriso, boss_iter, disk_path, iso_rr_path,
+                           (off_t) 0, (off_t) 0, 2|(flag&4));
+     if(ret>0 && !(compare_result&2))
+       deleted= 1;
+   }
+   if(late_hardlink_update) {
+     /* Handle eventual hardlink siblings of newly created file */
+     ret= Xorriso_hardlink_update(xorriso, &compare_result,
+                                  disk_path, iso_rr_path, 1 | (flag & 4));
+     if(ret < 0)
+       goto ex;
+   }
+   if(flag & 1)
+     sprintf(xorriso->info_text, "Widened hard link ");
+   else
+     sprintf(xorriso->info_text, "Added/overwrote ");
+
+ } else if(compare_result&(4|16|32|256|512|1024|(1<<19)|(1<<20)|(1<<22))) {
+   /* access permissions, user id, group id, mtime, atime, ctime, ACL, xattr,
+      dev_ino missing */
+
+   if(flag & 1)
+     goto overwrite;
+
+   if(is_split) {
+     ret= Xorriso_identify_split(xorriso, iso_rr_path, NULL,
+                                 &split_parts, &split_count, &stbuf, 0);
+     if(ret<=0)
+       {ret= -1; goto ex;}  /* (should not happen) */
+     for(i= 0; i<split_count; i++) {
+       Splitparts_get(split_parts, i, &part_name, &partno, &total_parts,
+                     &offset, &bytes, &total_bytes, 0);
+       strcpy(part_path, iso_rr_path);
+       if(Sfile_add_to_path(part_path, part_name, 0)<=0) {
+         Xorriso_much_too_long(xorriso,
+                               strlen(iso_rr_path)+strlen(part_path)+1, 2);
+         {ret= -1; goto ex;}
+       }
+       ret= Xorriso_copy_properties(xorriso, disk_path, part_path,
+                                    4 * !(compare_result & (1<<21))); 
+                             /* do not update eventually mismatching dev_ino */
+       if(ret<=0)
+         goto ex;
+     }
+     /* Copy file attributes to iso_rr_path, augment r-perms by x-perms */
+     ret= Xorriso_copy_properties(xorriso, disk_path, iso_rr_path, 2 | 4); 
+     if(ret<=0)
+       goto ex;
+   } else
+     ret= Xorriso_copy_properties(xorriso, disk_path, iso_rr_path, 4); 
+   sprintf(xorriso->info_text, "Adjusted attributes of ");
+
+ } else if(flag & 1) {
+     goto overwrite;
+ } else
+   ret= 1;
+ if(ret>0 && xorriso->info_text[0]) {
+   strcat(xorriso->info_text, Text_shellsafe(iso_rr_path, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0);
+ }
+ ret= 1;
+ex:;
+ if(split_parts!=NULL)
+   Splitparts_destroy(&split_parts, split_count, 0);
+ if(ret<=0)
+   return(ret);
+ if(deleted)
+   return(2);
+ return(ret);
+}
+

xorriso/cmp_update.h

@@ -0,0 +1,40 @@
+
+/* 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 flag bit0= update rather than compare
+*/
+int Xorriso_find_compare(struct XorrisO *xorriso, void *boss_iter,
+                         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
+*/
+int Xorriso_update_interpreter(struct XorrisO *xorriso, void *boss_iter,
+                               int compare_result, char *disk_path,
+                               char *iso_rr_path, int flag);
+
+#endif /* ! Xorriso_pvt_cmp_includeD */
+

xorriso/compile_xorriso.sh

@@ -117,9 +117,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 \
@@ -148,11 +177,6 @@ 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 \

xorriso/configure_ac.txt

@@ -3,9 +3,8 @@
 # Copyright (c) 2007 - 2010 Thomas Schmitt <scdbackup@gmx.net>
 # Provided under GPL version 2 or later.
 
-AC_INIT([xorriso], [0.5.6], [http://libburnia-project.org])
+AC_INIT([xorriso], [0.6.2], [http://libburnia-project.org])
 AC_PREREQ([2.50])
-dnl AC_CONFIG_HEADER([config.h])	
 
 AC_CANONICAL_HOST
 AC_CANONICAL_TARGET
@@ -14,16 +13,23 @@ LIBBURNIA_SET_FLAGS
 
 AM_INIT_AUTOMAKE([subdir-objects])
 
+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=0
 BURN_MINOR_VERSION=8
-BURN_MICRO_VERSION=1
+BURN_MICRO_VERSION=7
 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=33
+LIBISOFS_MICRO_VERSION=37
 AC_SUBST(LIBISOFS_MAJOR_VERSION)
 AC_SUBST(LIBISOFS_MINOR_VERSION)
 AC_SUBST(LIBISOFS_MICRO_VERSION)
@@ -50,6 +56,7 @@ 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
 
@@ -103,13 +110,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
@@ -138,6 +148,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)
@@ -162,9 +173,12 @@ dnl The X= in the yes case prevents that -lreadline gets linked twice
 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=yes)
@@ -177,9 +191,13 @@ dnl The empty yes case obviously causes -lacl to be linked
 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])
 AC_ARG_ENABLE(xattr,
 [  --enable-xattr          Enable use of xattr by libisofs, default=yes],
                , enable_xattr=yes)
@@ -191,9 +209,13 @@ dnl If not, erase this macro which would enable use of listxattr and others
 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
 
 
+AH_TEMPLATE([Libisofs_with_zliB], [Define to use compression via libz])
 AC_ARG_ENABLE(zlib,
 [  --enable-zlib           Enable use of zlib by libisofs, default=yes],
                , enable_zlib=yes)
@@ -208,9 +230,13 @@ dnl The empty parameter after "compressBound" causes -lz.
 else
     ZLIB_DEF=
 fi
-AC_SUBST(ZLIB_DEF)
+if test x$ZLIB_DEF = x-DLibisofs_with_zliB
+then
+    AC_DEFINE([Libisofs_with_zliB], [])
+fi
 
 
+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)
@@ -232,12 +258,21 @@ then
 else
     echo "enabled  EXPERIMENTAL use of libcdio as system adapter"
 
+# ------- Visible mark in configure : Start of library check
+
     LIBCDIO_REQUIRED=0.83
     PKG_CHECK_MODULES(LIBCDIO, libcdio >= $LIBCDIO_REQUIRED)
+
+# ------- Visible mark in configure : End of library check
+
+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)
@@ -248,8 +283,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)
@@ -260,8 +300,13 @@ 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_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)
@@ -272,8 +317,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)
@@ -284,12 +334,16 @@ 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
+
 
 AC_CONFIG_FILES([
 	Makefile
 	version.h
 	])
 AC_OUTPUT
-
 #	xorriso.pc
+

xorriso/disk_ops.h

@@ -0,0 +1,116 @@
+
+/* 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 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 */
+

xorriso/drive_mgt.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 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);
+
+#endif /* ! Xorriso_pvt_drive_mgt_includeD */
+

xorriso/emulators.h

@@ -0,0 +1,34 @@
+
+/* 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_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 */
+

xorriso/filters.c

@@ -0,0 +1,698 @@
+
+/* 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 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->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 *) *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[SfileadrL], *suffix= "";
+ IsoStream *stream;
+ int is_renamed= 0;
+
+ 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;
+   is_renamed= 1;
+ }
+
+ 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 == 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);
+     return(0);
+   }
+#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_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(strlen(line) > maxl)
+ continue;
+   strcat(line, " ");
+   if(extf->cmd->suffix[0]) {
+     strcat(line, "suffix=");
+     Text_shellsafe(extf->cmd->suffix, line, 1);
+     if(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(strlen(line) > maxl)
+ continue;
+   Text_shellsafe(extf->cmd->path, line, 1);
+   if(strlen(line) > maxl)
+ continue;
+   for(i= 1; i < extf->cmd->argc; i++) {
+     strcat(line, " ");
+     Text_shellsafe(extf->cmd->argv[i], line, 1);
+     if(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);
+}
+

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 */
+

xorriso/findjob.h

@@ -0,0 +1,405 @@
+
+/* 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 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)
+ */
+ 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
+ */
+ 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;
+ 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
+           */
+};
+
+
+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_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 */
+

xorriso/iso_img.c

@@ -0,0 +1,961 @@
+
+/* 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 functions which operate on ISO images and their
+   global properties.
+*/
+
+#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 <sys/wait.h>
+
+#include "xorriso.h"
+#include "xorriso_private.h"
+#include "xorrisoburn.h"
+
+#include "lib_mgt.h"
+#include "iso_img.h"
+#include "iso_tree.h"
+#include "drive_mgt.h"
+
+
+int Xorriso_set_ignore_aclea(struct XorrisO *xorriso, int flag)
+{
+ int ret, hflag;
+ IsoImage *volume;
+
+ ret= Xorriso_get_volume(xorriso, &volume, 1); 
+ if(ret<=0)
+   return(ret);
+ hflag= (~xorriso->do_aaip) & 1;
+ if((xorriso->ino_behavior & (1 | 2)) && !(xorriso->do_aaip & (4 | 16)))
+   hflag|= 2; 
+ iso_image_set_ignore_aclea(volume, hflag);
+ return(1);
+}
+
+
+int Xorriso_update_volid(struct XorrisO *xorriso, int flag)
+{
+ int gret, sret= 1;
+
+ gret= Xorriso_get_volid(xorriso, xorriso->loaded_volid, 0);
+ if(gret<=0 || (!xorriso->volid_default) || xorriso->loaded_volid[0]==0)
+   sret= Xorriso_set_volid(xorriso, xorriso->volid, 1);
+ return(gret>0 && sret>0);
+} 
+ 
+
+int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ IsoImage *volset;
+ struct isoburn_read_opts *ropts;
+ struct burn_drive_info *dinfo= NULL;
+ struct burn_drive *drive= NULL;
+
+ if(xorriso->out_drive_handle != NULL) {
+   ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                  "on attempt to attach volset to drive", 2);
+   if(ret<=0)
+     return(ret);
+ }
+ if(xorriso->in_volset_handle!=NULL) {
+   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->loaded_volid[0]= 0;
+   xorriso->volset_change_pending= 0;
+   xorriso->boot_count= 0;
+   xorriso->no_volset_present= 0;
+ }
+
+ ret= isoburn_ropt_new(&ropts, 0);
+ if(ret<=0)
+   return(ret);
+ /* Note: no return before isoburn_ropt_destroy() */
+ isoburn_ropt_set_extensions(ropts, isoburn_ropt_pretend_blank);
+ isoburn_ropt_set_input_charset(ropts, xorriso->in_charset);
+ isoburn_set_read_pacifier(drive, NULL, NULL);
+ ret= isoburn_read_image(drive, ropts, &volset);
+ Xorriso_process_msg_queues(xorriso,0);
+ isoburn_ropt_destroy(&ropts, 0);
+ if(ret<=0) {
+   sprintf(xorriso->info_text, "Failed to create new empty ISO image object");
+   Xorriso_report_iso_error(xorriso, "", ret, xorriso->info_text, 0, "FATAL",
+                            0);
+   return(-1);
+ }
+ xorriso->in_volset_handle= (void *) volset;
+ xorriso->in_sector_map= NULL;
+ Xorriso_update_volid(xorriso, 0);
+ xorriso->volset_change_pending= 0;
+ xorriso->boot_count= 0;
+ xorriso->no_volset_present= 0;
+ return(1);
+}
+
+
+int Xorriso_record_boot_info(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ IsoImage *image;
+ ElToritoBootImage *bootimg;
+ IsoFile *bootimg_node;
+ IsoBoot *bootcat_node;
+
+ xorriso->loaded_boot_bin_lba= -1;
+ xorriso->loaded_boot_cat_path[0]= 0;
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                "on attempt to record boot LBAs", 0);
+ if(ret<=0)
+   return(0);
+ image= isoburn_get_attached_image(drive);
+ if(image == NULL)
+   return(0);
+ ret= iso_image_get_boot_image(image, &bootimg,
+                               &bootimg_node, &bootcat_node);
+ iso_image_unref(image); /* release obtained reference */
+ if(ret != 1)
+   return(0);
+ if(bootimg_node != NULL)
+   Xorriso__file_start_lba((IsoNode *) bootimg_node,
+                           &(xorriso->loaded_boot_bin_lba), 0);
+ if(bootcat_node != NULL)
+   Xorriso_path_from_lba(xorriso, (IsoNode *) bootcat_node, 0,
+                         xorriso->loaded_boot_cat_path, 0);
+ return(1);
+}
+
+
+int Xorriso_assert_volid(struct XorrisO *xorriso, int msc1, int flag)
+{
+ int ret, image_blocks;
+ char volid[33];
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+
+ if(xorriso->assert_volid[0] == 0)
+   return(1);
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                "on attempt to perform -assert_volid", 0);
+ if(ret<=0)
+   return(0);
+ ret= isoburn_read_iso_head(drive, msc1, &image_blocks, volid, 1);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret <= 0) {
+   sprintf(xorriso->info_text,
+           "-assert_volid: Cannot determine Volume Id at LBA %d.", msc1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
+                       xorriso->assert_volid_sev, 0);
+   return(0);
+ }
+ ret= Sregex_match(xorriso->assert_volid, volid, 0);
+ if(ret < 0)
+   return(2);
+ if(ret == 0) {
+   strcpy(xorriso->info_text,
+          "-assert_volid: Volume id does not match pattern: ");
+   Text_shellsafe(xorriso->assert_volid, xorriso->info_text, 1);
+   strcat(xorriso->info_text, " <> ");
+   Text_shellsafe(volid, xorriso->info_text, 1);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
+                       xorriso->assert_volid_sev, 0);
+   return(0);
+ }
+ return(ret);
+}
+
+
+/* @return <0 yes , 0 no , <0 error */
+int Xorriso_is_isohybrid(struct XorrisO *xorriso, IsoFile *bootimg_node,
+                         int flag)
+{
+ int ret;
+ unsigned char buf[68];
+ void *data_stream= NULL;
+
+ ret= Xorriso_iso_file_open(xorriso, "", (void *) bootimg_node,
+                            &data_stream, 1);
+ if(ret <= 0)
+   return(-1);
+ ret= Xorriso_iso_file_read(xorriso, data_stream, (char *) buf, 68, 0);
+ Xorriso_iso_file_close(xorriso, &data_stream, 0);
+ if(ret <= 0)
+   return(0);
+ if(buf[64] == 0xfb && buf[65] == 0xc0 && buf[66] == 0x78 && buf[67] == 0x70)
+   return(1);
+ return(0);
+}
+
+
+int Xorriso_image_has_md5(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ IsoImage *image;
+ uint32_t start_lba, end_lba;
+ char md5[16];
+
+ ret= Xorriso_get_volume(xorriso, &image, 0);
+ if(ret<=0)
+   return(ret);
+ ret= iso_image_get_session_md5(image, &start_lba, &end_lba, md5, 0);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret <= 0)
+   return(0);
+ return(1);
+}
+
+
+static const char *un0(const char *text)
+{
+ if(text == NULL)
+   return("");
+ return(text);
+}
+
+
+int Xorriso_pvd_info(struct XorrisO *xorriso, int flag)
+{
+ int ret, msc1= -1, msc2, i;
+ IsoImage *image;
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ char *msg, block_head[8];
+ off_t head_count;
+
+ msg= xorriso->result_line;
+ ret= Xorriso_get_volume(xorriso, &image, 0);
+ if(ret<=0)
+   return(ret);
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive, "", 16);
+ if(ret > 0) {
+   ret= Xorriso_msinfo(xorriso, &msc1, &msc2, 1 | 4);
+   if(ret<0)
+     return(ret);
+   Xorriso_toc(xorriso, 128);
+   if(msc1 >= 0) {
+     for(i = msc1 + 16; i < msc1 + 32; i++) {
+       ret= burn_read_data(drive, (off_t) i * (off_t) 2048, block_head,
+                           (off_t) sizeof(block_head), &head_count, 2);
+       if(ret <= 0) {
+         i= msc1 + 32;
+     break;
+       }
+       if(block_head[0] == 1 && strncmp(block_head + 1, "CD001", 5) == 0)
+     break;
+     }
+     if(i < msc1 + 32) {
+       sprintf(msg, "PVD address  : %ds\n", i);
+       Xorriso_result(xorriso,0);
+     }
+   }
+ }
+ sprintf(msg, "Volume Id    : %s\n", un0(iso_image_get_volume_id(image)));
+ Xorriso_result(xorriso,0);
+ sprintf(msg, "Volume Set Id: %s\n", xorriso->volset_id);
+ Xorriso_result(xorriso,0);
+ sprintf(msg, "Publisher Id : %s\n", xorriso->publisher);
+ Xorriso_result(xorriso,0);
+ sprintf(msg, "Preparer Id  : %s\n",
+         un0(iso_image_get_data_preparer_id(image)));
+ Xorriso_result(xorriso,0);
+ sprintf(msg, "App Id       : %s\n", xorriso->application_id);
+ Xorriso_result(xorriso,0);
+ sprintf(msg, "System Id    : %s\n", xorriso->system_id);
+ Xorriso_result(xorriso,0);
+ sprintf(msg, "CopyrightFile: %s\n", xorriso->copyright_file);
+ Xorriso_result(xorriso,0);
+ sprintf(msg, "Abstract File: %s\n", xorriso->abstract_file);
+ Xorriso_result(xorriso,0);
+ sprintf(msg, "Biblio File  : %s\n", xorriso->biblio_file);
+ Xorriso_result(xorriso,0);
+ return(1);
+}
+
+
+/* @param flag bit0= do not mark image as changed */
+int Xorriso_set_volid(struct XorrisO *xorriso, char *volid, int flag)
+{
+ int ret;
+ IsoImage *volume;
+
+ if(xorriso->in_volset_handle == NULL)
+   return(2);
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+ iso_image_set_volume_id(volume, volid);
+ if(!(flag&1))
+   Xorriso_set_change_pending(xorriso, 1);
+ Xorriso_process_msg_queues(xorriso,0);
+ sprintf(xorriso->info_text,"Volume ID: '%s'",iso_image_get_volume_id(volume));
+ Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
+ return(1);
+}
+
+
+int Xorriso_get_volid(struct XorrisO *xorriso, char volid[33], int flag)
+{
+ int ret;
+ IsoImage *volume;
+
+ ret= Xorriso_get_volume(xorriso, &volume, 0);
+ if(ret<=0)
+   return(ret);
+ strncpy(volid, iso_image_get_volume_id(volume), 32);
+ volid[32]= 0;
+ return(1);
+}
+
+
+/* 
+ bit0= do only report non-default settings
+ bit1= do only report to fp
+ bit2= is_default
+ bit3= append -boot_image any next
+ bit4= eventually concentrate boot options
+*/
+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 is_default, no_defaults, i, is_default_id= 0, ret;
+ char *line, bspec[SfileadrL + 80], zeros[28];
+ off_t file_size;
+ struct stat stbuf;
+
+ no_defaults= flag & 1;
+ line= xorriso->result_line;
+
+ if(flag & 16) {
+   /* Allow to concentrate boot options. */
+   memset(zeros, 0, 28);
+   if(memcmp(id_string, zeros, 28) == 0 &&
+      memcmp(selection_crit, zeros, 20) == 0)
+     is_default_id= 1;
+
+   /* -boot_image isolinux dir= ... */
+   bspec[0]= 0;
+   if(strcmp(form, "isolinux") != 0 && strcmp(form, "any") != 0)
+     ;
+   else if(strcmp(bin_path, "/isolinux.bin") == 0 &&
+      strcmp(cat_path, "/boot.cat") == 0)
+     strcpy(bspec, "dir=/");
+   else if(strcmp(bin_path, "/isolinux/isolinux.bin") == 0 &&
+           strcmp(cat_path, "/isolinux/boot.cat") == 0)
+     strcpy(bspec, "dir=/isolinux");
+   else if(strcmp(xorriso->boot_image_bin_path,
+                  "/boot/isolinux/isolinux.bin") == 0
+           && strcmp(xorriso->boot_image_cat_path,
+                     "/boot/isolinux/boot.cat") == 0)
+     strcpy(bspec, "dir=/boot/isolinux");
+   memset(zeros, 0, 28);
+   if(bspec[0] && platform_id == 0 && patch_isolinux &&
+      load_size == 2048 && is_default_id) {
+     sprintf(line, "-boot_image isolinux %s\n", bspec);
+     Xorriso_status_result(xorriso,filter,fp,flag&2); 
+     return(1);
+   }
+
+   file_size= 0;
+   ret= Xorriso_iso_lstat(xorriso, bin_path, &stbuf, 2 | 4);
+   if(ret == 0)
+     file_size= ((stbuf.st_size / (off_t) 512) +
+                !!(stbuf.st_size % (off_t) 512)) * 512;
+   if(platform_id == 0xef && !patch_isolinux &&
+      load_size == file_size && is_default_id) {
+     sprintf(line, "-boot_image any efi_path=");
+     Text_shellsafe(bin_path, line, 1);
+     strcat(line, "\n");
+     Xorriso_status_result(xorriso,filter,fp,flag&2);
+     return(1);
+   }
+ }
+
+ is_default= (bin_path[0] == 0) || (flag & 4);
+ sprintf(line, "-boot_image %s bin_path=", form);
+ Text_shellsafe(bin_path, line, 1);
+ strcat(line, "\n");
+ if(!(is_default && no_defaults))
+   Xorriso_status_result(xorriso,filter,fp,flag&2);
+ 
+ is_default= (platform_id == 0 || (flag & 4));
+ sprintf(line, "-boot_image %s platform_id=0x%-2.2x\n", form, platform_id);
+ if(!(is_default && no_defaults))
+   Xorriso_status_result(xorriso,filter,fp,flag&2); 
+
+ is_default= ((patch_isolinux & 1) == 0 || bin_path[0] == 0 || (flag & 4));
+ sprintf(line, "-boot_image %s boot_info_table=%s\n",
+         (patch_isolinux & 2) ? "grub" : form, patch_isolinux ? "on" : "off");
+ if(!(is_default && no_defaults))
+   Xorriso_status_result(xorriso,filter,fp,flag&2); 
+ 
+ is_default= (load_size == 2048 || (flag & 4));
+ sprintf(line, "-boot_image %s load_size=%lu\n",
+         form, (unsigned long) load_size);
+ if(!(is_default && no_defaults))
+   Xorriso_status_result(xorriso,filter,fp,flag&2); 
+
+ is_default= 1;
+ if(!(flag & 4))
+   for(i= 0; i < 20; i++)
+     if(selection_crit[i])
+       is_default= 0;
+ sprintf(line, "-boot_image %s sel_crit=", form);
+ for(i= 0; i < 20; i++)
+   sprintf(line + strlen(line), "%-2.2X", (unsigned int) selection_crit[i]);
+ strcat(line, "\n");
+ if(!(is_default && no_defaults))
+   Xorriso_status_result(xorriso,filter,fp,flag&2); 
+
+ is_default= 1;
+ if(!(flag & 4))
+   for(i= 0; i < 28; i++)
+     if(id_string[i])
+       is_default= 0;
+ sprintf(line, "-boot_image %s id_string=", form);
+ for(i= 0; i < 28; i++)
+   sprintf(line + strlen(line), "%-2.2X", (unsigned int) id_string[i]);
+ strcat(line, "\n");
+ if(!(is_default && no_defaults))
+   Xorriso_status_result(xorriso,filter,fp,flag&2); 
+ 
+ return(1); 
+}
+
+
+/* 
+ bit0= do only report non-default settings
+ bit1= do only report to fp
+*/
+int Xorriso_boot_image_status(struct XorrisO *xorriso, char *filter, FILE *fp,
+                              int flag)
+{
+ int ret, i, num_boots, hflag;
+ int bin_path_in_use= 0, is_default, no_defaults;
+ char sfe[5*SfileadrL], path[SfileadrL], *form= "any", *line, *hpt;
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ IsoImage *image= NULL;
+ ElToritoBootImage **boots = NULL;
+ IsoFile **bootnodes = NULL;
+ int platform_id, patch, load_size;
+ enum eltorito_boot_media_type media_type;
+ unsigned char id_string[29], sel_crit[21];
+
+ line= xorriso->result_line;
+ no_defaults= flag & 1;
+
+ if(xorriso->boot_count == 0 && xorriso->boot_image_bin_path[0] == 0) {
+   if(xorriso->patch_isolinux_image & 1) {
+     sprintf(line, "-boot_image %s patch\n",
+             xorriso->patch_isolinux_image & 2 ? "grub" : form);
+     is_default= 0;
+   } else if(xorriso->keep_boot_image) {
+     sprintf(line, "-boot_image %s keep\n", form);
+     is_default= 0;
+   } else {
+     sprintf(line, "-boot_image %s discard\n", form);
+     is_default= 1;
+   }
+   if(!(is_default && no_defaults))
+      Xorriso_status_result(xorriso,filter,fp,flag&2); 
+   ret= 1; goto ex;
+ }
+
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                "on attempt to print boot info", 16);
+ if(ret<=0)
+   {ret= 0; goto ex;}
+ image= isoburn_get_attached_image(drive);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(image == NULL) 
+   {ret= 0; goto ex;}
+
+ if(xorriso->boot_image_bin_path[0] || xorriso->boot_count > 0)
+   bin_path_in_use= 1;
+ if(xorriso->boot_image_cat_path[0] && bin_path_in_use) {
+   is_default= 0;
+   sprintf(line,"-boot_image %s cat_path=%s\n",
+           form, Text_shellsafe(xorriso->boot_image_cat_path, sfe, 0));
+   if(!(is_default && no_defaults))
+     Xorriso_status_result(xorriso,filter,fp,flag&2);
+ }
+ if(bin_path_in_use) {
+   is_default= !xorriso->boot_image_cat_hidden;
+   hpt= Xorriso__hide_mode_text(xorriso->boot_image_cat_hidden & 3, 0);
+   sprintf(line, "-boot_image %s cat_hidden=%s\n", form, hpt);
+   if(!(is_default && no_defaults))
+     Xorriso_status_result(xorriso,filter,fp,flag&2);
+ }
+
+ if(xorriso->boot_count > 0) {
+
+   /* show attached boot image info */;
+
+   ret= iso_image_get_all_boot_imgs(image, &num_boots, &boots, &bootnodes, 0);
+   Xorriso_process_msg_queues(xorriso,0);
+   if(ret == 1 && num_boots > 0) {
+     for(i= 0; i < num_boots; i++) {
+       ret= Xorriso_path_from_node(xorriso, (IsoNode *) bootnodes[i], path, 0);
+       if(ret <= 0)
+    continue;
+       platform_id= el_torito_get_boot_platform_id(boots[i]);
+       patch= el_torito_get_isolinux_options(boots[i], 0);
+       el_torito_get_boot_media_type(boots[i], &media_type);
+       load_size= el_torito_get_load_size(boots[i]) * 512;
+       el_torito_get_id_string(boots[i], id_string);
+       el_torito_get_selection_crit(boots[i], sel_crit);
+       ret= Xorriso_boot_item_status(xorriso, xorriso->boot_image_cat_path,
+                  path, platform_id, patch & 1, media_type,
+                  load_size, id_string, sel_crit, "any",
+                  filter, fp, 16 | (flag & 3));
+       if(ret <= 0)
+     continue;
+       sprintf(line,"-boot_image %s next\n", form);
+       Xorriso_status_result(xorriso,filter,fp,flag&2);
+     }
+   }
+ } 
+
+ /* Show pending boot image info */
+ if(strcmp(xorriso->boot_image_bin_form, "isolinux") == 0 ||
+    strcmp(xorriso->boot_image_bin_form, "grub") == 0)
+   form= xorriso->boot_image_bin_form;
+
+ if(xorriso->boot_count > 0 &&
+    xorriso->boot_platform_id == 0 &&
+    xorriso->patch_isolinux_image == 0 &&
+    xorriso->boot_image_bin_path[0] == 0 &&
+    xorriso->boot_image_emul == 0 &&
+    xorriso->boot_image_load_size == 4 * 512) {
+   for(i= 0; i < 20; i++)
+     if(xorriso->boot_selection_crit[i])
+   break;
+   if(i >= 20)
+     for(i= 0; i < 28; i++)
+       if(xorriso->boot_id_string[i])
+     break;
+   if(i >= 28)
+     {ret= 1; goto ex;} /* Images registered, pending is still default */
+ }
+  
+ hflag= 16; 
+ if(xorriso->boot_platform_id == 0xef && !xorriso->boot_efi_default)
+   hflag= 0;
+ ret= Xorriso_boot_item_status(xorriso, xorriso->boot_image_cat_path,
+             xorriso->boot_image_bin_path, xorriso->boot_platform_id,
+             xorriso->patch_isolinux_image, xorriso->boot_image_emul,
+             xorriso->boot_image_load_size, xorriso->boot_id_string,
+             xorriso->boot_selection_crit, form,
+             filter, fp, hflag | (flag & 3));
+ if(ret <= 0)
+   goto ex;
+
+ ret= 1;
+ex:
+ if(boots != NULL)
+   free(boots);
+ if(bootnodes != NULL)
+   free(bootnodes);
+ return(ret);
+}
+
+
+int Xorriso__append_boot_params(char *line, ElToritoBootImage *bootimg,
+                                int flag)
+{
+ unsigned int platform_id;
+
+ platform_id= el_torito_get_boot_platform_id(bootimg); 
+ if(platform_id != 0)
+   sprintf(line + strlen(line),
+           " , platform_id=0x%-2.2X ", (unsigned int) platform_id);
+ if(el_torito_seems_boot_info_table(bootimg, 0))
+   sprintf(line + strlen(line), " , boot_info_table=on");
+ return(1);
+}
+
+
+/* @param flag bit0= no output if no boot record was found
+               bit1= short form
+               bit3= report to info channel (else to result channel)
+*/
+int Xorriso_show_boot_info(struct XorrisO *xorriso, int flag)
+{
+ int ret, bin_path_valid= 0,has_isolinux_mbr= 0, i, num_boots;
+ unsigned int mbr_lba= 0;
+ off_t lb0_count;
+ char *respt, sfe[5*SfileadrL], path[SfileadrL];
+ unsigned char lb0[2048];
+ struct burn_drive_info *dinfo;
+ struct burn_drive *drive;
+ IsoImage *image= NULL;
+ ElToritoBootImage *bootimg, **boots = NULL;
+ IsoFile *bootimg_node, **bootnodes = NULL;
+ IsoBoot *bootcat_node;
+
+ respt= xorriso->result_line;
+
+ if(xorriso->boot_count > 0) {
+   if(!(flag & 1)) {
+     sprintf(respt, "Boot record  : overridden by -boot_image any next\n");
+     Xorriso_toc_line(xorriso, flag & 8);
+   }
+   ret= 1; goto ex;
+ }
+
+ ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                "on attempt to print boot info", 16);
+ if(ret<=0)
+   goto no_boot;
+ image= isoburn_get_attached_image(drive);
+ if(image == NULL) {
+   ret= 0;
+no_boot:;
+   if(!(flag & 1)) {
+     sprintf(respt, "Boot record  : none\n");
+     Xorriso_toc_line(xorriso, flag & 8);
+   }
+   goto ex;
+ }
+
+ /* Using the nodes with extreme care . They might be deleted meanwhile. */
+ ret= iso_image_get_boot_image(image, &bootimg, &bootimg_node, &bootcat_node);
+ if(ret != 1)
+   goto no_boot;
+
+ ret= Xorriso_path_from_lba(xorriso, NULL, xorriso->loaded_boot_bin_lba,
+                             path, 1);
+ if(ret > 0)
+   bin_path_valid= 1;
+ sprintf(respt, "Boot record  : El Torito");
+ if(bin_path_valid)
+   ret= Xorriso_is_isohybrid(xorriso, bootimg_node, 0);
+ else
+   ret= 0;
+ if(ret > 0) {
+   /* Load and examine potential MBR */
+   ret= burn_read_data(drive, (off_t) 0, (char *) lb0, (off_t) 2048,
+                       &lb0_count, 2);
+   if(ret > 0) {
+     has_isolinux_mbr= 1;
+     if(lb0[510] != 0x55 || lb0[511] != 0xaa)
+       has_isolinux_mbr= 0;
+     mbr_lba= lb0[432] | (lb0[433] << 8) | (lb0[434] << 16) | (lb0[435] << 24);
+     mbr_lba/= 4;
+     if(mbr_lba != xorriso->loaded_boot_bin_lba)
+       has_isolinux_mbr= 0;
+     if(has_isolinux_mbr) {
+       for(i= 0; i < 426; i++)
+         if(strncmp((char *) (lb0 + i), "isolinux", 8) == 0)
+       break;
+       if(i >= 426)
+         has_isolinux_mbr= 0;
+     }
+     for(i= 462; i < 510; i++)
+       if(lb0[i])
+     break;
+     if(i < 510)
+       has_isolinux_mbr= 0;
+   }
+   if(has_isolinux_mbr)
+     strcat(respt, " , ISOLINUX isohybrid MBR pointing to boot image");
+   else
+     strcat(respt, " , ISOLINUX boot image capable of isohybrid");
+ }
+ strcat(respt, "\n");
+ Xorriso_toc_line(xorriso, flag & 8);
+ if(flag & 2)
+   {ret= 1; goto ex;}
+
+ if(xorriso->loaded_boot_cat_path[0])
+   sprintf(respt, "Boot catalog : %s\n",
+           Text_shellsafe(xorriso->loaded_boot_cat_path, sfe, 0));
+ else
+   sprintf(respt, "Boot catalog : -not-found-at-load-time-\n");
+ Xorriso_toc_line(xorriso, flag & 8);
+
+ if(bin_path_valid)
+   sprintf(respt, "Boot image   : %s", Text_shellsafe(path, sfe, 0));
+ else if(xorriso->loaded_boot_bin_lba <= 0)
+   sprintf(respt, "Boot image   : -not-found-at-load-time-");
+ else
+   sprintf(respt, "Boot image   : -not-found-any-more-by-lba=%d",
+           xorriso->loaded_boot_bin_lba);
+ Xorriso__append_boot_params(respt, bootimg, 0);
+ strcat(respt, "\n");
+ Xorriso_toc_line(xorriso, flag & 8);
+
+ ret= iso_image_get_all_boot_imgs(image, &num_boots, &boots, &bootnodes, 0);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret == 1 && num_boots > 1) {
+   for(i= 1; i < num_boots; i++) {
+     ret= Xorriso_path_from_node(xorriso, (IsoNode *) bootnodes[i], path, 0);
+     if(ret > 0)
+       sprintf(respt, "Boot image   : %s", Text_shellsafe(path, sfe, 0));
+     else
+       sprintf(respt, "Boot image   : -not-found-any-more-");
+     Xorriso__append_boot_params(respt, boots[i], 0);
+     strcat(respt, "\n");
+     Xorriso_toc_line(xorriso, flag & 8);
+   }
+ }
+ ret= 1;
+ex:;
+ if(boots != NULL)
+   free(boots);
+ if(bootnodes != NULL);
+   free(bootnodes);
+ if(image != NULL)
+   iso_image_unref(image); /* release obtained reference */
+ return(ret);
+} 
+
+
+/* @param flag    bit0=silently return 0 if no volume/image is present
+*/
+int Xorriso_get_volume(struct XorrisO *xorriso, IsoImage **volume,
+                       int flag)
+{
+ if(xorriso->in_volset_handle==NULL) {
+   if(flag & 1)
+     return(0);
+   Xorriso_process_msg_queues(xorriso,0);
+   sprintf(xorriso->info_text,"No ISO image present.");
+   if(xorriso->indev[0]==0 && xorriso->outdev[0]==0)
+     sprintf(xorriso->info_text+strlen(xorriso->info_text),
+             " No -dev, -indev, or -outdev selected.");
+   else
+     sprintf(xorriso->info_text+strlen(xorriso->info_text),
+             " Possible program error with drive '%s'.", xorriso->indev);
+
+   if(!xorriso->no_volset_present)
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+   xorriso->no_volset_present= 1;
+   return(0);
+ }
+ *volume= (IsoImage *) xorriso->in_volset_handle;
+ xorriso->no_volset_present= 0;
+ return(*volume != NULL);
+}
+
+
+int Xorriso_change_is_pending(struct XorrisO *xorriso, int flag)
+{
+ return(!!xorriso->volset_change_pending);
+}
+
+
+/* @param flag bit0= do not set hln_change_pending */
+int Xorriso_set_change_pending(struct XorrisO *xorriso, int flag)
+{
+ int ret;
+ IsoImage *image;
+
+ ret= Xorriso_get_volume(xorriso, &image, 1);
+ if(ret <= 0)
+   return ret;
+ xorriso->volset_change_pending= 1;
+ if(!(flag & 1))
+   xorriso->hln_change_pending= 1;
+ return(1);
+}
+
+
+/**
+    @param flag bit0= print mount command to result channel rather than
+                      performing it 
+                bit1= do not allow prefixes with cmd
+                bit2= interpret unprefixed cmd as shell:
+*/
+int Xorriso_mount(struct XorrisO *xorriso, char *dev, int adr_mode,
+                  char *adr_value, char *cmd, int flag)
+{
+ int ret, lba, track, session, params_flag= 0, is_safe= 0, is_extra_drive= 0;
+ int give_up= 0, mount_chardev= 0, status;
+ char volid[33], *devadr, mount_command[SfileadrL], adr_data[163], *adr_pt;
+ char *dev_path, libburn_adr[BURN_DRIVE_ADR_LEN + SfileadrL];
+ char sfe[5 * SfileadrL], *dpt, *sysname= "";
+ struct stat stbuf;
+ struct burn_drive_info *dinfo= NULL;
+ struct burn_drive *drive= NULL;
+
+ devadr= dev;
+ adr_pt= adr_value;
+ if(strcmp(dev, "indev") == 0) {
+   ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                  "on attempt to perform -mount \"indev\"", 0);
+   if(ret<=0)
+     goto ex;
+   dev_path= devadr= xorriso->indev;
+   if(strncmp(dev_path, "stdio:", 6) == 0)
+     dev_path+= 6;
+   if(xorriso->in_drive_handle == xorriso->out_drive_handle)
+     give_up= 3;
+   else
+     give_up= 1;
+ } else if(strcmp(dev, "outdev") == 0) {
+   ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
+                                  "on attempt to perform -mount \"outdev\"", 
+                                  2);
+   if(ret<=0)
+     goto ex;
+   dev_path= devadr= xorriso->outdev;
+   if(strncmp(dev_path, "stdio:", 6) == 0)
+     dev_path+= 6;
+   if(xorriso->in_drive_handle == xorriso->out_drive_handle)
+     give_up= 3;
+   else
+     give_up= 2;
+ } else {
+   is_extra_drive= 1;
+   dev_path= dev;
+   if(strncmp(dev_path, "stdio:", 6) == 0)
+     dev_path+= 6;
+
+   /* do only accept regular files and block devices */
+   ret= stat(dev_path, &stbuf);
+   if(ret == -1) {
+     sprintf(xorriso->info_text, "Cannot determine properties of file %s",
+             Text_shellsafe(dev_path, sfe, 0));
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+     ret= 0; goto ex;
+   }
+   ret= System_uname(&sysname, NULL, NULL, NULL, 0);
+   if(ret > 0 && strcmp(sysname, "FreeBSD") == 0)
+     mount_chardev= 1;
+   if(!(S_ISREG(stbuf.st_mode) || (S_ISBLK(stbuf.st_mode) && !mount_chardev)
+        || (S_ISCHR(stbuf.st_mode) && !mount_chardev))) {
+     sprintf(xorriso->info_text,
+             "File object is not suitable as mount device: %s",
+             Text_shellsafe(dev_path, sfe, 0));
+     Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+     ret= 0; goto ex;
+   }
+
+   /* Aquire drive as direct libburn address or via stdio: prefix */
+   ret= burn_drive_convert_fs_adr(dev, libburn_adr);
+   Xorriso_process_msg_queues(xorriso,0);
+   if(ret < 0)
+     {ret= -1; goto ex;}
+   if(ret == 0 && strncmp(dev, "stdio:", 6) != 0)
+     sprintf(libburn_adr, "stdio:%s", dev);
+   burn_preset_device_open(xorriso->drives_exclusive, 0, 0);
+   ret= isoburn_drive_aquire(&dinfo, libburn_adr, 1);
+   burn_preset_device_open(1, 0, 0);
+   Xorriso_process_msg_queues(xorriso,0);
+   if(ret <= 0)
+     {ret= 0; goto ex;}
+   drive= dinfo[0].drive;
+ }
+
+ if(adr_mode == 4 && strlen(adr_pt) <= 80) {
+   ret= Xorriso__bourne_to_reg(adr_pt, adr_data, 0);
+   if(ret == 1) {
+     params_flag|= 4;
+     adr_pt= adr_data;
+   }
+ }
+ ret= isoburn_get_mount_params(drive, adr_mode, adr_pt, &lba, &track,
+                               &session, volid, params_flag);
+ Xorriso_process_msg_queues(xorriso,0);
+ if(ret <= 0)
+   goto ex;
+ if(session <= 0 || track <= 0 || ret == 2) {
+   Xorriso_msgs_submit(xorriso, 0,
+                "-mount : Given address does not point to an ISO 9660 session",
+                0, "FAILURE", 0);
+   ret= 0; goto ex;
+ }
+ if(strstr(devadr, "stdio:") == devadr)
+   devadr+= 6;
+ ret= Xorriso_make_mount_cmd(xorriso, cmd, lba, track, session, volid, devadr,
+                             mount_command, flag & (2 | 4));
+ if(ret <= 0)
+   goto ex;
+ if(ret == 2)
+   is_safe= 1;
+
+ if(is_extra_drive) {
+   isoburn_drive_release(drive, 0);
+   burn_drive_info_free(dinfo);
+   drive= NULL;
+ } else if(give_up > 0 && !((flag & 1) || (xorriso->mount_opts_flag & 1))) {
+   Xorriso_give_up_drive(xorriso, give_up);
+   if(ret <= 0)
+     goto ex;
+ }
+ Xorriso_process_msg_queues(xorriso,0);
+
+ sprintf(xorriso->info_text, "Volume id    : %s\n",
+                             Text_shellsafe(volid, sfe, 0));
+ Xorriso_info(xorriso, 0);
+ if(flag & 1) {
+   sprintf(xorriso->result_line, "%s\n", mount_command);
+   Xorriso_result(xorriso,0);
+ } else {
+   sprintf(xorriso->info_text, "Mount command: %s\n", mount_command);
+   Xorriso_info(xorriso, 0);
+   if(!is_safe) {
+     Xorriso_msgs_submit(xorriso, 0,
+  "-mount : Will not perform mount command which stems from command template.",
+       0, "SORRY", 0);
+     sprintf(xorriso->result_line, "%s\n", mount_command);
+     Xorriso_result(xorriso,0);
+   } else {
+     ret= Xorriso_execv(xorriso, mount_command, "/bin:/sbin", &status, 1);
+     if(WIFEXITED(status) && WEXITSTATUS(status) != 0) {
+       sprintf(xorriso->info_text,
+               "-mount : mount command failed with exit value %d",
+               (int) WEXITSTATUS(ret));
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+       ret= 0; goto ex;
+     }
+     sprintf(xorriso->info_text, "\nMounted session %d of device %s",
+                                 session, Text_shellsafe(dev_path, sfe, 0));
+     dpt= strchr(cmd, ':');
+     if(dpt == NULL)
+       dpt= cmd ;
+     else
+       dpt++;
+     sprintf(xorriso->info_text + strlen(xorriso->info_text),
+             " as directory %s\n", Text_shellsafe(dpt, sfe, 0));
+     Xorriso_info(xorriso, 0);
+   }
+ }
+ ret= 1;
+ex:;
+ if(is_extra_drive && drive != NULL) {
+   isoburn_drive_release(drive, 0);
+   burn_drive_info_free(dinfo);
+   Xorriso_process_msg_queues(xorriso,0);
+ }
+ return(ret);
+}
+

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 */
+

xorriso/iso_manip.h

@@ -0,0 +1,72 @@
+
+/* 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);
+
+
+#endif /* ! Xorriso_pvt_iso_manip_includeD */
+

xorriso/iso_tree.h

@@ -0,0 +1,94 @@
+
+/* 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 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_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 */
+

xorriso/lib_mgt.c

@@ -0,0 +1,523 @@
+
+/* 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 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>
+
+/* for -charset */
+#include <iconv.h>
+#include <langinfo.h>
+
+
+#include "xorriso.h" 
+#include "xorriso_private.h"
+#include "xorrisoburn.h"
+
+#include "lib_mgt.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)
+*/
+int Xorriso_set_signal_handling(struct XorrisO *xorriso, int flag)
+{
+ char *handler_prefix= NULL;
+
+ if(Xorriso__get_signal_behavior(0) != 1)
+   return(2);
+ handler_prefix= calloc(strlen(xorriso->progname)+3+1, 1);
+ if(handler_prefix==NULL) {
+   sprintf(xorriso->info_text,
+           "Cannot allocate memory for for setting signal handler");
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
+   return(-1);
+ }
+ sprintf(handler_prefix, "%s : ", xorriso->progname);
+ burn_set_signal_handling(handler_prefix, NULL, (flag & 1) * 0x30);
+ 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;
+ }
+
+ /* 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);
+ 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;
+
+ ret= iso_text_to_sev(severity_name, severity_number);
+ if(ret>0)
+   return(ret);
+   ret= burn_text_to_sev(severity_name, severity_number, 0);
+ return(ret);
+}
+
+
+/* @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[6*SfileadrL];
+ static int sorry_sev= -1;
+
+ 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);
+ 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, sfe[5 * SfileadrL];
+ 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: %s",
+           Text_shellsafe(name, sfe, 0));
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
+   return(0);
+ }
+ sprintf(xorriso->info_text, "Local character set is now assumed as: %s",
+         Text_shellsafe(name, sfe, 0));
+ 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;
+ char severity[80];
+
+ if(!xorriso->libs_are_started)
+   return(1);
+ for(pass= 0; pass< 2; pass++) {
+   while(1) {
+     tunneled= 0;
+     if(pass==0)
+       ret= iso_obtain_msgs("ALL", &error_code, &imgid,
+                            xorriso->info_text, severity);
+     else {
+       ret= burn_msgs_obtain("ALL", &error_code, xorriso->info_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");
+
+     Xorriso_msgs_submit(xorriso, error_code, xorriso->info_text, os_errno, 
+                         severity, ((pass+tunneled)+1)<<2);
+     count++;
+   }
+ }
+ if(xorriso->library_msg_direct_print && count>0) {
+   sprintf(xorriso->info_text,"   (%d library messages repeated by xorriso)\n",
+           count);
+   Xorriso_info(xorriso, 0);
+ }
+ return(1);
+}
+
+
+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);
+}
+

xorriso/lib_mgt.h

@@ -0,0 +1,78 @@
+
+/* 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= asynchronous handling (else catch thread, wait, and exit)
+*/
+int Xorriso_set_signal_handling(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 */
+

xorriso/make_xorriso_1.c

@@ -12,6 +12,10 @@
    Provided under GPL version 2 or later.
 */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>

xorriso/make_xorriso_standalone.sh

@@ -40,7 +40,7 @@ create_gnu_xorriso="yes"
 current_dir=$(pwd)
 lone_dir="$current_dir"/"xorriso-standalone"
 
-xorriso_rev=0.5.6
+xorriso_rev=0.6.2
 # For unstable uploads and patch level 0 of stable releases:
 xorriso_pl=""
 # For higher patch levels of stable releases:
@@ -114,6 +114,8 @@ 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
@@ -134,10 +136,58 @@ 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 \
@@ -237,7 +287,7 @@ then
   # patch xorriso/xorriso.c 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
 

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)
-

xorriso/match.c

@@ -0,0 +1,759 @@
+
+/* 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.
+*/
+
+#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;
+ char *cpt,*npt,adr_part[2*SfileadrL],absolute_adr[2*SfileadrL],*adr_start,*wd;
+
+ 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>sizeof(xorriso->reg_expr) || l*2+2>sizeof(adr_part)) {
+       sprintf(xorriso->info_text,"Search pattern too long");
+       Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
+       return(0);
+     }
+   }
+   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)
+       return(-1);
+     xorriso->re_constants= TSOB_FELD(char *,count);
+     if(xorriso->re_constants==NULL)
+       return(-1);
+     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(strlen(cpt)>=sizeof(adr_part))
+           return(-1);
+         strcpy(adr_part,cpt);
+       } else {
+         if(npt-cpt>=sizeof(adr_part))
+           return(-1);
+         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)
+           return(-1);
+       } 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)
+         return(2);
+       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);
+       return(0);
+     }
+
+     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))
+         return(-1);
+       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)
+       return(-1);
+     xorriso->re_constants[0]= NULL;
+     if(is_constant) {
+       if(strcmp(adr,"*")==0) {
+         if(Sregex_string(&(xorriso->re_constants[0]),"",0)<=0)
+           return(-1);
+       } else {
+         if(Sregex_string(&(xorriso->re_constants[0]),adr,0)<=0)
+           return(-1);
+       }
+       xorriso->re_fill= 1;
+     } else { 
+       xorriso->re= TSOB_FELD(regex_t,1);
+       if(xorriso->re==NULL)
+         return(-1);
+       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);
+         return(0);
+       }
+     }
+
+   }
+ }
+ return(1);
+}
+
+
+/* @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[SfileadrL],*mpt;
+
+ 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)
+         return(0);
+       if(strcmp(xorriso->re_constants[0],to_match)!=0)
+         return(reg_nomatch);
+       return(0);
+     }  
+   ret= regexec(&(xorriso->re[0]),to_match,1,xorriso->match,0);
+   return(ret);
+ }
+
+ 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)) 
+       return(reg_nomatch); /* 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)
+         return(reg_nomatch);
+   } else {
+     ret= regexec(&(xorriso->re[i]),mpt,1,xorriso->match,0);
+     if(ret!=0)
+       return(ret);
+   }
+   if(npt==NULL) {
+     if(i>=xorriso->re_fill-1)
+       return(0); /* MATCH */
+     *failed_at= i+1;
+     return(reg_nomatch);
+   }
+   cpt= npt+1;
+   while(*cpt=='/')
+     cpt++; 
+ }
+ *failed_at= xorriso->re_fill;
+ if(flag & 2)
+   return(0); /* MATCH */
+ return(reg_nomatch);
+}
+
+
+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)
+{
+ char sfe[5*SfileadrL];
+
+ 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), ": %s",
+             Text_shellsafe(patterns[0], sfe, 0));
+   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 sfe[5*SfileadrL], dir_adr[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)
+     return(ret);
+   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: %s",
+               Text_shellsafe(dir_adr, sfe, 0));
+       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)
+     return(ret);
+
+   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;
+ }
+ 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)
+{
+ if(strchr(path,'*')!=NULL || strchr(path,'?')!=NULL ||
+    strchr(path,'[')!=NULL) {
+   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: %s\n", path);
+   Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
+   return(1);
+ }
+ return(0);
+}
+

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 */
+

xorriso/misc_funct.h

@@ -0,0 +1,94 @@
+
+/* 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 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 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);
+
+
+#endif /* ! Xorriso_pvt_misc_includeD */
+

xorriso/parse_exec.h

@@ -0,0 +1,92 @@
+
+/* 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);
+
+#endif /* ! Xorriso_pvt_cmd_includeD */
+

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 */
+

xorriso/sfile.c

@@ -0,0 +1,881 @@
+
+/* 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 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_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;
+
+ l= strlen(path)+strlen(prefix)+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);
+ for(i= strlen(path)+1; i>=0; i--)
+   path[i+l]= path[i];
+ strcpy(path,prefix);
+ path[l-1]= '/';
+ 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(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)
+{
+ char *rpt, *wpt;
+ int count, sq_open= 0, dq_open= 0;
+
+ count= 0;
+ for(rpt= text; 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= text; 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_make_argv(char *progname, char *line, 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(isspace(*cpt)) continue;
+     start= cpt;
+     buf[0]= 0;
+     cpt--;
+     while(*(++cpt)!=0) {
+     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);
+}
+
+
+/* @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(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<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);
+}
+
+

xorriso/sfile.h

@@ -0,0 +1,121 @@
+
+/* 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 around files and strings.
+*/
+
+
+#ifndef Xorriso_pvt_sfile_includeD
+#define Xorriso_pvt_sfile_includeD yes
+
+#define TSOB_FELD(typ,anz) (typ *) calloc(1, (anz)*sizeof(typ));
+#define Smem_malloC malloc
+#define Smem_freE free
+
+#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);
+  
+/*
+ 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);
+
+/* 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 */
+

xorriso/sort_cmp.c

@@ -0,0 +1,714 @@
+
+/* 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 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[ISO_MSGS_MESSAGE_LEN], severity[80];
+ unsigned char *vpt;
+ static char *name= "isofs.di";
+
+#ifdef NIX
+ /* <<< */
+ Xorriso_get_di_counteR++;
+#endif /* NIX */
+
+ *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);
+   return(ret);
+ }
+ vpt= (unsigned char *) value;
+ for(i= 1; i <= vpt[0] && i < value_length; i++)
+   *dev= ((*dev) << 8) | vpt[i];
+ i_end= i + vpt[i] + 1;
+ for(i++; i < i_end && i < value_length; i++)
+   *ino= ((*ino) << 8) | vpt[i];
+ free(value);
+ return(1);
+}
+
+
+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
+                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))
+   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);
+}
+

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 */
+

xorriso/text_io.h

@@ -0,0 +1,90 @@
+
+/* 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);
+
+#endif /* ! Xorriso_pvt_textio_includeD */
+

xorriso/write_run.h

@@ -0,0 +1,53 @@
+
+/* 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 are needed to write
+   sessions.
+*/
+
+
+#ifndef Xorriso_pvt_write_run_includeD
+#define Xorriso_pvt_write_run_includeD yes
+
+
+/* CD specs say one shall not write tracks < 600 kiB */
+#define Xorriso_cd_min_track_sizE 300
+
+
+/* Default setting for -compliance */
+#define Xorriso_relax_compliance_defaulT \
+        (isoburn_igopt_allow_deep_paths | isoburn_igopt_allow_longer_paths | \
+         isoburn_igopt_always_gmt | \
+         isoburn_igopt_rrip_version_1_10 | isoburn_igopt_aaip_susp_1_10 | \
+         isoburn_igopt_only_iso_versions | isoburn_igopt_no_j_force_dots)
+
+
+int Xorriso_make_write_options(
+        struct XorrisO *xorriso, struct burn_drive *drive,
+        struct burn_write_opts **burn_options, int flag);
+
+int Xorriso_sanitize_image_size(struct XorrisO *xorriso,
+                    struct burn_drive *drive, struct burn_disc *disc,
+                    struct burn_write_opts *burn_options, int flag);
+
+int Xorriso_auto_format(struct XorrisO *xorriso, int flag);
+
+int Xorriso_set_system_area(struct XorrisO *xorriso, struct burn_drive *drive,
+                            IsoImage *img, struct isoburn_imgen_opts *sopts,
+                            int flag);
+
+int Xorriso_check_burn_abort(struct XorrisO *xorriso, int flag);
+
+int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
+                          int flag);
+
+int Xorriso_set_isolinux_options(struct XorrisO *xorriso,
+                                 IsoImage *image, int flag);
+
+
+#endif /* ! Xorriso_pvt_write_run_includeD */
+

xorriso/xorriso.1

@@ -9,7 +9,7 @@
 .\" First parameter, NAME, should be all caps
 .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
 .\" other parameters are allowed: see man(7), man(1)
-.TH XORRISO 1 "Apr 28, 2010"
+.TH XORRISO 1 "Sep 10, 2010"
 .\" Please adjust this date whenever revising the manpage.
 .\"
 .\" Some roff macros, for reference:
@@ -168,6 +168,10 @@ There are two families of media in the MMC standard:
 unformatted DVD-RW. These media provide a table of content which
 describes their existing sessions. See option \fB\-toc\fR.
 .br
+Similar to multi-session media are DVD-R DL and minimally blanked DVD-RW.
+They allow only a single session of which the size must be known in advance.
+xorriso will write onto them only if option -close is set to "on".
+.br
 \fBOverwriteable media\fR are DVD-RAM, DVD+RW, BD-RE, and formatted DVD-RW.
 They allow random write access but do not provide information about their
 session history. If they contain one or more ISO 9660 sessions and if the
@@ -241,7 +245,7 @@ The write method of \fBmodifying\fR produces compact filesystem
 images with no outdated files or directory trees. Modifying can write its
 images to target media which are completely unsuitable for multi-session
 operations. E.g. DVD-RW which were treated with -blank deformat_quickest,
-named pipes, character devices, sockets.
+DVD-R DL, named pipes, character devices, sockets.
 On the other hand modified sessions cannot be written to appendable media
 but to blank media only.
 .br
@@ -291,6 +295,10 @@ On FreeBSD the device files have names like
 .br
   -dev /dev/cd0
 .br
+On OpenSolaris:
+.br
+  -dev /dev/rdsk/c4t0d0s2
+.br
 Get a list of accessible drives by command
 .br
   -devices
@@ -385,8 +393,9 @@ An \fBMBR\fR contains boot code and a partition table. It does not hamper
 CDROM booting. The new MBR of a follow-up session can get in effect
 only on overwriteable media.
 .br
-Emulation -as mkisofs supports the example options out of the ISOLINUX wiki.
-It also supports the options used in GRUB script grub-mkrescue.
+Emulation -as mkisofs supports the example options out of the ISOLINUX wiki,
+the options used in GRUB script grub-mkrescue, and the example in the
+FreeBSD AvgLiveCD wiki.
 .br
 The support for other boot image types is sparse.
 .br
@@ -728,10 +737,6 @@ are both in effect. This restricts hard linking to other files restored by
 the same single extract command. -hardlinks "normal_extract" re-enables
 wide and expensive hardlink accumulation.
 .br
-Hardlink processing automatically enables \fB\-compliance new_rr\fR.
-This may be overridden by a following -compliance old_rr . In this case
-the resulting image will violate the RRIP-1.10 specs for entry PX in
-the same way as mkisofs does.
 .TP
 \fB\-acl\fR "on"|"off"
 Enable or disable processing of ACLs.
@@ -1422,6 +1427,23 @@ where "A0" is year 2000, "B0" is 2010, etc.
 \fB\-alter_date_r\fR type timestring iso_rr_path [***]
 Like -alter_date but affecting all files below eventual directories.
 .TP
+\fB\-hide\fR hide_state iso_rr_path [***]
+Prevent the names of the given files from showing up in the directory trees
+of ISO 9660 and/or Joliet when the image gets written.
+The eventual data content of such hidden files will be included in the
+resulting image, even if they do not show up in any directory.
+But you will need own means to find nameless data in the image.
+.br
+Warning: Data which are hidden from the ISO 9660 tree will not be copied
+by the write method of modifying.
+.br
+Possible values of hide_state are: "iso_rr" for hiding from ISO 9660 tree,
+"joliet" for Joliet tree, "on" for both trees. "off" means visibility in
+both directory trees.
+.br
+This command does not apply to the boot catalog.
+Rather use: -boot_image "any" "cat_hidden=on"
+.TP
 .B Tree traversal command -find:
 .PP
 .TP
@@ -1447,6 +1469,10 @@ Matches if pattern matches the file leaf name.
 Matches if pattern matches the file path as it would be printed by action
 "echo". Character '/' is not special but can be matched by wildcards.
 .br
+\fB\-disk_name\fR pattern :
+Like -name but testing the leaf name of the file source on disk.
+Can be true only for data files which stem not from the loaded image.
+.br
 \fB\-type\fR type_letter :
 Matches files of the given type:
 "block", "char", "dir", "pipe", "file", "link", "socket", "eltorito",
@@ -1484,6 +1510,11 @@ Matches data files which have MD5 checksums.
 \fB\-has_filter\fR :
 Matches files which are filtered by -set_filter.
 .br
+\fB\-hidden\fR hide_state :
+Matches files which are hidden in "iso_rr" tree, in "joliet" tree,
+in both trees ("on"), or not hidden in any tree ("off").
+Those which are hidden in some tree match -not -hidden "off".
+.br
 \fB\-prune\fR :
 If this test is reached and the tested file is a directory then -find will not
 dive into that directory. This test itself does always match. 
@@ -1658,6 +1689,13 @@ E.g.: -exec sort_weight 3 --
 \fBshow_stream\fR
 shows the content stream chain of a data file.
 .br
+\fBhide\fR
+brings the file into one of the hide states "on", "iso_rr", "joliet", "off".
+.br
+E.g.:
+.br
+  -find / -disk_name *_secret -exec hide on
+.br
 \fBfind\fR
 performs another run of -find on the matching file address.
 It accepts the same params as -find, except iso_rr_path.
@@ -1961,6 +1999,9 @@ Default is "old_rr" which uses Rock Ridge version 1.10. This implies also
 "aaip_susp_1_10" allows AAIP to be written as unofficial extension of RRIP
 rather than as official extension under SUSP-1.12.
 .br
+"no_emul_toc" saves 64 kB with the first session on overwriteable media
+but makes the image incapable of displaying its session history.
+.br
 Default setting is
 .br
  "clear:only_iso_version:deep_paths:long_paths:no_j_force_dots:
@@ -2006,6 +2047,10 @@ Set the application id string to be written with the next -commit. This may
 identify the specification of how the data are recorded.
 Permissible are up to 128 characters. This setting gets overridden by
 image loading.
+.br
+The special text "@xorriso@" gets converted to the id string of xorriso
+which is normally written as -preparer_id. It is a wrong tradition to write
+the program id as -application_id.
 .TP
 \fB\-system_id\fR text
 Set the system id string to be written with the next -commit. This may
@@ -2041,6 +2086,39 @@ They are prone to timezone computations. The timestrings "default" or
 of image creation. "x" and "f" will be marked as insignificant.
 "uuid" will be deactivated.
 .TP
+\fB\-copyright_file\fR text
+Set the copyright file name to be written with the next -commit. This should
+be the ISO 9660 path of a file in the image which contains a copyright
+statement.
+Permissible are up to 37 characters. This setting gets overridden by
+image loading.
+.TP
+\fB\-abstract_file\fR text
+Set the abstract file name to be written with the next -commit. This should
+be the ISO 9660 path of a file in the image which contains an abstract
+statement about the image content.
+Permissible are up to 37 characters. This setting gets overridden by
+image loading.
+.TP
+\fB\-biblio_file\fR text
+Set the biblio file name to be written with the next -commit. This should
+be the ISO 9660 path of a file in the image which contains bibliographic
+records.
+Permissible are up to 37 characters. This setting gets overridden by
+image loading.
+.TP
+\fB\-preparer_id\fR
+Set the preparer id string to be written with the next -commit. This may
+identify the person or other entity which controls the preparation of the data
+which shall be recorded. Normally this should be the id of xorriso and not
+of the person or program which operates xorriso. Please avoid to change it.
+Permissible are up to 128 characters.
+.br
+The special text "@xorriso@" gets converted to the id string of xorriso
+which is default at program startup.
+.br
+Unlike other id strings, this setting is not influenced by image loading.
+.TP
 \fB\-out_charset\fR character_set_name
 Set the character set to which file names get converted when writing an
 image. See paragraph "Character sets" for more explanations.
@@ -2231,19 +2309,25 @@ which bundles these individual settings:
 .br
  -boot_image any boot_info_table=on
 .br
-\fBbin_path=\fR depicts the boot image file, a binary program which is to be
-started by the hardware boot facility (e.g. the BIOS) at boot time.
-.br
-\fBefi_path=\fR depicts a boot image file that is ready for EFI booting.
-Its load_size is determined automatically, no boot info table gets
-written, platform_id is 0xef.
-.br
 An El Torito boot catalog file gets inserted into the ISO image with address
 \fBcat_path=\fR at -commit time.
 It is subject to normal -overwrite and -reassure processing if there is already
 a file with the same name.
 The catalog lists the boot images and is read by the boot facility to choose
-one of the boot images.
+one of the boot images. But it is not necessary that it appears in the
+directory tree at all. One may hide it in all trees by \fBcat_hidden=on\fR.
+Other possible values are "iso_rr", "joliet", and the default "off".
+.br
+\fBbin_path=\fR depicts a boot image file, a binary program which is to be
+started by the hardware boot facility (e.g. the BIOS) at boot time.
+.br
+\fBefi_path=\fR depicts a boot image file that is ready for EFI booting.
+Its load_size is determined automatically, no boot info table gets
+written, no boot media gets emulated, platform_id is 0xef.
+.br
+\fBemul_type=\fR can be one of "no_emulation", "hard_disk", "diskette".
+It controls the boot media emulation code of a boot image.
+The default "no_emulation" is suitable for ISOLINUX, GRUB, FreeBSD cdboot.
 .br
 \fBload_size=\fR is a value which depends on the boot image.
 Default 2048 should be overridden only if a better value is known.
@@ -2309,6 +2393,22 @@ then those parameters get updated when the new System Area is written.
 Special "system_area=/dev/zero" causes 32k of NUL-bytes.
 Use this to discard an MBR which eventually was loaded with the ISO image.
 .br
+\fBpartition_offset=\fR2kb_block_adr causes a partition table with a single
+partition that begins at the given block address. This is counted in 2048 byte
+blocks, not in 512 byte blocks. If the block address is non-zero then it must
+be at least 16. A non-zero partition offset causes two superblocks to be
+generated and two sets of directory trees. The image is then mountable from its
+absolute start as well as from the partition start.
+.br
+The offset value of an ISO image gets preserved when a new session is added.
+So the value defined here is only in effect if a new ISO image gets written.
+.br
+\fBpartition_sec_hd=\fRnumber gives the number of sectors per head for
+partition offset. 0 chooses a default value.
+.br
+\fBpartition_hd_cyl=\fRnumber gives the number of heads per cylinder for
+partition offset. 0 chooses a default value.
+.br
 .TP
 .B Character sets:
 .PP
@@ -2623,7 +2723,7 @@ subtracting already foreseeable consumption by next -commit.
 .TP
 \fB\-pvd_info\fR 
 Print various id strings which can be found in loaded ISO images. Some of
-them may be changed by options -volid, -publisher, -application_id. For these
+them may be changed by options like -volid or -publisher. For these
 ids -pvd_info reports what would be written with the next -commit.
 .TP
 .B Navigation in ISO image and disk filesystem:
@@ -2667,6 +2767,10 @@ This resembles shell command ls -d.
 \fB\-lsl\fR iso_rr_pattern [***]
 Like -ls but also list some of the file attributes. 
 The output format resembles shell command ls -ln.
+.br
+If the file has non-trivial ACL, then a '+' is appended to the permission info.
+If the file is hidden, then 'I' for "iso_rr", 'J' for "joliet", resp. 'H' for
+"on" gets appended. Together with ACL it is 'i', 'j', resp. 'h'.
 .TP
 \fB\-lsdl\fR iso_rr_pattern [***]
 Like -lsd but also list some of the file attributes. 
@@ -3139,10 +3243,12 @@ Personality "\fBmkisofs\fR" accepts the options listed with:
 .br
   -as mkisofs -help --
 .br
-Among them: -R (always on), -r, -J, -o, -M, -C, -path-list, -m, -exclude-list,
+Among them: -R (always on), -r, -J, -o, -M, -C, -dir-mode, -file-mode,
+-path-list, -m, -exclude-list,
 -f, -print-size, -pad, -no-pad, -V, -v, -version, -graft-points, -z,
 -no-emul-boot, -b, -c, -boot-info-table, -boot-load-size, -input-charset, -G,
--output-charset, pathspecs as with xorriso -add.
+-output-charset, -U, -hide, -hide-joliet, -hide-list, -hide-joliet-list,
+file paths and pathspecs.
 A lot of options are not supported and lead to failure of the mkisofs
 emulation. Some are ignored, but better do not rely on this tolerance.
 .br
@@ -3175,6 +3281,7 @@ They work like the xorriso options with the
 same name and hardcoded argument "on", e.g. -acl "on".
 Explicit arguments are expected by --stdio_sync
 and --scdbackup_tag.
+--no-emul-toc is -compliance no_emul_toc.
 .br
 --sort-weight gets as arguments a number and an iso_rr_path.
 The number becomes the LBA sorting weight of regular file iso_rr_path or
@@ -3184,22 +3291,31 @@ of all regular files underneath directory iso_rr_path.
 Adopted from grub-mkisofs are --protective-msdos-label 
 (see -boot_image grub partition_table=on) and 
 --modification-date=YYYYMMDDhhmmsscc
-(see -volume_date uuid). For EFI bootable GRUB boot images use --efi-boot.
-It performs -boot_image grub efi_path= surrounded by two -boot_image any next. 
+(see -volume_date uuid). For EFI bootable GRUB boot images use
+--efi-boot.
+It performs -boot_image grub efi_path= surrounded by two
+-boot_image "any" "next". 
+Alternative option -e from Fedora genisoimage sets bin_path and
+platform_id for EFI, but performs no "next". 
 .br
 For MBR bootable ISOLINUX images there is -isohybrid-mbr FILE, where
 FILE is one of the Syslinux files mbr/isohdp[fp]x*.bin . Use this
 instead of -G to apply the effect of -boot_image isolinux partition_table=on.
 .br
+--boot-catalog-hide is -boot_image any cat_hidden=on.
+.br
+-partition_offset number is
+-boot_image any partition_offset=number.
+.br
 Personalites "\fBxorrisofs\fR", "\fBgenisoimage\fR",
 and "\fBgenisofs\fR" are aliases for "mkisofs".
 .br
 If xorriso is started with one of the leafnames "xorrisofs", "genisofs",
-"mkisofs", or "genisoimage", then it automatically prepends -as "genisofs"
-to the command line arguments. I.e. all arguments will be interpreted mkisofs
-style until "--" is encountered.
-From then on, options are interpreted
-as xorriso options.
+"mkisofs", or "genisoimage", then it performs -read_mkisofsrc and prepends
+-as "genisofs" to the command line arguments.
+I.e. all arguments will be interpreted mkisofs style until "--"
+is encountered. 
+From then on, options are interpreted as xorriso options.
 .br
 
 Personality "\fBcdrecord\fR" accepts the options listed with:
@@ -3244,6 +3360,20 @@ to the command line arguments. I.e. all arguments will be interpreted cdrecord
 style until "--" is encountered and an eventual commit happens.
 From then on, options are interpreted as xorriso options.
 .TP
+\fB\-read_mkisofsrc\fR
+Try one by one to open for reading:
+ ./.mkisofsrc , $MKISOFSRC , $HOME/.mkisofsrc , $(dirname $0)/.mkisofsrc 
+.br
+On success interpret the file content as of man mkisofs CONFIGURATION,
+and end this command. Do not try further files.
+The last address is used only if start argument 0 has a non-trivial dirname.
+.br
+The reader currently interprets the following NAME=VALUE pairs:
+APPI (-application_id) , PUBL (-publisher) , SYSI (-system_id) ,
+VOLI (-volid) , VOLS (-volset_id)
+.br
+Any other lines will be silently ignored.
+.TP
 \fB\-pacifier\fR behavior_code
 Control behavior of UPDATE pacifiers during write operations.
 The following behavior codes are defined:
@@ -3493,8 +3623,10 @@ Restore directory trees from a particular ISO session to disk
 Try to retrieve blocks from a damaged media
 .SS
 .B As superuser learn about available drives
-Consider to give rw permissions to those users or groups
+On Linux or FreeBSD consider to give rw-permissions to those users or groups
 which shall be able to use the drives with xorriso.
+On Solaris use pfexec. Consider to restrict privileges of xorriso to
+"base,sys_devices" and to give r-permission to user or group.
 .br
 $ xorriso -devices
 .br
@@ -3969,6 +4101,10 @@ to read and execute lines from the following files:
 .br
 The files are read in the sequence given above, but none of them is required
 to exist.
+.br
+If mkisofs emulation was enabled by program name "xorrisofs", "mkisofs",
+"genisoimage", or "genisofs", then afterwards -read_mkisofsrc is performed,
+which reads .mkisofsrc files. See there.
 .SS
 .B Runtime control files:
 .br
@@ -4009,7 +4145,7 @@ for libburnia-project.org
 .SH COPYRIGHT
 Copyright (c) 2007 - 2010 Thomas Schmitt
 .br
-Permission is granted to distrubute this text freely. It shall only be
+Permission is granted to distribute this text freely. 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 then you are entitled
 to modify this text under that same license.

xorriso/xorriso.h

@@ -1,14 +1,42 @@
 
-/* Command line oriented batch and dialog tool which creates, loads,
-   manipulates and burns ISO 9660 filesystem images.
+/* xorriso - libisoburn higher level API which 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 public option interface of xorriso.
+   This file contains the public API of xorriso which covers all of its
+   operations.
+
+   An example of its usage is xorriso_main.c which checks version compatibility,
+   creates a xorriso object, initializes the libraries, and runs the command
+   interpreters of the API to constitute the command line oriented batch and
+   dialog tool xorriso.
+
+   Alternatively to command interpreters it is possible to run all options of
+   xorriso directly via the calls of the "Options API". 
+   The "Problem Status and Message API" shall then be used to obtain the
+   text output of the options.
+
+   Mandatory calls are:
+     Xorriso_new(), Xorriso_startup_libraries(), Xorriso_destroy()
+
+   This architecture is fully public since version 0.5.8. From then on, new
+   features get marked by
+     @since major.minor.micro
+   If this mark is missing, then the feature was present before release 0.5.8.
+
+
+   There is a lower level of API which consists of libisofs.h, libburn.h and
+   libisoburn.h. One should not mix those calls with the ones of xorriso.h .
 */
 
+/* Important: If you add a public API function then add its name to file
+                  libisoburn/libisoburn.ver
+*/
+
+
 #ifndef Xorriso_includeD
 #define Xorriso_includeD yes
 
@@ -16,20 +44,81 @@
 struct XorrisO; 
 
 
-#define Xorriso_program_versioN "0.5.6"
-#define Xorriso_program_patch_leveL ""
+
+/* This may be changed to Xorriso_GNU_xorrisO in order to create GNU xorriso
+   under GPLv3+ derived from above GPLv2+.
+*/
+#define Xorriso_libburnia_xorrisO yes
 
 
 /* --------------------- Fundamental Management ------------------- */
 
 
-/* Get the version text (e.g. "0.4.2") of the program code.
-   This may differ from Xorriso_program_versioN if xorriso is dynamically
-   linked to an application.
-   @param flag     unused yet, submit 0
-   @return         readonly character string
+/** These three release version numbers tell the revision of this header file
+    and of the API which it describes. They shall be memorized by applications
+    at build time.
+    @since 0.5.8
 */
-char *Xorriso__get_version_text(int flag);
+#define Xorriso_header_version_majoR  0
+#define Xorriso_header_version_minoR  6
+#define Xorriso_header_version_micrO  2
+
+
+/** Eventually something like ".pl01" to indicate a bug fix. Normally empty.
+    @since 0.5.8
+*/
+#define Xorriso_program_patch_leveL ""
+
+
+/** Obtain the three release version numbers of the library. These are the
+    numbers encountered by the application when linking with libisoburn,
+    i.e. possibly not before run time.
+    Better do not base the fundamental compatibility decision of an application
+    on these numbers. For a reliable check use Xorriso__is_compatible().
+    @since 0.5.8
+    @param major The maturity version (0 for now, as we are still learning)
+    @param minor The development goal version.
+    @param micro The development step version. This has an additional meaning:
+
+                 Pare numbers indicate a version with frozen API. I.e. you can
+                 rely on the same set of features to be present in all
+                 published releases with that major.minor.micro combination.
+                 Features of a pare release will stay available and ABI
+                 compatible as long as the SONAME of libisoburn stays "1".
+                 Currently there are no plans to ever change the SONAME.
+                  
+                 Odd numbers indicate that API upgrades are in progress.
+                 I.e. new features might be already present or they might
+                 be still missing. Newly introduced features may be changed
+                 incompatibly or even be revoked before release of a pare
+                 version.
+                 So micro revisions {1,3,5,7,9} should never be used for
+                 dynamic linking unless the proper library match can be
+                 guaranteed by external circumstances.
+
+    @return 1 success, <=0 might in future become an error indication
+*/
+void Xorriso__version(int *major, int *minor, int *micro);
+
+
+/** Check whether all features of header file xorriso.h from the given
+    major.minor.micro revision triple can be delivered by the library version
+    which is performing this call.
+        if (! Xorriso__is_compatible(Xorriso_header_version_majoR,
+                                     Xorriso_header_version_minoR,
+                                     Xorriso_header_version_micrO, 0))
+           ...refuse to start the program with this dynamic library version...
+    @since 0.5.8
+    @param major obtained at build time
+    @param minor obtained at build time
+    @param micro obtained at build time
+    @param flag Bitfield for control purposes. Unused yet. Submit 0.
+    @return 1= library can work for caller
+            0= library is not usable in some aspects. Caller must restrict
+               itself to an earlier API version or must not use this library
+               at all.
+*/
+int Xorriso__is_compatible(int major, int minor, int micro, int flag);
 
 
 /* Get the patch level text (e.g. "" or ".pl01") of the program code.
@@ -74,8 +163,71 @@ int Xorriso__preset_signal_behavior(int behavior, int flag);
 int Xorriso_new(struct XorrisO ** xorriso, char *progname, int flag);
 
 
-/* Interpret certain commands which shall get into effect before the
-   libraries get initialized:
+/* Note: Between Xorriso_new() and the next call Xorriso_startup_libraries()
+         there may be called the special command interpreter
+         Xorriso_prescan_args().
+         The other command interpreters may be used only after
+         Xorriso_startup_libraries(). The same restriction applies to the
+         calls of the Options API further below.
+*/
+
+
+/* Mandatory call:
+   It has to be made before calling any function listed below this point.
+   Only exception is the special command interpreter Xorriso_prescan_args().
+
+   Make global library initializations.
+   This must be done with the first xorriso object that gets created and
+   with the first xorriso object that gets created after Xorriso_destroy(,1).
+   @param xorriso The context object.
+   @param flag    unused yet, submit 0
+   @return        <=0 error , >0 success
+*/ 
+int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
+
+
+/* Note: After library startup, you may run Command Interpreters or call
+         functions from the Options API.
+
+         Wenn all desired activities are done, you may check whether there are
+         uncommited changes pending, compute an exit value, destroy the XorrisO
+         object, and exit your program.
+*/
+
+
+/* Inquire whether option -commit would make sense.
+   @param xorriso The context object to inquire.
+   @param flag    unused yet, submit 0
+   @return        0= -commit would have nothing to do
+                  1= a new image session would emerge at -commit
+*/
+int Xorriso_change_is_pending(struct XorrisO *xorriso, int flag);
+
+
+/* Compute the exit value from the recorded maximum event severity.
+   @param xorriso The context object to inquire.
+   @param flag    unused yet, submit 0
+   @return        The computed exit value
+*/
+int Xorriso_make_return_value(struct XorrisO *xorriso, int flag);
+
+
+/* Mandatory call:
+   Destroy xorriso object when it is no longer needed.
+   @param xorriso  The context object to destroy. *xorriso will become NULL.
+   @param flag     bit0= Perform global library shutdown.
+                         Use only with last xorriso object to be destroyed.
+   @return         <=0 error, >0 success
+*/
+int Xorriso_destroy(struct XorrisO **xorriso, int flag);
+
+
+/* --------------------- Command Interpreters ------------------- */
+
+
+/* This special interpreter is eventually called between Xorriso_new() and
+   Xorriso_startup_libraries(). It interprets certain commands which shall
+   get into effect before the libraries get initialized:
      -abort_on , -report_about , -return_with , -list_delimiter
    Some commands get executed only if they are the only command in argv:
      -prog_help , -help , -no_rc
@@ -98,19 +250,6 @@ int Xorriso_prescan_args(struct XorrisO *xorriso, int argc, char **argv,
                          int flag);
 
 
-/* Mandatory call:
-   It has to be made before calling any function listed below this point.
-
-   Make global library initializations.
-   This must be done with the first xorriso object that gets created and
-   with the first xorriso object that gets created after Xorriso_destroy(,1).
-   @param xorriso The context object.
-   @param flag    unused yet, submit 0
-   @return        <=0 error , >0 success
-*/ 
-int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
-
-
 /* Read and interpret commands from eventual startup files as listed in
    man xorriso.
    @param xorriso The context object in which to perform the commands.
@@ -156,8 +295,9 @@ int Xorriso_program_arg_bsl(struct XorrisO *xorriso, int argc, char ***argv,
                   be at least 1, argv[*idx] must be a command.
                   *idx will iterate over commands and parameters until this
                   function aborts or until argc is reached.
-   @param flag    bit0= recursion
-                  bit1= these are the main() program start arguments
+   @param flag    bit0= reserved. Indicates recursion. Submit 0. 
+                  bit1= Indicates that these are the main() program start
+                        arguments
    @return <=0 = error
              1 = success
              2 = problem event ignored
@@ -192,33 +332,6 @@ int Xorriso_execute_option(struct XorrisO *xorriso, char *line, int flag);
 int Xorriso_dialog(struct XorrisO *xorriso, int flag);
 
 
-/* Inquire whether option -commit would make sense.
-   @param xorriso The context object to inquire.
-   @param flag    unused yet, submit 0
-   @return        0= -commit would have nothing to do
-                  1= a new image session would emerge at -commit
-*/
-int Xorriso_change_is_pending(struct XorrisO *xorriso, int flag);
-
-
-/* Compute the exit value from the recorded maximum event severity.
-   @param xorriso The context object to inquire.
-   @param flag    unused yet, submit 0
-   @return        The computed exit value
-*/
-int Xorriso_make_return_value(struct XorrisO *xorriso, int flag);
-
-
-/* Mandatory call:
-   Destroy xorriso object when it is no longer needed.
-   @param xorriso  The context object to destroy. *xorriso will become NULL.
-   @param flag     bit0= Perform global library shutdown.
-                         Use only with last xorriso object to be destroyed.
-   @return         <=0 error, >0 success
-*/
-int Xorriso_destroy(struct XorrisO **xorriso, int flag);
-
-
 /* --------------------- Problem Status and Message API ------------------- */
 
 
@@ -241,8 +354,9 @@ int Xorriso_destroy(struct XorrisO **xorriso, int flag);
                       A final newline character gets appended automatically.
     @param os_errno   Eventual errno related to the message. Submit 0 if
                       the message is not related to a operating system error.
-    @param severity   One of "ABORT", "FATAL", "SORRY", "WARNING", "HINT",
-                      "NOTE", "UPDATE", "DEBUG". Defaults to "FATAL".
+    @param severity   One of "ABORT", "FATAL", "FAILURE", "MISHAP", "SORRY",
+                      "WARNING", "HINT", "NOTE", "UPDATE", "DEBUG".
+                      Defaults to "FATAL".
     @param flag       Bitfield for control purposes
                         bit0= use pager (as with result)
                         bit1= permission to suppress output
@@ -424,6 +538,7 @@ struct Xorriso_lsT *Xorriso_lst_get_prev(struct Xorriso_lsT *entry, int flag);
 
 /** Destroy all list items which are directly or indirectly connected to
     the given link item.
+    All pointers obtained by Xorriso_lst_get_text() become invalid by this.
     Apply this to each of the two list handles obtained by 
     Xorriso_pull_outlists() when the lists are no longer needed.
     @param lstring  *lstring will be freed and set to NULL.
@@ -462,11 +577,13 @@ int Xorriso_lst_destroy_all(struct Xorriso_lsT **lstring, int flag);
 /* Option -abort_on */
 int Xorriso_option_abort_on(struct XorrisO *xorriso, char *severity, int flag);
 
+/* Option -abstract_file */
+int Xorriso_option_abstract_file(struct XorrisO *xorriso, char *name,
+                                 int flag);
 
 /* Option -acl "on"|"off" */
 int Xorriso_option_acl(struct XorrisO *xorriso, char *mode, int flag);
 
-
 /* Option -add */
 /* @param flag bit0=do not report the added item
                bit1=do not reset pacifier, no final pacifier message
@@ -511,6 +628,9 @@ int Xorriso_option_backslash_codes(struct XorrisO *xorriso, char *mode,
 /* Option -ban_stdio_write */
 int Xorriso_option_ban_stdio_write(struct XorrisO *xorriso, int flag);
 
+/* Option -biblio_file */
+int Xorriso_option_biblio_file(struct XorrisO *xorriso, char *name, int flag);
+
 /* Option -blank and -format */
 /* @param flag bit0= format rather than blank
    @return <=0 error , 1 success, 2 revoked by -reassure
@@ -574,6 +694,9 @@ int Xorriso_option_chowni(struct XorrisO *xorriso, char *uid,
 /* Option -close "on"|"off" */
 int Xorriso_option_close(struct XorrisO *xorriso, char *mode, int flag);
 
+/* Option -close_filter_list */
+int Xorriso_option_close_filter_list(struct XorrisO *xorriso, int flag);
+
 /* Option -commit */
 /* @param flag bit0= leave indrive and outdrive aquired as they were,
                      i.e. do not aquire outdrive as new in-out-drive
@@ -596,6 +719,13 @@ int Xorriso_option_commit_eject(struct XorrisO *xorriso, char *which, int flag);
 int Xorriso_option_compare(struct XorrisO *xorriso, char *disk_path,
                            char *iso_path, int flag);
 
+/* Option -compliance */
+int Xorriso_option_compliance(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -copyright_file */
+int Xorriso_option_copyright_file(struct XorrisO *xorriso, char *name,
+                                  int flag);
+
 /* Option -cpr alias -cpri */
 int Xorriso_option_cpri( struct XorrisO *xorriso, int argc, char **argv,
                          int *idx, int flag);
@@ -676,8 +806,10 @@ int Xorriso_option_extract(struct XorrisO *xorriso, char *disk_path,
 int Xorriso_option_extract_cut(struct XorrisO *xorriso, char *iso_rr_path,
                           char *start, char *count, char *disk_path, int flag);
 
-/* Option -follow */
-int Xorriso_option_follow(struct XorrisO *xorriso, char *mode, int flag);
+/* Option -file_size_limit */
+int Xorriso_option_file_size_limit(struct XorrisO *xorriso,
+                                   int argc, char **argv, int *idx, int flag);
+
 
 /* Option -find alias -findi, and -findx */
 /* @param flag bit0= -findx rather than -findi
@@ -687,6 +819,9 @@ int Xorriso_option_follow(struct XorrisO *xorriso, char *mode, int flag);
 int Xorriso_option_find(struct XorrisO *xorriso, int argc, char **argv,
                        int *idx, int flag);
 
+/* Option -follow */
+int Xorriso_option_follow(struct XorrisO *xorriso, char *mode, int flag);
+
 /* Option -fs */
 int Xorriso_option_fs(struct XorrisO *xorriso, char *size, int flag);
 
@@ -708,6 +843,10 @@ int Xorriso_option_hardlinks(struct XorrisO *xorriso, char *mode, int flag);
 /* Option -help and part of -prog_help */
 int Xorriso_option_help(struct XorrisO *xorriso, int flag);
 
+/* Option -hide */
+int Xorriso_option_hide(struct XorrisO *xorriso, char *hide_state,
+                        int argc, char **argv, int *idx, int flag);
+
 /* Option -history */
 int Xorriso_option_history(struct XorrisO *xorriso, char *line, int flag);
 
@@ -804,14 +943,28 @@ int Xorriso_option_mvi(struct XorrisO *xorriso, int argc, char **argv,
 /* Option -no_rc */
 int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag);
 
-/* Option -not_leaf */
+/* Option -not_leaf , -as mkisofs -hide without '/' */
+/* @param flag  bit0= add to iso_rr hide list rather than to disk exclusions
+                      @since 0.6.0
+                bit1= add to joliet hide list rather than disk exclusions
+                      @since 0.6.0
+*/
 int Xorriso_option_not_leaf(struct XorrisO *xorriso, char *pattern, int flag);
 
 /* Option -not_list , -quoted_not_list */
 /* @param flag bit0= -quoted_not_list */
 int Xorriso_option_not_list(struct XorrisO *xorriso, char *adr, int flag);
 
-/* Option -not_paths */
+/* Option -not_mgt */
+int Xorriso_option_not_mgt(struct XorrisO *xorriso, char *setting, int flag);
+
+/* Option -not_paths , -as mkisofs -hide with '/' */
+/* @param flag  bit0= add to iso_rr hide list rather than to disk exclusions
+                      @since 0.6.0
+                bit1= add to joliet hide list rather than disk exclusions
+                      @since 0.6.0
+                bit2= enable disk pattern expansion regardless of -disk_pattern
+*/ 
 int Xorriso_option_not_paths(struct XorrisO *xorriso, int argc, char **argv,
                              int *idx, int flag);
 
@@ -849,6 +1002,9 @@ int Xorriso_option_pathspecs(struct XorrisO *xorriso, char *mode, int flag);
 /* Option -pkt_output */
 int Xorriso_option_pkt_output(struct XorrisO *xorriso, char *mode, int flag);
 
+/* Option -preparer_id */
+int Xorriso_option_preparer_id(struct XorrisO *xorriso, char *name, int flag);
+
 /* Option -print */
 int Xorriso_option_print(struct XorrisO *xorriso, char *text, int flag);
 
@@ -860,6 +1016,9 @@ int Xorriso_option_print_size(struct XorrisO *xorriso, int flag);
 /* Option -prog */
 int Xorriso_option_prog(struct XorrisO *xorriso, char *name, int flag);
 
+/* Option -prompt */
+int Xorriso_option_prompt(struct XorrisO *xorriso, char *text, int flag);
+
 /* Option -prog_help */
 int Xorriso_option_prog_help(struct XorrisO *xorriso, char *name, int flag);
 
@@ -875,13 +1034,12 @@ int Xorriso_option_pwdi(struct XorrisO *xorriso, int flag);
 /* Option -pwdx */
 int Xorriso_option_pwdx(struct XorrisO *xorriso, int flag);
 
+/* Option -read_mkisofsrc */
+int Xorriso_option_read_mkisofsrc(struct XorrisO *xorriso, int flag);
+
 /* Option -reassure "on"|"tree"|"off" */
 int Xorriso_option_reassure(struct XorrisO *xorriso, char *mode, int flag);
 
-/* Option -relax_compliance */
-int Xorriso_option_relax_compliance(struct XorrisO *xorriso, char *mode,
-                                    int flag);
-
 /* Option -report_about */
 int Xorriso_option_report_about(struct XorrisO *xorriso, char *severity, 
                                 int flag);
@@ -890,9 +1048,6 @@ int Xorriso_option_report_about(struct XorrisO *xorriso, char *severity,
 int Xorriso_option_return_with(struct XorrisO *xorriso, char *severity,
                                int exit_value, int flag);
 
-/* Option -revoke_exclusions */
-int Xorriso_option_revoke_exclusions(struct XorrisO *xorriso, int flag);
-
 /* Options -rm alias -rmi , -rm_r alias -rm_ri , -rmdir alias -rmdiri */
 /* @param flag bit0=recursive , bit2= remove empty directory: rmdir */
 int Xorriso_option_rmi(struct XorrisO *xorriso, int argc, char **argv,
@@ -999,6 +1154,8 @@ int Xorriso_option_use_readline(struct XorrisO *xorriso, char *mode, int flag);
 int Xorriso_option_version(struct XorrisO *xorriso, int flag);
 
 /* Option -volid */
+/* @param flag bit0= do not warn of problematic volid
+*/
 int Xorriso_option_volid(struct XorrisO *xorriso, char *volid, int flag);
 
 /* Option -volset_id */

xorriso/xorriso.info

@@ -149,6 +149,10 @@ There are two families of media in the MMC standard:
 *Multi-session media* are CD-R, CD-RW, DVD-R, DVD+R, DVD+R/DL, BD-R, and
 unformatted DVD-RW. These media provide a table of content which
 describes their existing sessions. See option *-toc*.
+Similar to multi-session media are DVD-R DL and minimally blanked
+DVD-RW.  They allow only a single session of which the size must be
+known in advance.  xorriso will write onto them only if option -close
+is set to "on".
 *Overwriteable media* are DVD-RAM, DVD+RW, BD-RE, and formatted DVD-RW.
 They allow random write access but do not provide information about
 their session history. If they contain one or more ISO 9660 sessions
@@ -221,9 +225,9 @@ Growing is achieved by option -dev.
 with no outdated files or directory trees. Modifying can write its
 images to target media which are completely unsuitable for multi-session
 operations. E.g. DVD-RW which were treated with -blank
-deformat_quickest, named pipes, character devices, sockets.  On the
-other hand modified sessions cannot be written to appendable media but
-to blank media only.
+deformat_quickest, DVD-R DL, named pipes, character devices, sockets.
+On the other hand modified sessions cannot be written to appendable
+media but to blank media only.
 So for this method one needs either two optical drives or has to work
 with filesystem objects as source and/or target media.
 Modifying takes place if input drive and output drive are not the same
@@ -265,6 +269,8 @@ character device. E.g.
 -dev /dev/sg2
 On FreeBSD the device files have names like
 -dev /dev/cd0
+On OpenSolaris:
+-dev /dev/rdsk/c4t0d0s2
 Get a list of accessible drives by command
 -devices
 It might be necessary to do this as *superuser* in order to see all
@@ -343,7 +349,8 @@ needs of GRUB resp. ISOLINUX.  An *MBR* contains boot code and a
 partition table. It does not hamper CDROM booting. The new MBR of a
 follow-up session can get in effect only on overwriteable media.
 Emulation -as mkisofs supports the example options out of the ISOLINUX
-wiki.  It also supports the options used in GRUB script grub-mkrescue.
+wiki, the options used in GRUB script grub-mkrescue, and the example in
+the FreeBSD AvgLiveCD wiki.
 The support for other boot image types is sparse.
 
 *ACL* are an advanced way of controlling access permissions to file
@@ -687,11 +694,6 @@ activate them only after image loading.
      restored by the same single extract command. -hardlinks
      "normal_extract" re-enables wide and expensive hardlink
      accumulation.
-     Hardlink processing automatically enables *-compliance new_rr*.
-     This may be overridden by a following -compliance old_rr . In this
-     case the resulting image will violate the RRIP-1.10 specs for
-     entry PX in the same way as mkisofs does.
-
 -acl "on"|"off"
      Enable or disable processing of ACLs.  If enabled, then xorriso
      will obtain ACLs from disk file objects, store ACLs in the ISO
@@ -1302,6 +1304,21 @@ whether they stem from the loaded image or were newly inserted.
      Like -alter_date but affecting all files below eventual
      directories.
 
+-hide hide_state iso_rr_path [***]
+     Prevent the names of the given files from showing up in the
+     directory trees of ISO 9660 and/or Joliet when the image gets
+     written.  The eventual data content of such hidden files will be
+     included in the resulting image, even if they do not show up in
+     any directory.  But you will need own means to find nameless data
+     in the image.
+     Warning: Data which are hidden from the ISO 9660 tree will not be
+     copied by the write method of modifying.
+     Possible values of hide_state are: "iso_rr" for hiding from ISO
+     9660 tree, "joliet" for Joliet tree, "on" for both trees. "off"
+     means visibility in both directory trees.
+     This command does not apply to the boot catalog.  Rather use:
+     -boot_image "any" "cat_hidden=on"
+
 
 File: xorriso.info,  Node: CmdFind,  Next: Filter,  Prev: Manip,  Up: Options
 
@@ -1327,6 +1344,10 @@ File: xorriso.info,  Node: CmdFind,  Next: Filter,  Prev: Manip,  Up: Options
           Matches if pattern matches the file path as it would be
           printed by action "echo". Character '/' is not special but
           can be matched by wildcards.
+    -disk_name pattern :
+          Like -name but testing the leaf name of the file source on
+          disk.  Can be true only for data files which stem not from
+          the loaded image.
     -type type_letter :
           Matches files of the given type: "block", "char", "dir",
           "pipe", "file", "link", "socket", "eltorito", "Xotic" which
@@ -1355,6 +1376,10 @@ File: xorriso.info,  Node: CmdFind,  Next: Filter,  Prev: Manip,  Up: Options
           Matches data files which have MD5 checksums.
     -has_filter :
           Matches files which are filtered by -set_filter.
+    -hidden hide_state :
+          Matches files which are hidden in "iso_rr" tree, in "joliet"
+          tree, in both trees ("on"), or not hidden in any tree ("off").
+          Those which are hidden in some tree match -not -hidden "off".
     -prune :
           If this test is reached and the tested file is a directory
           then -find will not dive into that directory. This test
@@ -1493,6 +1518,11 @@ File: xorriso.info,  Node: CmdFind,  Next: Filter,  Prev: Manip,  Up: Options
           E.g.: -exec sort_weight 3 --
     show_stream
           shows the content stream chain of a data file.
+    hide
+          brings the file into one of the hide states "on", "iso_rr",
+          "joliet", "off".
+          E.g.:
+          -find / -disk_name *_secret -exec hide on
     find
           performs another run of -find on the matching file address.
           It accepts the same params as -find, except iso_rr_path.
@@ -1760,6 +1790,9 @@ will be written according to the setting of option -acl.
      "aaip_susp_1_10_off".
      "aaip_susp_1_10" allows AAIP to be written as unofficial extension
      of RRIP rather than as official extension under SUSP-1.12.
+     "no_emul_toc" saves 64 kB with the first session on overwriteable
+     media but makes the image incapable of displaying its session
+     history.
      Default setting is
      "clear:only_iso_version:deep_paths:long_paths:no_j_force_dots:
      always_gmt:old_rr".
@@ -1801,6 +1834,9 @@ will be written according to the setting of option -acl.
      This may identify the specification of how the data are recorded.
      Permissible are up to 128 characters. This setting gets overridden
      by image loading.
+     The special text "@xorriso@" gets converted to the id string of
+     xorriso which is normally written as -preparer_id. It is a wrong
+     tradition to write the program id as -application_id.
 
 -system_id text
      Set the system id string to be written with the next -commit. This
@@ -1820,7 +1856,7 @@ will be written according to the setting of option -acl.
      literally.  It must consist of 16 decimal digits which form
      YYYYMMDDhhmmsscc, with YYYY between 1970 and 2999. Time zone is
      GMT.  It is supposed to match this GRUB line:
-     search -fs-uuid -set YYYY-MM-DD-hh-mm-ss-cc
+     search --fs-uuid --set YYYY-MM-DD-hh-mm-ss-cc
      E.g. 2010040711405800 is 7 Apr 2010 11:40:58 (+0 centiseconds).
      Timestrings for the other types may be given as with option
      -alter_date.  They are prone to timezone computations. The
@@ -1828,6 +1864,37 @@ will be written according to the setting of option -acl.
      and "m" will show the current time of image creation. "x" and "f"
      will be marked as insignificant.  "uuid" will be deactivated.
 
+-copyright_file text
+     Set the copyright file name to be written with the next -commit.
+     This should be the ISO 9660 path of a file in the image which
+     contains a copyright statement.  Permissible are up to 37
+     characters. This setting gets overridden by image loading.
+
+-abstract_file text
+     Set the abstract file name to be written with the next -commit.
+     This should be the ISO 9660 path of a file in the image which
+     contains an abstract statement about the image content.
+     Permissible are up to 37 characters. This setting gets overridden
+     by image loading.
+
+-biblio_file text
+     Set the biblio file name to be written with the next -commit. This
+     should be the ISO 9660 path of a file in the image which contains
+     bibliographic records.  Permissible are up to 37 characters. This
+     setting gets overridden by image loading.
+
+-preparer_id
+     Set the preparer id string to be written with the next -commit.
+     This may identify the person or other entity which controls the
+     preparation of the data which shall be recorded. Normally this
+     should be the id of xorriso and not of the person or program which
+     operates xorriso. Please avoid to change it.  Permissible are up
+     to 128 characters.
+     The special text "@xorriso@" gets converted to the id string of
+     xorriso which is default at program startup.
+     Unlike other id strings, this setting is not influenced by image
+     loading.
+
 -out_charset character_set_name
      Set the character set to which file names get converted when
      writing an image. See paragraph "Character sets" for more
@@ -1991,17 +2058,25 @@ of the existing sessions, unless one can assume overwriteable media.
      -boot_image isolinux cat_path=/boot/isolinux/boot.cat
      -boot_image isolinux load_size=2048
      -boot_image any boot_info_table=on
-     *bin_path=* depicts the boot image file, a binary program which is
-     to be started by the hardware boot facility (e.g. the BIOS) at
-     boot time.
-     *efi_path=* depicts a boot image file that is ready for EFI
-     booting.  Its load_size is determined automatically, no boot info
-     table gets written, platform_id is 0xef.
      An El Torito boot catalog file gets inserted into the ISO image
      with address *cat_path=* at -commit time.  It is subject to normal
      -overwrite and -reassure processing if there is already a file
      with the same name.  The catalog lists the boot images and is read
-     by the boot facility to choose one of the boot images.
+     by the boot facility to choose one of the boot images. But it is
+     not necessary that it appears in the directory tree at all. One
+     may hide it in all trees by *cat_hidden=on*.  Other possible
+     values are "iso_rr", "joliet", and the default "off".
+     *bin_path=* depicts a boot image file, a binary program which is
+     to be started by the hardware boot facility (e.g. the BIOS) at
+     boot time.
+     *efi_path=* depicts a boot image file that is ready for EFI
+     booting.  Its load_size is determined automatically, no boot info
+     table gets written, no boot media gets emulated, platform_id is
+     0xef.
+     *emul_type=* can be one of "no_emulation", "hard_disk", "diskette".
+     It controls the boot media emulation code of a boot image.  The
+     default "no_emulation" is suitable for ISOLINUX, GRUB, FreeBSD
+     cdboot.
      *load_size=* is a value which depends on the boot image.  Default
      2048 should be overridden only if a better value is known.
      *boot_info_table=on* may be used to apply patching to a boot image
@@ -2054,6 +2129,20 @@ of the existing sessions, unless one can assume overwriteable media.
      when the new System Area is written.
      Special "system_area=/dev/zero" causes 32k of NUL-bytes.  Use this
      to discard an MBR which eventually was loaded with the ISO image.
+     *partition_offset=*2kb_block_adr causes a partition table with a
+     single partition that begins at the given block address. This is
+     counted in 2048 byte blocks, not in 512 byte blocks. If the block
+     address is non-zero then it must be at least 16. A non-zero
+     partition offset causes two superblocks to be generated and two
+     sets of directory trees. The image is then mountable from its
+     absolute start as well as from the partition start.
+     The offset value of an ISO image gets preserved when a new session
+     is added.  So the value defined here is only in effect if a new
+     ISO image gets written.
+     *partition_sec_hd=*number gives the number of sectors per head for
+     partition offset. 0 chooses a default value.
+     *partition_hd_cyl=*number gives the number of heads per cylinder
+     for partition offset. 0 chooses a default value.
 
 
 File: xorriso.info,  Node: Charset,  Next: Exception,  Prev: Bootable,  Up: Options
@@ -2326,9 +2415,9 @@ File: xorriso.info,  Node: Inquiry,  Next: Navigate,  Prev: DialogCtl,  Up: Opti
 
 -pvd_info
      Print various id strings which can be found in loaded ISO images.
-     Some of them may be changed by options -volid, -publisher,
-     -application_id. For these ids -pvd_info reports what would be
-     written with the next -commit.
+     Some of them may be changed by options like -volid or -publisher.
+     For these ids -pvd_info reports what would be written with the
+     next -commit.
 
 
 File: xorriso.info,  Node: Navigate,  Next: Verify,  Prev: Inquiry,  Up: Options
@@ -2370,6 +2459,10 @@ File: xorriso.info,  Node: Navigate,  Next: Verify,  Prev: Inquiry,  Up: Options
 -lsl iso_rr_pattern [***]
      Like -ls but also list some of the file attributes.  The output
      format resembles shell command ls -ln.
+     If the file has non-trivial ACL, then a '+' is appended to the
+     permission info.  If the file is hidden, then 'I' for "iso_rr",
+     'J' for "joliet", resp. 'H' for "on" gets appended. Together with
+     ACL it is 'i', 'j', resp. 'h'.
 
 -lsdl iso_rr_pattern [***]
      Like -lsd but also list some of the file attributes.  The output
@@ -2810,13 +2903,14 @@ programs trigger comparable actions.
 
      Personality "*mkisofs*" accepts the options listed with:
      -as mkisofs -help --
-     Among them: -R (always on), -r, -J, -o, -M, -C, -path-list, -m,
-     -exclude-list, -f, -print-size, -pad, -no-pad, -V, -v, -version,
-     -graft-points, -z, -no-emul-boot, -b, -c, -boot-info-table,
-     -boot-load-size, -input-charset, -G, -output-charset, pathspecs as
-     with xorriso -add.  A lot of options are not supported and lead to
-     failure of the mkisofs emulation. Some are ignored, but better do
-     not rely on this tolerance.
+     Among them: -R (always on), -r, -J, -o, -M, -C, -dir-mode,
+     -file-mode, -path-list, -m, -exclude-list, -f, -print-size, -pad,
+     -no-pad, -V, -v, -version, -graft-points, -z, -no-emul-boot, -b,
+     -c, -boot-info-table, -boot-load-size, -input-charset, -G,
+     -output-charset, -U, -hide, -hide-joliet, -hide-list,
+     -hide-joliet-list, file paths and pathspecs.  A lot of options are
+     not supported and lead to failure of the mkisofs emulation. Some
+     are ignored, but better do not rely on this tolerance.
      -graft-points is equivalent to -pathspecs on. Note that pathspecs
      without "=" are interpreted differently than with xorriso option
      -add. Directories get merged with the root directory of the ISO
@@ -2841,7 +2935,7 @@ programs trigger comparable actions.
      , --acl , --xattr , --md5 , --stdio_sync .  They work like the
      xorriso options with the same name and hardcoded argument "on",
      e.g. -acl "on".  Explicit arguments are expected by --stdio_sync
-     and --scdbackup_tag.
+     and --scdbackup_tag.  --no-emul-toc is -compliance no_emul_toc.
      --sort-weight gets as arguments a number and an iso_rr_path.  The
      number becomes the LBA sorting weight of regular file iso_rr_path
      or of all regular files underneath directory iso_rr_path.  (See
@@ -2849,20 +2943,25 @@ programs trigger comparable actions.
      Adopted from grub-mkisofs are --protective-msdos-label (see
      -boot_image grub partition_table=on) and
      --modification-date=YYYYMMDDhhmmsscc (see -volume_date uuid). For
-     EFI bootable GRUB boot images use -efi-boot.  It performs
-     -boot_image grub efi_path= surrounded by two -boot_image any next.
+     EFI bootable GRUB boot images use --efi-boot.  It performs
+     -boot_image grub efi_path= surrounded by two -boot_image "any"
+     "next".  Alternative option -e from Fedora genisoimage sets
+     bin_path and platform_id for EFI, but performs no "next".
      For MBR bootable ISOLINUX images there is -isohybrid-mbr FILE,
      where FILE is one of the Syslinux files mbr/isohdp[fp]x*.bin . Use
      this instead of -G to apply the effect of -boot_image isolinux
      partition_table=on.
+     --boot-catalog-hide is -boot_image any cat_hidden=on.
+     -partition_offset number is -boot_image any
+     partition_offset=number.
      Personalites "*xorrisofs*", "*genisoimage*", and "*genisofs*" are
      aliases for "mkisofs".
      If xorriso is started with one of the leafnames "xorrisofs",
-     "genisofs", "mkisofs", or "genisoimage", then it automatically
-     prepends -as "genisofs" to the command line arguments. I.e. all
-     arguments will be interpreted mkisofs style until "--" is
-     encountered.  From then on, options are interpreted as xorriso
-     options.
+     "genisofs", "mkisofs", or "genisoimage", then it performs
+     -read_mkisofsrc and prepends -as "genisofs" to the command line
+     arguments.  I.e. all arguments will be interpreted mkisofs style
+     until "--" is encountered.  From then on, options are interpreted
+     as xorriso options.
 
      Personality "*cdrecord*" accepts the options listed with:
      -as cdrecord -help --
@@ -2896,6 +2995,18 @@ programs trigger comparable actions.
      an eventual commit happens.  From then on, options are interpreted
      as xorriso options.
 
+-read_mkisofsrc
+     Try one by one to open for reading:  ./.mkisofsrc , $MKISOFSRC ,
+     $HOME/.mkisofsrc , $(dirname $0)/.mkisofsrc
+     On success interpret the file content as of man mkisofs
+     CONFIGURATION, and end this command. Do not try further files.
+     The last address is used only if start argument 0 has a
+     non-trivial dirname.
+     The reader currently interprets the following NAME=VALUE pairs:
+     APPI (-application_id) , PUBL (-publisher) , SYSI (-system_id) ,
+     VOLI (-volid) , VOLS (-volset_id)
+     Any other lines will be silently ignored.
+
 -pacifier behavior_code
      Control behavior of UPDATE pacifiers during write operations.  The
      following behavior codes are defined:
@@ -3114,8 +3225,10 @@ File: xorriso.info,  Node: ExDevices,  Next: ExCreate,  Prev: Frontend,  Up: Exa
 10.1 As superuser learn about available drives
 ==============================================
 
-Consider to give rw permissions to those users or groups which shall be
-able to use the drives with xorriso.
+On Linux or FreeBSD consider to give rw-permissions to those users or
+groups which shall be able to use the drives with xorriso.  On Solaris
+use pfexec. Consider to restrict privileges of xorriso to
+"base,sys_devices" and to give r-permission to user or group.
 
 $ xorriso -devices
 0  -dev '/dev/sr0' rwrw-- :  '_NEC    ' 'DVD_RW ND-4570A'
@@ -3564,6 +3677,9 @@ $HOME/.xorrisorc
 
 The files are read in the sequence given above, but none of them is
 required to exist.
+If mkisofs emulation was enabled by program name "xorrisofs", "mkisofs",
+"genisoimage", or "genisofs", then afterwards -read_mkisofsrc is
+performed, which reads .mkisofsrc files. See there.
 
 11.3 Runtime control files
 ==========================
@@ -3611,7 +3727,7 @@ for libburnia-project.org
 ==============
 
 Copyright (c) 2007 - 2010 Thomas Schmitt
-Permission is granted to distrubute this text freely. It shall only be
+Permission is granted to distribute this text freely. 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 then you are
 entitled to modify this text under that same license.
@@ -3637,20 +3753,22 @@ File: xorriso.info,  Node: CommandIdx,  Next: ConceptIdx,  Prev: Legal,  Up: Top
 
 * #   starts a comment line:             Scripting.           (line 128)
 * -abort_on   controls abort on error:   Exception.           (line  27)
-* -acl   controls handling of ACLs:      Loading.             (line 128)
+* -abstract_file   sets abstract file name: SetWrite.         (line 131)
+* -acl   controls handling of ACLs:      Loading.             (line 123)
 * -add   inserts one or more paths:      Insert.              (line  42)
 * -add_plainly   inserts one or more paths: Insert.           (line  61)
 * -alter_date   sets timestamps in ISO image: Manip.          (line 146)
 * -alter_date_r   sets timestamps in ISO image: Manip.        (line 166)
-* -application_id   sets application id: SetWrite.            (line  87)
+* -application_id   sets application id: SetWrite.            (line  90)
 * -as   emulates mkisofs or cdrecord:    Emulation.           (line  13)
 * -assert_volid   rejects undesired images: Loading.          (line  65)
 * -auto_charset   learns character set from image: Loading.   (line  80)
 * -backslash_codes   enables backslash conversion: Scripting. (line  45)
-* -ban_stdio_write   demands real drive: Loading.             (line 225)
+* -ban_stdio_write   demands real drive: Loading.             (line 220)
+* -biblio_file   sets biblio file name:  SetWrite.            (line 138)
 * -blank   erases media:                 Writing.             (line  45)
 * -boot_image   controls bootability:    Bootable.            (line  20)
-* -calm_drive   reduces drive activity:  Loading.             (line 214)
+* -calm_drive   reduces drive activity:  Loading.             (line 209)
 * -cd   sets working directory in ISO:   Navigate.            (line   7)
 * -cdx   sets working directory on disk: Navigate.            (line  16)
 * -charset   sets input/output character set: Charset.        (line  43)
@@ -3664,14 +3782,15 @@ File: xorriso.info,  Node: CommandIdx,  Next: ConceptIdx,  Prev: Legal,  Up: Top
 * -chmod_r   sets permissions in ISO image: Manip.            (line  70)
 * -chown   sets ownership in ISO image:  Manip.               (line  42)
 * -chown_r   sets ownership in ISO image: Manip.              (line  47)
-* -close   controls media closing:       SetWrite.            (line 196)
+* -close   controls media closing:       SetWrite.            (line 233)
 * -close_filter_list   bans filter registration: Filter.      (line  52)
 * -commit   writes pending ISO image:    Writing.             (line  13)
 * -commit_eject    writes and ejects:    Writing.             (line  40)
-* -compare   reports ISO/disk differences: Navigate.          (line 130)
-* -compare_l   reports ISO/disk differences: Navigate.        (line 148)
-* -compare_r   reports ISO/disk differences: Navigate.        (line 143)
+* -compare   reports ISO/disk differences: Navigate.          (line 134)
+* -compare_l   reports ISO/disk differences: Navigate.        (line 152)
+* -compare_r   reports ISO/disk differences: Navigate.        (line 147)
 * -compliance   controls standard compliance: SetWrite.       (line  14)
+* -copyright_file   sets copyright file name: SetWrite.       (line 125)
 * -cp_rx   copies file trees to disk:    Restore.             (line 104)
 * -cpax   copies files to disk:          Restore.             (line 100)
 * -cpr   inserts like with cp -r:        Insert.              (line 152)
@@ -3680,15 +3799,15 @@ File: xorriso.info,  Node: CommandIdx,  Next: ConceptIdx,  Prev: Legal,  Up: Top
 * -dev   aquires one drive for input and output: AqDrive.     (line  10)
 * -devices   gets list of drives:        Inquiry.             (line   7)
 * -dialog   enables dialog mode:         DialogCtl.           (line   7)
-* -disk_dev_ino   fast incremental backup: Loading.           (line 168)
+* -disk_dev_ino   fast incremental backup: Loading.           (line 163)
 * -disk_pattern   controls pattern expansion: Insert.         (line  31)
 * -drive_class   controls drive accessability: Loading.       (line  35)
-* -du   show directory size in ISO image: Navigate.           (line  84)
-* -dummy   controls write simulation:    SetWrite.            (line 185)
-* -dus   show directory size in ISO image: Navigate.          (line  88)
-* -dusx   show directory size on disk:   Navigate.            (line  97)
-* -dux   show directory size on disk:    Navigate.            (line  92)
-* -dvd_obs   set write block size:       SetWrite.            (line 172)
+* -du   show directory size in ISO image: Navigate.           (line  88)
+* -dummy   controls write simulation:    SetWrite.            (line 222)
+* -dus   show directory size in ISO image: Navigate.          (line  92)
+* -dusx   show directory size on disk:   Navigate.            (line 101)
+* -dux   show directory size on disk:    Navigate.            (line  96)
+* -dvd_obs   set write block size:       SetWrite.            (line 209)
 * -eject    ejects drive tray:           Writing.             (line  36)
 * -end   writes pending session and ends program: Scripting.  (line 122)
 * -errfile_log   logs problematic disk files: Scripting.      (line  84)
@@ -3701,19 +3820,20 @@ File: xorriso.info,  Node: CommandIdx,  Next: ConceptIdx,  Prev: Legal,  Up: Top
 * -extract_single   copies file to disk: Restore.             (line  68)
 * -file_size_limit   limits data file size: SetInsert.        (line   7)
 * -find   traverses and alters ISO tree: CmdFind.             (line   7)
-* -findx   traverses disk tree:          Navigate.            (line 101)
+* -findx   traverses disk tree:          Navigate.            (line 105)
 * -follow   softlinks and mount points:  SetInsert.           (line  76)
-* -for_backup    -acl,-xattr,-hardlinks,-md5: Loading.        (line 163)
+* -for_backup    -acl,-xattr,-hardlinks,-md5: Loading.        (line 158)
 * -format   formats media:               Writing.             (line  69)
-* -fs   sets size of fifo:               SetWrite.            (line 189)
-* -getfacl   shows ACL in ISO image:     Navigate.            (line  65)
-* -getfacl_r   shows ACL in ISO image:   Navigate.            (line  72)
-* -getfattr   shows xattr in ISO image:  Navigate.            (line  76)
-* -getfattr_r   shows xattr in ISO image: Navigate.           (line  80)
-* -gid   sets global ownership:          SetWrite.            (line 129)
+* -fs   sets size of fifo:               SetWrite.            (line 226)
+* -getfacl   shows ACL in ISO image:     Navigate.            (line  69)
+* -getfacl_r   shows ACL in ISO image:   Navigate.            (line  76)
+* -getfattr   shows xattr in ISO image:  Navigate.            (line  80)
+* -getfattr_r   shows xattr in ISO image: Navigate.           (line  84)
+* -gid   sets global ownership:          SetWrite.            (line 166)
 * -grow_blindly   overides next writeable address: AqDrive.   (line  44)
 * -hardlinks   controls handling of hard links: Loading.      (line  91)
 * -help   prints help text:              Scripting.           (line  16)
+* -hide   excludes file names from directory trees: Manip.    (line 170)
 * -history   brings text into readline history: Scripting.    (line  22)
 * -in_charset   sets input character set: Loading.            (line  73)
 * -indev   aquires a drive for input:    AqDrive.             (line  22)
@@ -3727,17 +3847,17 @@ File: xorriso.info,  Node: CommandIdx,  Next: ConceptIdx,  Prev: Legal,  Up: Top
 * -logfile   logs output channels to file: Frontend.          (line  20)
 * -ls   lists files in ISO image:        Navigate.            (line  26)
 * -lsd   lists files in ISO image:       Navigate.            (line  34)
-* -lsdl   lists files in ISO image:      Navigate.            (line  42)
-* -lsdlx   lists files on disk:          Navigate.            (line  61)
-* -lsdx   lists files on disk:           Navigate.            (line  53)
+* -lsdl   lists files in ISO image:      Navigate.            (line  46)
+* -lsdlx   lists files on disk:          Navigate.            (line  65)
+* -lsdx   lists files on disk:           Navigate.            (line  57)
 * -lsl   lists files in ISO image:       Navigate.            (line  38)
-* -lslx   lists files on disk:           Navigate.            (line  57)
-* -lsx   lists files on disk:            Navigate.            (line  46)
+* -lslx   lists files on disk:           Navigate.            (line  61)
+* -lsx   lists files on disk:            Navigate.            (line  50)
 * -map   inserts path:                   Insert.              (line  85)
 * -map_l   inserts paths from disk file: Insert.              (line  94)
 * -map_single   inserts path:            Insert.              (line  90)
 * -mark   sets synchronizing message:    Frontend.            (line  25)
-* -md5   controls handling of MD5 sums:  Loading.             (line 141)
+* -md5   controls handling of MD5 sums:  Loading.             (line 136)
 * -mkdir   creates ISO directory:        Insert.              (line 166)
 * -mount   issues mount command for ISO session: Restore.     (line 122)
 * -mount_cmd   composes mount command line: Inquiry.          (line  31)
@@ -3750,27 +3870,30 @@ File: xorriso.info,  Node: CommandIdx,  Next: ConceptIdx,  Prev: Legal,  Up: Top
 * -not_paths   sets absolute exclusion paths: SetInsert.      (line  55)
 * -options_from_file   reads commands from file: Scripting.   (line  12)
 * -osirrox   enables ISO-to-disk copying: Restore.            (line  18)
-* -out_charset   sets output character set: SetWrite.         (line 119)
+* -out_charset   sets output character set: SetWrite.         (line 156)
 * -outdev   aquires a drive for output:  AqDrive.             (line  29)
 * -overwrite   enables overwriting in ISO: SetInsert.         (line 127)
-* -pacifier   controls pacifier text form: Emulation.         (line 105)
-* -padding   sets amount of image padding: SetWrite.          (line 202)
+* -pacifier   controls pacifier text form: Emulation.         (line 123)
+* -padding   sets amount of image padding: SetWrite.          (line 239)
 * -page   set terminal geometry:         DialogCtl.           (line  15)
 * -paste_in   copies file into disk file: Restore.            (line 117)
 * -path_list   inserts paths from disk file: Insert.          (line  75)
 * -pathspecs   sets meaning of = with -add: SetInsert.        (line 118)
 * -pkt_output   consolidates text output: Frontend.           (line   7)
+* -preparer_id   sets preparer id:       SetWrite.            (line 144)
 * -print   prints text line:             Scripting.           (line  77)
 * -print_size   predicts image size:     Inquiry.             (line  69)
 * -prog   sets program name:             Frontend.            (line  29)
 * -prog_help   prints help text:         Frontend.            (line  32)
 * -prompt   prompts for enter key:       Scripting.           (line  80)
-* -publisher   sets publisher id:        SetWrite.            (line  81)
+* -publisher   sets publisher id:        SetWrite.            (line  84)
 * -pvd_info   shows image id strings:    Inquiry.             (line  78)
 * -pwd   tells working directory in ISO: Navigate.            (line  20)
 * -pwdx   tells working directory on disk: Navigate.          (line  23)
 * -quoted_not_list   sets exclusions:    SetInsert.           (line  72)
 * -quoted_path_list   inserts paths from disk file: Insert.   (line  80)
+* -read_mkisofsrc   searches and reads .mkisofsrc file: Emulation.
+                                                              (line 111)
 * -reassure   enables confirmation question: DialogCtl.       (line  28)
 * -report_about   controls verbosity:    Exception.           (line  55)
 * -return_with   controls exit value:    Exception.           (line  39)
@@ -3779,8 +3902,8 @@ File: xorriso.info,  Node: CommandIdx,  Next: ConceptIdx,  Prev: Legal,  Up: Top
 * -rmdir   deletes ISO directory:        Manip.               (line  32)
 * -rollback   discards pending changes:  Writing.             (line   9)
 * -rollback_end   ends program without writing: Scripting.    (line 125)
-* -rom_toc_scan   searches for sessions: Loading.             (line 189)
-* -scdbackup_tag   enables scdbackup checksum tag: Emulation. (line 115)
+* -rom_toc_scan   searches for sessions: Loading.             (line 184)
+* -scdbackup_tag   enables scdbackup checksum tag: Emulation. (line 133)
 * -scsi_log   reports SCSI commands:     Scripting.           (line 113)
 * -session_log   logs written sessions:  Scripting.           (line 104)
 * -session_string   composes session info line: Inquiry.      (line  56)
@@ -3792,29 +3915,29 @@ File: xorriso.info,  Node: CommandIdx,  Next: ConceptIdx,  Prev: Legal,  Up: Top
 * -setfattr   sets xattr in ISO image:   Manip.               (line 110)
 * -setfattr_list   sets xattr in ISO image: Manip.            (line 126)
 * -setfattr_r   sets xattr in ISO image: Manip.               (line 123)
-* -show_stream   shows data source and filters: Navigate.     (line 153)
-* -show_stream_r   shows data source and filters: Navigate.   (line 168)
-* -speed   set write speed:              SetWrite.            (line 145)
+* -show_stream   shows data source and filters: Navigate.     (line 157)
+* -show_stream_r   shows data source and filters: Navigate.   (line 172)
+* -speed   set write speed:              SetWrite.            (line 182)
 * -split_size   enables large file splitting: SetInsert.      (line 140)
 * -status   shows current settings:      Scripting.           (line  25)
 * -status_history_max   curbs -status history: Scripting.     (line  34)
-* -stdio_sync   controls stdio buffer:   SetWrite.            (line 179)
-* -stream_recording   controls defect management: SetWrite.   (line 160)
-* -system_id   sets system id:           SetWrite.            (line  93)
+* -stdio_sync   controls stdio buffer:   SetWrite.            (line 216)
+* -stream_recording   controls defect management: SetWrite.   (line 197)
+* -system_id   sets system id:           SetWrite.            (line  99)
 * -tell_media_space   reports free space: Inquiry.            (line  74)
 * -temp_mem_limit   curbs memory consumption: Scripting.      (line  70)
 * -toc   shows list of sessions:         Inquiry.             (line  18)
-* -uid   sets global ownership:          SetWrite.            (line 125)
+* -uid   sets global ownership:          SetWrite.            (line 162)
 * -update   inserts path if different:   Insert.              (line  99)
 * -update_l   inserts paths if different: Insert.             (line 121)
 * -update_r   inserts paths if different: Insert.             (line 110)
 * -use_readline   enables readline for dialog: DialogCtl.     (line  24)
 * -version   prints help text:           Scripting.           (line  19)
-* -volid   sets volume id:               SetWrite.            (line  57)
-* -volset_id   sets volume set id:       SetWrite.            (line  76)
-* -volume_date   sets volume timestamp:  SetWrite.            (line 100)
-* -xattr   controls handling of xattr (EA): Loading.          (line 136)
-* -zisofs   controls zisofs production:  SetWrite.            (line 133)
+* -volid   sets volume id:               SetWrite.            (line  60)
+* -volset_id   sets volume set id:       SetWrite.            (line  79)
+* -volume_date   sets volume timestamp:  SetWrite.            (line 106)
+* -xattr   controls handling of xattr (EA): Loading.          (line 131)
+* -zisofs   controls zisofs production:  SetWrite.            (line 170)
 
 
 File: xorriso.info,  Node: ConceptIdx,  Prev: CommandIdx,  Up: Top
@@ -3825,29 +3948,29 @@ File: xorriso.info,  Node: ConceptIdx,  Prev: CommandIdx,  Up: Top
 [index]
 * Menu:
 
-* ACL, _definiton:                       Extras.              (line  36)
-* ACL, control handling, -acl:           Loading.             (line 128)
+* ACL, _definiton:                       Extras.              (line  37)
+* ACL, control handling, -acl:           Loading.             (line 123)
 * ACL, set in ISO image, -setfacl:       Manip.               (line  73)
 * ACL, set in ISO image, -setfacl_list:  Manip.               (line 100)
 * ACL, set in ISO image, -setfacl_r:     Manip.               (line  97)
-* ACL, show in ISO image, -getfacl:      Navigate.            (line  65)
-* ACL, show in ISO image, -getfacl_r:    Navigate.            (line  72)
-* Appendable media, _definition:         Media.               (line  34)
+* ACL, show in ISO image, -getfacl:      Navigate.            (line  69)
+* ACL, show in ISO image, -getfacl_r:    Navigate.            (line  76)
+* Appendable media, _definition:         Media.               (line  38)
 * Backslash Interpretation, _definition: Processing.          (line  49)
-* Backup, enable fast incremental, -disk_dev_ino: Loading.    (line 168)
-* Backup, enable features, -for_backup:  Loading.             (line 163)
-* Backup, scdbackup checksum tag, -scdbackup: Emulation.      (line 115)
-* Blank media, _definition:              Media.               (line  25)
+* Backup, enable fast incremental, -disk_dev_ino: Loading.    (line 163)
+* Backup, enable features, -for_backup:  Loading.             (line 158)
+* Backup, scdbackup checksum tag, -scdbackup: Emulation.      (line 133)
+* Blank media, _definition:              Media.               (line  29)
 * Blind growing, _definition:            Methods.             (line  40)
 * Bootability, control, -boot_image:     Bootable.            (line  20)
-* cdrecord, Emulation:                   Emulation.           (line  72)
+* cdrecord, Emulation:                   Emulation.           (line  78)
 * Character Set, _definition:            Charset.             (line   6)
 * Character Set, for input, -in_charset: Loading.             (line  73)
 * Character Set, for input/output, -charset: Charset.         (line  43)
-* Character Set, for output, -out_charset: SetWrite.          (line 119)
+* Character Set, for output, -out_charset: SetWrite.          (line 156)
 * Character set, learn from image, -auto_charset: Loading.    (line  80)
 * Character Set, of terminal, -local_charset: Charset.        (line  47)
-* Closed media, _definition:             Media.               (line  39)
+* Closed media, _definition:             Media.               (line  43)
 * Comment, #:                            Scripting.           (line 128)
 * Create, new ISO image, _definiton:     Methods.             (line   6)
 * Delete, from ISO image, -rm:           Manip.               (line  21)
@@ -3863,45 +3986,51 @@ File: xorriso.info,  Node: ConceptIdx,  Prev: CommandIdx,  Up: Top
 * disk_path, _definition:                Insert.              (line   6)
 * Drive, _definiton:                     Drives.              (line   6)
 * Drive, accessability, -drive_class:    Loading.             (line  35)
-* Drive, demand real MMC, -ban_stdio_write: Loading.          (line 225)
+* Drive, demand real MMC, -ban_stdio_write: Loading.          (line 220)
 * Drive, eject tray, -eject:             Writing.             (line  36)
 * Drive, for input and output, -dev:     AqDrive.             (line  10)
 * Drive, for input, -indev:              AqDrive.             (line  22)
 * Drive, for output, -outdev:            AqDrive.             (line  29)
 * Drive, get drive list, -devices:       Inquiry.             (line   7)
 * Drive, list supported media, -list_profiles: Writing.       (line 119)
-* Drive, reduce activity, -calm_drive:   Loading.             (line 214)
+* Drive, reduce activity, -calm_drive:   Loading.             (line 209)
 * Drive, report SCSI commands, -scsi_log: Scripting.          (line 113)
 * Drive, write and eject, -commit_eject: Writing.             (line  40)
 * El Torito, _definiton:                 Extras.              (line  19)
 * Emulation, -as:                        Emulation.           (line  13)
-* Emulation, cdrecord, -as:              Emulation.           (line  72)
+* Emulation, .mkisofsrc, -read_mkisofsrc: Emulation.          (line 111)
+* Emulation, cdrecord, -as:              Emulation.           (line  78)
 * Emulation, mkisofs, -as:               Emulation.           (line  16)
-* Emulation, pacifier form, -pacifier:   Emulation.           (line 105)
+* Emulation, pacifier form, -pacifier:   Emulation.           (line 123)
 * Examples:                              Examples.            (line   6)
 * Filter, _definition:                   Filter.              (line   6)
 * Filter, apply to file tree, -set_filter_r: Filter.          (line  84)
 * Filter, apply to file, -set_filter:    Filter.              (line  59)
 * Filter, ban registration, -close_filter_list: Filter.       (line  52)
 * Filter, register, -external_filter:    Filter.              (line  20)
-* Filter, show chain, -show_stream:      Navigate.            (line 153)
-* Filter, show chains of tree, -show_stream_r: Navigate.      (line 168)
+* Filter, show chain, -show_stream:      Navigate.            (line 157)
+* Filter, show chains of tree, -show_stream_r: Navigate.      (line 172)
 * Filter, unregister, -unregister_filter: Filter.             (line  48)
-* Filter, zisofs parameters, -zisofs:    SetWrite.            (line 133)
-* Group, global in ISO image, -gid:      SetWrite.            (line 129)
+* Filter, zisofs parameters, -zisofs:    SetWrite.            (line 170)
+* Group, global in ISO image, -gid:      SetWrite.            (line 166)
 * Group, in ISO image, -chgrp:           Manip.               (line  50)
 * Group, in ISO image, -chgrp_r:         Manip.               (line  55)
 * Growing, _definition:                  Methods.             (line  19)
 * Hard links, control handling, -hardlinks: Loading.          (line  91)
+* hidden, set in ISO image, -hide:       Manip.               (line 170)
 * Image, _definition:                    Model.               (line   9)
 * Image, demand volume id, -assert_volid: Loading.            (line  65)
 * Image, discard pending changes, -rollback: Writing.         (line   9)
-* Image, set application id, -application_id: SetWrite.       (line  87)
-* Image, set publisher id, -publisher:   SetWrite.            (line  81)
-* Image, set system id, -system_id:      SetWrite.            (line  93)
-* Image, set volume id, -volid:          SetWrite.            (line  57)
-* Image, set volume set id, -volset_id:  SetWrite.            (line  76)
-* Image, set volume timestamp, -volume_date: SetWrite.        (line 100)
+* Image, set abstract file name, -abstract_file: SetWrite.    (line 131)
+* Image, set application id, -application_id: SetWrite.       (line  90)
+* Image, set biblio file name, -biblio_file: SetWrite.        (line 138)
+* Image, set copyright file name, -copyright_file: SetWrite.  (line 125)
+* Image, set preparer id, -preparer_id:  SetWrite.            (line 144)
+* Image, set publisher id, -publisher:   SetWrite.            (line  84)
+* Image, set system id, -system_id:      SetWrite.            (line  99)
+* Image, set volume id, -volid:          SetWrite.            (line  60)
+* Image, set volume set id, -volset_id:  SetWrite.            (line  79)
+* Image, set volume timestamp, -volume_date: SetWrite.        (line 106)
 * Image, show id strings, -pvd_info:     Inquiry.             (line  78)
 * Insert, enable overwriting, -overwrite: SetInsert.          (line 127)
 * Insert, file exclusion absolute, -not_paths: SetInsert.     (line  55)
@@ -3928,8 +4057,8 @@ File: xorriso.info,  Node: ConceptIdx,  Prev: CommandIdx,  Up: Top
 * iso_rr_path, _definition:              Insert.              (line   7)
 * List delimiter, _definiton:            Processing.          (line   8)
 * MBR, _definiton:                       Extras.              (line  26)
-* MBR, set, -boot_image system_area=:    Bootable.            (line 109)
-* MD5, control handling, -md5:           Loading.             (line 141)
+* MBR, set, -boot_image system_area=:    Bootable.            (line 117)
+* MD5, control handling, -md5:           Loading.             (line 136)
 * Media, erase, -blank:                  Writing.             (line  45)
 * Media, format, -format:                Writing.             (line  69)
 * Media, list formats, -list_formats:    Writing.             (line 107)
@@ -3937,28 +4066,29 @@ File: xorriso.info,  Node: ConceptIdx,  Prev: CommandIdx,  Up: Top
 * Modifying, _definition:                Methods.             (line  27)
 * Multi-session media, _definition:      Media.               (line   7)
 * Multi-session, _definition:            Model.               (line  18)
-* Navigate, directory size in ISO image, -du: Navigate.       (line  84)
-* Navigate, directory size in ISO image, -dus: Navigate.      (line  88)
-* Navigate, directory size in on disk, -dusx: Navigate.       (line  97)
-* Navigate, directory size in on disk, -dux: Navigate.        (line  92)
-* Navigate, list disk files, -lsdlx:     Navigate.            (line  61)
-* Navigate, list disk files, -lsdx:      Navigate.            (line  53)
-* Navigate, list disk files, -lslx:      Navigate.            (line  57)
-* Navigate, list disk files, -lsx:       Navigate.            (line  46)
+* Navigate, directory size in ISO image, -du: Navigate.       (line  88)
+* Navigate, directory size in ISO image, -dus: Navigate.      (line  92)
+* Navigate, directory size in on disk, -dusx: Navigate.       (line 101)
+* Navigate, directory size in on disk, -dux: Navigate.        (line  96)
+* Navigate, list disk files, -lsdlx:     Navigate.            (line  65)
+* Navigate, list disk files, -lsdx:      Navigate.            (line  57)
+* Navigate, list disk files, -lslx:      Navigate.            (line  61)
+* Navigate, list disk files, -lsx:       Navigate.            (line  50)
 * Navigate, list ISO files, -ls:         Navigate.            (line  26)
 * Navigate, list ISO files, -lsd:        Navigate.            (line  34)
-* Navigate, list ISO files, -lsdl:       Navigate.            (line  42)
+* Navigate, list ISO files, -lsdl:       Navigate.            (line  46)
 * Navigate, list ISO files, -lsl:        Navigate.            (line  38)
 * Navigate, set disk working directory, -cdx: Navigate.       (line  16)
 * Navigate, set ISO working directory, -cd: Navigate.         (line   7)
 * Navigate, tell disk working directory, -pwdx: Navigate.     (line  23)
 * Navigate, tell ISO working directory, -pwd: Navigate.       (line  20)
 * Next writeable address, -grow_blindly: AqDrive.             (line  44)
-* Overwriteable media, _definition:      Media.               (line  10)
-* Ownership, global in ISO image, -uid:  SetWrite.            (line 125)
+* Overwriteable media, _definition:      Media.               (line  14)
+* Ownership, global in ISO image, -uid:  SetWrite.            (line 162)
 * Ownership, in ISO image, -chown:       Manip.               (line  42)
 * Ownership, in ISO image, -chown_r:     Manip.               (line  47)
-* Partition table, _definiton:           Bootable.            (line 116)
+* Partition offset, _definiton:          Bootable.            (line 142)
+* Partition table, _definiton:           Bootable.            (line 124)
 * Pathspec, _definition:                 SetInsert.           (line 120)
 * Pattern expansion, _definition:        Processing.          (line  22)
 * Pattern expansion, for disk paths, -disk_pattern: Insert.   (line  31)
@@ -4009,43 +4139,43 @@ File: xorriso.info,  Node: ConceptIdx,  Prev: CommandIdx,  Up: Top
 * Session, mount command line, -mount_cmd: Inquiry.           (line  31)
 * Session, mount parameters, -mount_opts: Inquiry.            (line  47)
 * Session, select as input, -load:       Loading.             (line  11)
-* System area, _definiton:               Bootable.            (line 109)
-* Table-of-content, search sessions, -rom_toc_scan: Loading.  (line 189)
+* System area, _definiton:               Bootable.            (line 117)
+* Table-of-content, search sessions, -rom_toc_scan: Loading.  (line 184)
 * Table-of-content, show, -toc:          Inquiry.             (line  18)
 * Timestamps, set in ISO image, -alter_date: Manip.           (line 146)
 * Timestamps, set in ISO image, -alter_date_r: Manip.         (line 166)
-* Tree, disk, traverse, -findx:          Navigate.            (line 101)
+* Tree, disk, traverse, -findx:          Navigate.            (line 105)
 * Tree, ISO, traverse and alter, -find:  CmdFind.             (line   7)
 * Verify, check blocks, -check_media:    Verify.              (line  21)
-* Verify, compare ISO and disk file, -compare: Navigate.      (line 130)
-* Verify, compare ISO and disk tree, -compare_r: Navigate.    (line 143)
-* Verify, compare ISO and disk, -compare_l: Navigate.         (line 148)
+* Verify, compare ISO and disk file, -compare: Navigate.      (line 134)
+* Verify, compare ISO and disk tree, -compare_r: Navigate.    (line 147)
+* Verify, compare ISO and disk, -compare_l: Navigate.         (line 152)
 * Verify, file checksum, -check_md5:     Verify.              (line 144)
 * Verify, file tree checksums, -check_md5_r: Verify.          (line 160)
 * Verify, preset -check_media, -check_media_defaults: Verify. (line  40)
-* Write, block size, -dvd_obs:           SetWrite.            (line 172)
+* Write, block size, -dvd_obs:           SetWrite.            (line 209)
 * Write, bootability, -boot_image:       Bootable.            (line  20)
-* Write, buffer syncing, -stdio_sync:    SetWrite.            (line 179)
-* Write, close media, -close:            SetWrite.            (line 196)
+* Write, buffer syncing, -stdio_sync:    SetWrite.            (line 216)
+* Write, close media, -close:            SetWrite.            (line 233)
 * Write, compliance to specs, -compliance: SetWrite.          (line  14)
-* Write, defect management, -stream_recording: SetWrite.      (line 160)
+* Write, defect management, -stream_recording: SetWrite.      (line 197)
 * Write, enable Joliet, -joliet:         SetWrite.            (line  10)
-* Write, fifo size, -fs:                 SetWrite.            (line 189)
+* Write, fifo size, -fs:                 SetWrite.            (line 226)
 * Write, free space, -tell_media_space:  Inquiry.             (line  74)
 * Write, log problematic disk files, -errfile_log: Scripting. (line  84)
 * Write, log written sessions, -session_log: Scripting.       (line 104)
-* Write, padding image, -padding:        SetWrite.            (line 202)
+* Write, padding image, -padding:        SetWrite.            (line 239)
 * Write, pending ISO image, -commit:     Writing.             (line  13)
 * Write, predict image size, -print_size: Inquiry.            (line  69)
-* Write, set speed, -speed:              SetWrite.            (line 145)
-* Write, simulation, -dummy:             SetWrite.            (line 185)
-* xattr, _definiton:                     Extras.              (line  50)
-* xattr, control handling, -xattr:       Loading.             (line 136)
+* Write, set speed, -speed:              SetWrite.            (line 182)
+* Write, simulation, -dummy:             SetWrite.            (line 222)
+* xattr, _definiton:                     Extras.              (line  51)
+* xattr, control handling, -xattr:       Loading.             (line 131)
 * xattr, set in ISO image, -setfattr:    Manip.               (line 110)
 * xattr, set in ISO image, -setfattr_list: Manip.             (line 126)
 * xattr, set in ISO image, -setfattr_r:  Manip.               (line 123)
-* xattr, show in ISO image, -getfattr:   Navigate.            (line  76)
-* xattr, show in ISO image, -getfattr_r: Navigate.            (line  80)
+* xattr, show in ISO image, -getfattr:   Navigate.            (line  80)
+* xattr, show in ISO image, -getfattr_r: Navigate.            (line  84)
 
 
 
@@ -4054,53 +4184,53 @@ Node: Top420
 Node: Overview1324
 Node: Model3209
 Node: Media6089
-Node: Methods8519
-Node: Drives11066
-Node: Extras14332
-Node: Processing17730
-Node: Dialog21226
-Node: Options22883
-Node: AqDrive24451
-Node: Loading27357
-Node: Insert39792
-Node: SetInsert48149
-Node: Manip56716
-Node: CmdFind64592
-Node: Filter73937
-Node: Writing78286
-Node: SetWrite84575
-Node: Bootable94707
-Node: Charset102455
-Node: Exception105209
-Node: DialogCtl109724
-Node: Inquiry112069
-Node: Navigate116209
-Node: Verify123563
-Node: Restore131983
-Node: Emulation138639
-Node: Scripting145465
-Node: Frontend151027
-Node: Examples152228
-Node: ExDevices153397
-Node: ExCreate153879
-Node: ExDialog155153
-Node: ExGrowing156415
-Node: ExModifying157217
-Node: ExBootable157718
-Node: ExCharset158265
-Node: ExPseudo159093
-Node: ExCdrecord159987
-Node: ExMkisofs160302
-Node: ExGrowisofs161305
-Node: ExException162429
-Node: ExTime162883
-Node: ExIncBackup163342
-Node: ExRestore166814
-Node: ExRecovery167783
-Node: Files168349
-Node: Seealso169387
-Node: Legal169911
-Node: CommandIdx170833
-Node: ConceptIdx184134
+Node: Methods8739
+Node: Drives11295
+Node: Extras14601
+Node: Processing18028
+Node: Dialog21524
+Node: Options23181
+Node: AqDrive24749
+Node: Loading27655
+Node: Insert39834
+Node: SetInsert48191
+Node: Manip56758
+Node: CmdFind65439
+Node: Filter75390
+Node: Writing79739
+Node: SetWrite86028
+Node: Bootable97979
+Node: Charset107071
+Node: Exception109825
+Node: DialogCtl114340
+Node: Inquiry116685
+Node: Navigate120815
+Node: Verify128413
+Node: Restore136833
+Node: Emulation143489
+Node: Scripting151292
+Node: Frontend156854
+Node: Examples158055
+Node: ExDevices159224
+Node: ExCreate159858
+Node: ExDialog161132
+Node: ExGrowing162394
+Node: ExModifying163196
+Node: ExBootable163697
+Node: ExCharset164244
+Node: ExPseudo165072
+Node: ExCdrecord165966
+Node: ExMkisofs166281
+Node: ExGrowisofs167284
+Node: ExException168408
+Node: ExTime168862
+Node: ExIncBackup169321
+Node: ExRestore172793
+Node: ExRecovery173762
+Node: Files174328
+Node: Seealso175556
+Node: Legal176080
+Node: CommandIdx177002
+Node: ConceptIdx190808
 
 End Tag Table

xorriso/xorriso.texi

@@ -19,7 +19,7 @@
 @c   The first line gets discarded.
 @c   Line start "@c man " will become "", the remainder is put out unaltered. 
 @c   Lines "@*" will be converted to ".br"
-@c   @c man-ignore-lines N  will discard N following lines.
+@c   "@c man-ignore-lines N"  will discard N following lines.
 @c   "@c man-ignore-lines begin" discards all following lines
 @c   up to "@c man-ignore-lines end".
 @c   Line blocks of "@menu" "@end menu" will be discarded.
@@ -44,7 +44,7 @@
 @c man .\" First parameter, NAME, should be all caps
 @c man .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
 @c man .\" other parameters are allowed: see man(7), man(1)
-@c man .TH XORRISO 1 "Apr 28, 2010"
+@c man .TH XORRISO 1 "Sep 10, 2010"
 @c man .\" Please adjust this date whenever revising the manpage.
 @c man .\"
 @c man .\" Some roff macros, for reference:
@@ -264,6 +264,10 @@ There are two families of media in the MMC standard:
 unformatted DVD-RW. These media provide a table of content which
 describes their existing sessions. See option @strong{-toc}.
 @*
+Similar to multi-session media are DVD-R DL and minimally blanked DVD-RW.
+They allow only a single session of which the size must be known in advance.
+xorriso will write onto them only if option -close is set to "on".
+@*
 @cindex Overwriteable media, _definition
 @strong{Overwriteable media} are DVD-RAM, DVD+RW, BD-RE, and formatted DVD-RW.
 They allow random write access but do not provide information about their
@@ -353,7 +357,7 @@ The write method of @strong{modifying} produces compact filesystem
 images with no outdated files or directory trees. Modifying can write its
 images to target media which are completely unsuitable for multi-session
 operations. E.g. DVD-RW which were treated with -blank deformat_quickest,
-named pipes, character devices, sockets.
+DVD-R DL, named pipes, character devices, sockets.
 On the other hand modified sessions cannot be written to appendable media
 but to blank media only.
 @*
@@ -410,6 +414,10 @@ On FreeBSD the device files have names like
 @*
   -dev /dev/cd0
 @*
+On OpenSolaris:
+@*
+  -dev /dev/rdsk/c4t0d0s2
+@*
 Get a list of accessible drives by command
 @*
   -devices
@@ -514,8 +522,9 @@ An @strong{MBR} contains boot code and a partition table. It does not hamper
 CDROM booting. The new MBR of a follow-up session can get in effect
 only on overwriteable media.
 @*
-Emulation -as mkisofs supports the example options out of the ISOLINUX wiki.
-It also supports the options used in GRUB script grub-mkrescue.
+Emulation -as mkisofs supports the example options out of the ISOLINUX wiki,
+the options used in GRUB script grub-mkrescue, and the example in the
+FreeBSD AvgLiveCD wiki.
 @*
 The support for other boot image types is sparse.
 @*
@@ -933,10 +942,11 @@ are both in effect. This restricts hard linking to other files restored by
 the same single extract command. -hardlinks "normal_extract" re-enables
 wide and expensive hardlink accumulation.
 @*
-Hardlink processing automatically enables @strong{-compliance new_rr}.
-This may be overridden by a following -compliance old_rr . In this case
-the resulting image will violate the RRIP-1.10 specs for entry PX in
-the same way as mkisofs does.
+@c B00613 : disabled because implemented faulty from beginning:
+@c Hardlink processing automatically enables @strong{-compliance new_rr}.
+@c This may be overridden by a following -compliance old_rr . In this case
+@c the resulting image will violate the RRIP-1.10 specs for entry PX in
+@c the same way as mkisofs does.
 @c man .TP
 @item -acl "on"|"off"
 @kindex -acl   controls handling of ACLs
@@ -1750,6 +1760,25 @@ where "A0" is year 2000, "B0" is 2010, etc.
 @kindex -alter_date_r   sets timestamps in ISO image
 @cindex Timestamps, set in ISO image, -alter_date_r
 Like -alter_date but affecting all files below eventual directories.
+@c man .TP
+@item -hide hide_state iso_rr_path [***]
+@kindex -hide   excludes file names from directory trees
+@cindex hidden, set in ISO image, -hide
+Prevent the names of the given files from showing up in the directory trees
+of ISO 9660 and/or Joliet when the image gets written.
+The eventual data content of such hidden files will be included in the
+resulting image, even if they do not show up in any directory.
+But you will need own means to find nameless data in the image.
+@*
+Warning: Data which are hidden from the ISO 9660 tree will not be copied
+by the write method of modifying.
+@*
+Possible values of hide_state are: "iso_rr" for hiding from ISO 9660 tree,
+"joliet" for Joliet tree, "on" for both trees. "off" means visibility in
+both directory trees.
+@*
+This command does not apply to the boot catalog.
+Rather use: -boot_image "any" "cat_hidden=on"
 @end table
 @c man .TP
 @c man .B Tree traversal command -find:
@@ -1784,6 +1813,10 @@ Matches if pattern matches the file leaf name.
 Matches if pattern matches the file path as it would be printed by action
 "echo". Character '/' is not special but can be matched by wildcards.
 @*
+@item -disk_name pattern :
+Like -name but testing the leaf name of the file source on disk.
+Can be true only for data files which stem not from the loaded image.
+@*
 @item -type type_letter :
 Matches files of the given type:
 "block", "char", "dir", "pipe", "file", "link", "socket", "eltorito",
@@ -1821,6 +1854,11 @@ Matches data files which have MD5 checksums.
 @item -has_filter :
 Matches files which are filtered by -set_filter.
 @*
+@item -hidden hide_state :
+Matches files which are hidden in "iso_rr" tree, in "joliet" tree,
+in both trees ("on"), or not hidden in any tree ("off").
+Those which are hidden in some tree match -not -hidden "off".
+@*
 @item -prune :
 If this test is reached and the tested file is a directory then -find will not
 dive into that directory. This test itself does always match. 
@@ -2013,6 +2051,13 @@ E.g.: -exec sort_weight 3 @minus{}@minus{}
 @item show_stream
 shows the content stream chain of a data file.
 @*
+@item hide
+brings the file into one of the hide states "on", "iso_rr", "joliet", "off".
+@*
+E.g.:
+@*
+  -find / -disk_name *_secret -exec hide on
+@*
 @item find
 performs another run of -find on the matching file address.
 It accepts the same params as -find, except iso_rr_path.
@@ -2364,6 +2409,9 @@ Default is "old_rr" which uses Rock Ridge version 1.10. This implies also
 "aaip_susp_1_10" allows AAIP to be written as unofficial extension of RRIP
 rather than as official extension under SUSP-1.12.
 @*
+"no_emul_toc" saves 64 kB with the first session on overwriteable media
+but makes the image incapable of displaying its session history.
+@*
 Default setting is
 @*
  "clear:only_iso_version:deep_paths:long_paths:no_j_force_dots:
@@ -2417,6 +2465,10 @@ Set the application id string to be written with the next -commit. This may
 identify the specification of how the data are recorded.
 Permissible are up to 128 characters. This setting gets overridden by
 image loading.
+@*
+The special text "@@xorriso@@" gets converted to the id string of xorriso
+which is normally written as -preparer_id. It is a wrong tradition to write
+the program id as -application_id.
 @c man .TP
 @item -system_id text
 @kindex -system_id   sets system id
@@ -2446,7 +2498,7 @@ It must consist of 16 decimal digits which form YYYYMMDDhhmmsscc, with
 YYYY between 1970 and 2999. Time zone is GMT.
 It is supposed to match this GRUB line:
 @*
- search --fs-uuid --set YYYY-MM-DD-hh-mm-ss-cc
+ search @minus{}@minus{}fs-uuid @minus{}@minus{}set YYYY-MM-DD-hh-mm-ss-cc
 @*
 E.g. 2010040711405800 is 7 Apr 2010 11:40:58 (+0 centiseconds).
 @*
@@ -2456,6 +2508,47 @@ They are prone to timezone computations. The timestrings "default" or
 of image creation. "x" and "f" will be marked as insignificant.
 "uuid" will be deactivated.
 @c man .TP
+@item -copyright_file text
+@kindex -copyright_file   sets copyright file name
+@cindex Image, set copyright file name, -copyright_file
+Set the copyright file name to be written with the next -commit. This should
+be the ISO 9660 path of a file in the image which contains a copyright
+statement.
+Permissible are up to 37 characters. This setting gets overridden by
+image loading.
+@c man .TP
+@item -abstract_file text
+@kindex -abstract_file   sets abstract file name
+@cindex Image, set abstract file name, -abstract_file
+Set the abstract file name to be written with the next -commit. This should
+be the ISO 9660 path of a file in the image which contains an abstract
+statement about the image content.
+Permissible are up to 37 characters. This setting gets overridden by
+image loading.
+@c man .TP
+@item -biblio_file text
+@kindex -biblio_file   sets biblio file name
+@cindex Image, set biblio file name, -biblio_file
+Set the biblio file name to be written with the next -commit. This should
+be the ISO 9660 path of a file in the image which contains bibliographic
+records.
+Permissible are up to 37 characters. This setting gets overridden by
+image loading.
+@c man .TP
+@item -preparer_id
+@kindex -preparer_id   sets preparer id
+@cindex Image, set preparer id, -preparer_id
+Set the preparer id string to be written with the next -commit. This may
+identify the person or other entity which controls the preparation of the data
+which shall be recorded. Normally this should be the id of xorriso and not
+of the person or program which operates xorriso. Please avoid to change it.
+Permissible are up to 128 characters.
+@*
+The special text "@@xorriso@@" gets converted to the id string of xorriso
+which is default at program startup.
+@*
+Unlike other id strings, this setting is not influenced by image loading.
+@c man .TP
 @item -out_charset character_set_name
 @kindex -out_charset   sets output character set
 @cindex Character Set, for output, -out_charset
@@ -2681,19 +2774,25 @@ which bundles these individual settings:
 @*
  -boot_image any boot_info_table=on
 @*
-@strong{bin_path=} depicts the boot image file, a binary program which is to be
-started by the hardware boot facility (e.g. the BIOS) at boot time.
-@*
-@strong{efi_path=} depicts a boot image file that is ready for EFI booting.
-Its load_size is determined automatically, no boot info table gets
-written, platform_id is 0xef.
-@*
 An El Torito boot catalog file gets inserted into the ISO image with address
 @strong{cat_path=} at -commit time.
 It is subject to normal -overwrite and -reassure processing if there is already
 a file with the same name.
 The catalog lists the boot images and is read by the boot facility to choose
-one of the boot images.
+one of the boot images. But it is not necessary that it appears in the
+directory tree at all. One may hide it in all trees by @strong{cat_hidden=on}.
+Other possible values are "iso_rr", "joliet", and the default "off".
+@*
+@strong{bin_path=} depicts a boot image file, a binary program which is to be
+started by the hardware boot facility (e.g. the BIOS) at boot time.
+@*
+@strong{efi_path=} depicts a boot image file that is ready for EFI booting.
+Its load_size is determined automatically, no boot info table gets
+written, no boot media gets emulated, platform_id is 0xef.
+@*
+@strong{emul_type=} can be one of "no_emulation", "hard_disk", "diskette".
+It controls the boot media emulation code of a boot image.
+The default "no_emulation" is suitable for ISOLINUX, GRUB, FreeBSD cdboot.
 @*
 @strong{load_size=} is a value which depends on the boot image.
 Default 2048 should be overridden only if a better value is known.
@@ -2762,6 +2861,23 @@ then those parameters get updated when the new System Area is written.
 Special "system_area=/dev/zero" causes 32k of NUL-bytes.
 Use this to discard an MBR which eventually was loaded with the ISO image.
 @*
+@cindex Partition offset, _definiton
+@strong{partition_offset=}2kb_block_adr causes a partition table with a single
+partition that begins at the given block address. This is counted in 2048 byte
+blocks, not in 512 byte blocks. If the block address is non-zero then it must
+be at least 16. A non-zero partition offset causes two superblocks to be
+generated and two sets of directory trees. The image is then mountable from its
+absolute start as well as from the partition start.
+@*
+The offset value of an ISO image gets preserved when a new session is added.
+So the value defined here is only in effect if a new ISO image gets written.
+@*
+@strong{partition_sec_hd=}number gives the number of sectors per head for
+partition offset. 0 chooses a default value.
+@*
+@strong{partition_hd_cyl=}number gives the number of heads per cylinder for
+partition offset. 0 chooses a default value.
+@*
 @end table
 @c man .TP
 @c man .B Character sets:
@@ -3131,7 +3247,7 @@ subtracting already foreseeable consumption by next -commit.
 @kindex -pvd_info   shows image id strings
 @cindex Image, show id strings, -pvd_info
 Print various id strings which can be found in loaded ISO images. Some of
-them may be changed by options -volid, -publisher, -application_id. For these
+them may be changed by options like -volid or -publisher. For these
 ids -pvd_info reports what would be written with the next -commit.
 @end table
 @c man .TP
@@ -3193,6 +3309,10 @@ This resembles shell command ls -d.
 @cindex Navigate, list ISO files, -lsl
 Like -ls but also list some of the file attributes. 
 The output format resembles shell command ls -ln.
+@*
+If the file has non-trivial ACL, then a '+' is appended to the permission info.
+If the file is hidden, then 'I' for "iso_rr", 'J' for "joliet", resp. 'H' for
+"on" gets appended. Together with ACL it is 'i', 'j', resp. 'h'.
 @c man .TP
 @item -lsdl iso_rr_pattern [***]
 @kindex -lsdl   lists files in ISO image
@@ -3760,10 +3880,12 @@ Personality "@strong{mkisofs}" accepts the options listed with:
 @*
   -as mkisofs -help @minus{}@minus{}
 @*
-Among them: -R (always on), -r, -J, -o, -M, -C, -path-list, -m, -exclude-list,
+Among them: -R (always on), -r, -J, -o, -M, -C, -dir-mode, -file-mode,
+-path-list, -m, -exclude-list,
 -f, -print-size, -pad, -no-pad, -V, -v, -version, -graft-points, -z,
 -no-emul-boot, -b, -c, -boot-info-table, -boot-load-size, -input-charset, -G,
--output-charset, pathspecs as with xorriso -add.
+-output-charset, -U, -hide, -hide-joliet, -hide-list, -hide-joliet-list,
+file paths and pathspecs.
 A lot of options are not supported and lead to failure of the mkisofs
 emulation. Some are ignored, but better do not rely on this tolerance.
 @*
@@ -3796,6 +3918,7 @@ They work like the xorriso options with the
 same name and hardcoded argument "on", e.g. -acl "on".
 Explicit arguments are expected by @minus{}@minus{}stdio_sync
 and @minus{}@minus{}scdbackup_tag.
+@minus{}@minus{}no-emul-toc is -compliance no_emul_toc.
 @*
 @minus{}@minus{}sort-weight gets as arguments a number and an iso_rr_path.
 The number becomes the LBA sorting weight of regular file iso_rr_path or
@@ -3805,22 +3928,31 @@ of all regular files underneath directory iso_rr_path.
 Adopted from grub-mkisofs are @minus{}@minus{}protective-msdos-label 
 (see -boot_image grub partition_table=on) and 
 @minus{}@minus{}modification-date=YYYYMMDDhhmmsscc
-(see -volume_date uuid). For EFI bootable GRUB boot images use --efi-boot.
-It performs -boot_image grub efi_path= surrounded by two -boot_image any next. 
+(see -volume_date uuid). For EFI bootable GRUB boot images use
+@minus{}@minus{}efi-boot.
+It performs @minus{}boot_image grub efi_path= surrounded by two
+@minus{}boot_image "any" "next". 
+Alternative option @minus{}e from Fedora genisoimage sets bin_path and
+platform_id for EFI, but performs no "next". 
 @*
 For MBR bootable ISOLINUX images there is -isohybrid-mbr FILE, where
 FILE is one of the Syslinux files mbr/isohdp[fp]x*.bin . Use this
 instead of -G to apply the effect of -boot_image isolinux partition_table=on.
 @*
+@minus{}@minus{}boot-catalog-hide is -boot_image any cat_hidden=on.
+@*
+@minus{}partition_offset number is
+@minus{}boot_image any partition_offset=number.
+@*
 Personalites "@strong{xorrisofs}", "@strong{genisoimage}",
 and "@strong{genisofs}" are aliases for "mkisofs".
 @*
 If xorriso is started with one of the leafnames "xorrisofs", "genisofs",
-"mkisofs", or "genisoimage", then it automatically prepends -as "genisofs"
-to the command line arguments. I.e. all arguments will be interpreted mkisofs
-style until "@minus{}@minus{}" is encountered.
-From then on, options are interpreted
-as xorriso options.
+"mkisofs", or "genisoimage", then it performs -read_mkisofsrc and prepends
+-as "genisofs" to the command line arguments.
+I.e. all arguments will be interpreted mkisofs style until "@minus{}@minus{}"
+is encountered. 
+From then on, options are interpreted as xorriso options.
 @*
 @sp 1
 
@@ -3868,6 +4000,22 @@ to the command line arguments. I.e. all arguments will be interpreted cdrecord
 style until "@minus{}@minus{}" is encountered and an eventual commit happens.
 From then on, options are interpreted as xorriso options.
 @c man .TP
+@item -read_mkisofsrc
+@kindex -read_mkisofsrc   searches and reads .mkisofsrc file
+@cindex Emulation, .mkisofsrc, -read_mkisofsrc
+Try one by one to open for reading:
+ ./.mkisofsrc , $MKISOFSRC , $HOME/.mkisofsrc , $(dirname $0)/.mkisofsrc 
+@*
+On success interpret the file content as of man mkisofs CONFIGURATION,
+and end this command. Do not try further files.
+The last address is used only if start argument 0 has a non-trivial dirname.
+@*
+The reader currently interprets the following NAME=VALUE pairs:
+APPI (-application_id) , PUBL (-publisher) , SYSI (-system_id) ,
+VOLI (-volid) , VOLS (-volset_id)
+@*
+Any other lines will be silently ignored.
+@c man .TP
 @item -pacifier behavior_code
 @kindex -pacifier   controls pacifier text form
 @cindex Emulation, pacifier form, -pacifier
@@ -4202,8 +4350,10 @@ Use text as name of this program and perform -help.
 @c man .B As superuser learn about available drives
 @node ExDevices, ExCreate, Frontend, Examples
 @section As superuser learn about available drives
-Consider to give rw permissions to those users or groups
+On Linux or FreeBSD consider to give rw-permissions to those users or groups
 which shall be able to use the drives with xorriso.
+On Solaris use pfexec. Consider to restrict privileges of xorriso to
+"base,sys_devices" and to give r-permission to user or group.
 @*
 @sp 1
 $ xorriso -devices
@@ -4811,6 +4961,10 @@ to read and execute lines from the following files:
 @sp 1
 The files are read in the sequence given above, but none of them is required
 to exist.
+@*
+If mkisofs emulation was enabled by program name "xorrisofs", "mkisofs",
+"genisoimage", or "genisofs", then afterwards -read_mkisofsrc is performed,
+which reads .mkisofsrc files. See there.
 @c man .SS
 @c man .B Runtime control files:
 @section Runtime control files
@@ -4882,7 +5036,7 @@ for libburnia-project.org
 @section Copyright
 Copyright (c) 2007 - 2010 Thomas Schmitt
 @*
-Permission is granted to distrubute this text freely. It shall only be
+Permission is granted to distribute this text freely. 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 then you are entitled
 to modify this text under that same license.

xorriso/xorriso_bootstrap.txt

@@ -0,0 +1,10 @@
+#!/bin/sh -x
+
+aclocal
+libtoolize --copy --force
+autoconf
+
+autoheader
+
+automake --foreign --add-missing --copy --include-deps
+

xorriso/xorriso_eng.html

@@ -2,7 +2,7 @@
 
 <HEAD>
 <META NAME="description" CONTENT="GNU xorriso, creates, loads, manipulates and writes ISO 9660 filesystem images with Rock Ridge extensions">
-<META NAME="keywords" CONTENT="xorriso, libburn, libburnia, burn, CD, DVD, ISO, ISO 9660, RockRidge, Rock Ridge, GNU/Linux, Linux, FreeBSD, recording, burning, CD-R, CD-RW, DVD-R, DVD-RW, DVD+RW, DVD+R, DVD+R DL, BD-RE, BD-R, scdbackup">
+<META NAME="keywords" CONTENT="xorriso, libburn, libburnia, burn, CD, DVD, ISO, ISO 9660, RockRidge, Rock Ridge, GNU/Linux, Linux, FreeBSD, Solaris, recording, burning, CD-R, CD-RW, DVD-R, DVD-RW, DVD+RW, DVD+R, DVD+R DL, BD-RE, BD-R, scdbackup">
 <META NAME="robots" CONTENT="follow">
 <TITLE>GNU xorriso - GNU Project - Free Software Foundation</TITLE>
 <LINK rev="made" href="mailto:webmasters@gnu.org">
@@ -15,7 +15,8 @@
 <P>
 <H1>GNU xorriso</H1>
 
-<H2>ISO 9660 Rock Ridge Filesystem Manipulator for GNU/Linux and FreeBSD</H2>
+<H2>ISO 9660 Rock Ridge Filesystem Manipulator<BR>
+for GNU/Linux, FreeBSD, Solaris</H2>
 </P>
 </CENTER>
 
@@ -43,7 +44,7 @@ About any CD, DVD, or BD recorder produced in the recent ten years.
 supports recorders which are compliant to standards MMC-1 for CD and
 MMC-5 for DVD or BD.
 <BR>
-GNU/Linux and FreeBSD allow to access drives connected
+GNU/Linux, FreeBSD, and Solaris allow to access drives connected
 via SCSI, PATA (aka IDE, ATA), USB, or SATA.
 <BR>
 xorriso also operates on ISO images in data files or block devices.
@@ -58,9 +59,11 @@ Images or add-on sessions may be written to about any kind of file object.
 <DD>With kernel 2.6 ide-scsi is not needed.</DD>
 <DT>or FreeBSD, libc, libpthread :</DT>
 <DD>PATA/IDE drives need atapicam running.</DD>
-<DD>SATA drives need atapicam or ahci running.</DD>
+<DD>SATA drives need atapicam running or need to be driven by ahci.</DD>
 <DD>libcam has to be installed.</DD>
 <DD>libiconv has to be installed.</DD>
+<DT>or Solaris, libc, libpthread :</DT>
+<DD>Tested on kernel 5.11, hopefully suitable for older ones too.</DD>
 <DT>or some other X/Open system, libc, libpthread :</DT>
 <DD>
 There will be no direct operation of optical drives, but only POSIX i/o
@@ -119,11 +122,11 @@ File content may get zisofs or gzip compressed or filtered by external
 processes.
 </LI>
 <LI>
-Writes result as completely new image or as add-on session
-to optical media or filesystem objects.
+Can activate ISOLINUX and GRUB boot images by El Torito boot record and MBR.
 </LI>
 <LI>
-Can activate ISOLINUX and GRUB boot images by El Torito boot record and MBR.
+Writes result as completely new image or as add-on session
+to optical media or filesystem objects.
 </LI>
 <LI>
 Can perform multi-session tasks as emulation of mkisofs and cdrecord.
@@ -139,7 +142,8 @@ Scans for optical drives, blanks re-useable optical media, formats media.
 </LI>
 <LI>
 Suitable for:
-CD-R, CD-RW, DVD-R, DVD-RW, DVD+R, DVD+R DL, DVD+RW, DVD-RAM, BD-R, BD-RE.
+CD-R, CD-RW, DVD-R, DVD-R DL, DVD-RW, DVD+R, DVD+R DL, DVD+RW, DVD-RAM,
+BD-R, BD-RE.
 </LI>
 <LI>
 Reads its instructions from command line arguments, dialog, and batch files.
@@ -436,19 +440,19 @@ files or trees to disk:
 <P>
 <DL>
 <DT><H3>Download as source code (see README):</H3></DT>
-<DD><A HREF="xorriso-0.5.6.tar.gz">xorriso-0.5.6.tar.gz</A>
-(1600 KB).
+<DD><A HREF="xorriso-0.6.2.tar.gz">xorriso-0.6.2.tar.gz</A>
+(1670 KB).
 </DD>
-<DD>(Released 19 Apr 2010)</DD>
-<DD><A HREF="xorriso-0.5.6.tar.gz.sig">xorriso-0.5.6.tar.gz.sig</A></DD>
+<DD>(Released 18 Sep 2010)</DD>
+<DD><A HREF="xorriso-0.6.2.tar.gz.sig">xorriso-0.6.2.tar.gz.sig</A></DD>
 <DD>
 (detached GPG signature for verification by
-<KBD>gpg --verify xorriso-0.5.6.tar.gz.sig xorriso-0.5.6.tar.gz</KBD>).
+<KBD>gpg --verify xorriso-0.6.2.tar.gz.sig xorriso-0.6.2.tar.gz</KBD>).
 </DD>
 <DD>
 Also on <A HREF="http://www.gnu.org/prep/ftp.html">
 mirrors of ftp://ftp.gnu.org/gnu/ </A>
-as xorriso/xorriso-0.5.6.tar.gz
+as xorriso/xorriso-0.6.2.tar.gz
 </DD>
 </DL>
 </DD>
@@ -476,9 +480,9 @@ as xorriso/xorriso-0.5.6.tar.gz
 <HR>
 
 <P>
-Bug fixes towards xorriso-0.5.4:
+Bug fixes towards xorriso-0.6.0:
 <UL>
-<LI>- none -</LI>
+<LI>Regression with -hardlinks and -compliance old_rr, 0.4.2, Aug 2009</LI>
 <!--
 <LI>- none -</LI>
 -->
@@ -496,17 +500,35 @@ Bug fixes in .pl01 towards xorriso-:
 -->
 
 <P>
-Enhancements towards previous stable version xorriso-0.5.4:
+Enhancements towards previous stable version xorriso-0.6.0:
 <UL>
+
 <LI>
-Allowing up to 32 boot images
+New option -preparer_id, -as mkisofs options -p and -preparer
 </LI>
 <LI>
-New -boot_image bootspecs efi_path=, platform_id=, sel_crit=, id_string=, next
+New -boot_image specifier emul_type=none|hard_disk|floppy
 </LI>
 <LI>
-New -as mkisofs options --efi-boot, -eltorito-alt-boot
+New boot_image boot specs partition_offset, partition_hd_cyl, partition_sec_hd
 </LI>
+<LI>
+Made behavior of -as mkisofs with unknown options more similar to original
+</LI>
+<LI>
+New -as mkisofs option -hard-disk-boot, enabled -b without -no-emul-boot
+</LI>
+<LI>
+New -as mkisofs option -e from Fedora genisoimage
+</LI>
+<LI>
+New -as mkisofs options -partition_offset,-partition_hd_cyl,-partition_sec_hd
+</LI>
+<LI>
+DVD-R DL are supported as single-session media.
+I.e. only with option -close "on".
+</LI>
+
 <!--
 <LI>- none -</LI>
 -->
@@ -529,18 +551,20 @@ libburnia project and the legal intentions of
 <A HREF="http://www.fsf.org/"> FSF </A> match completely.
 </DT>
 <DD>&nbsp;</DD>
-<DT>libburn-0.8.1</DT>
+<DT>libburn-0.8.7</DT>
 <DD>reads and writes data from and to CD, DVD, BD.</DD>
 <DD>(founded by Derek Foreman and Ben Jansens,
 developed and maintained since August 2006 by
 Thomas Schmitt from team of libburnia-project.org)</DD>
-<DT>libisofs-0.6.33</DT>
+<DT>libisofs-0.6.37</DT>
 <DD>operates on ISO 9660 filesystem images.</DD>
 <DD>(By Vreixo Formoso, Mario Danic and Thomas Schmitt
 from team of libburnia-project.org)</DD>
-<DT>libisoburn-0.5.6</DT>
+<DT>libisoburn-0.6.2</DT>
 <DD>coordinates libburn and libisofs, emulates multi-session where needed,
 and hosts the original source code of program xorriso.</DD>
+<DD>It provides the complete functionality of xorriso via
+a C language API.</DD>
 <DD>(By Vreixo Formoso and Thomas Schmitt
 from team of libburnia-project.org)</DD>
 <DD>&nbsp;</DD>
@@ -553,8 +577,8 @@ cdrecord and mkisofs.</DT>
 
 <P>
 <DL>
-<DT><H3>Development snapshot, version 0.5.7 :</H3></DT>
-<DD>Bug fixes towards xorriso-0.5.6:
+<DT><H3>Development snapshot, version 0.6.3 :</H3></DT>
+<DD>Bug fixes towards xorriso-0.6.2:
 <UL>
 <LI>- none yet -</LI>
 <!-- 
@@ -562,7 +586,7 @@ cdrecord and mkisofs.</DT>
  -->
 </UL>
 </DD>
-<DD>Enhancements towards stable version 0.5.6:
+<DD>Enhancements towards stable version 0.6.2:
 <UL>
 <LI>- none yet -</LI>
 <!-- 
@@ -571,9 +595,9 @@ cdrecord and mkisofs.</DT>
 </UL>
 </DD>
 <DD>&nbsp;</DD>
-<DD><A HREF="README_xorriso_devel">README 0.5.7</A>
-<DD><A HREF="xorriso_help_devel">xorriso_0.5.7 -help</A></DD>
-<DD><A HREF="man_1_xorriso_devel.html">man xorriso (as of 0.5.7)</A></DD>
+<DD><A HREF="README_xorriso_devel">README 0.6.3</A>
+<DD><A HREF="xorriso_help_devel">xorriso_0.6.3 -help</A></DD>
+<DD><A HREF="man_1_xorriso_devel.html">man xorriso (as of 0.6.3)</A></DD>
 <DD>&nbsp;</DD>
 <DT>If you want to distribute development versions of xorriso, then use
 this tarball which produces static linking between xorriso and the
@@ -583,8 +607,8 @@ libburnia libraries.
 installation see README)
 </DD>
 <DD>
-<A HREF="xorriso-0.5.7.tar.gz">xorriso-0.5.7.tar.gz</A>
-(1600 KB).
+<A HREF="xorriso-0.6.3.tar.gz">xorriso-0.6.3.tar.gz</A>
+(1670 KB).
 </DD>
 <DT>A dynamically linked development version of xorriso can be obtained
 from repositories of
@@ -608,8 +632,7 @@ versions for dynamic linking. Only release versions are safe for that.
 </KBD></DD>
 <DD>Install: <KBD><B>cd libisoburn ; ./bootstrap ; ./configure --prefix /usr ; make ; make install</B>
 </KBD></DD>
-<DT>Build of SVN versions needs <A HREF="http://sources.redhat.com/autobook/">
-autotools</A> of at least version 1.7 installed.
+<DT>Build of SVN versions needs of at least version 1.7 installed.
 But after the run of <KBD>./bootstrap</KBD>, only
 vanilla tools like make and gcc are needed.
 </DT>
@@ -629,10 +652,21 @@ with DVD media and how to emulate multi-session on overwriteable media.
 </P>
 <HR>
 
+<!-- The following links might lead to sites which do not comply
+     to the strict rules of FSF about non-free software.
+     GNU xorriso does not endorse or recommend any non-free software
+     which can be reached by them directly or indirectly. Nevertheless
+     outside of official GNU sites, GNU xorriso thanks the following
+     entities for their long standing support.
+-->
+<!-- Start not-www.gnu.org -->
+
 <P>
 <CENTER><FONT SIZE=+0>
-<FONT SIZE=+0>Enjoying free hosting by<BR>
-<A HREF="http://www.gnu.org">www.gnu.org</A><BR>
+<FONT SIZE=+0>
+<A HREF="http://www.gnu.org">Dedicated to the GNU Operating System</A><BR>
+
+Enjoying free hosting by<BR>
 <A HREF="http://www.webframe.org">www.webframe.org</A><BR>
 <A HREF="http://sourceforge.net">sourceforge.net</A><BR>
 
@@ -652,6 +686,9 @@ scdbackup, multi volume CD/DVD/BD backup</A></DD>
 <DL><DD><A HREF=http://scdbackup.sourceforge.net/main_eng.html> 
 (a second source of above)</A></DD></DL>
 </DL>
+
+<!-- End not-www.gnu.org -->
+
 <BR>
 Legal statement: This website does not serve any commercial purpose.
 <BR><BR>

xorriso/xorriso_main.c

@@ -0,0 +1,294 @@
+
+/* xorriso - Command line oriented batch and dialog tool which creates, loads,
+   manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2010 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Initial code of this program was derived from program src/askme.c out
+   of scdbackup-0.8.8, Copyright 2007 Thomas Schmitt, BSD-License.
+
+   Provided under GPL version 2 or later, with the announcement that this
+   might get changed in future. I would prefer BSD or LGPL as soon as the
+   license situation of the library code allows that.
+   (This announcement affects only future releases of xorriso and it will
+    always be possible to derive a GPLv2+ from the future license.)
+
+   There is a derived package "GNU xorriso" under GPLv3+ which combines the
+   libburnia libraries and program xorriso to a statically linked binary.
+
+
+   Overview of xorriso architecture:
+
+   libburn provides the ability to read and write data. 
+
+   libisofs interprets and manipulates ISO 9660 directory trees. It generates
+   the output stream which is handed over to libburn.
+
+   libisoburn by its lower level API encapsulates the connectivity issues
+   between libburn and libisofs. This API also enables multi-session emulation
+   on overwritable media and random access file objects.
+
+   xorriso is the higher level API of libisoburn which allows to operate all
+   three libraries by a unified set of commands. 
+   <libisoburn/xorriso.h> exposes the public functions.
+   Among these functions are direct equivalents of the xorriso interpreter
+   commands. There are also functions for fundamental management and for
+   handling event messages.
+
+   This file  xorriso_main.c  runs the xorriso API as batch and dialog program.
+
+   One should not mix the use of the xorriso API with the use of the lower
+   level APIs of libburn, libisofs, libisoburn.
+   
+   --------------------------------------------------------------------------
+   The following overview is relevant for development but not for usage of
+   xorriso. An application programmer should read xorriso.h and man xorriso
+   resp. info xorriso, rather than diving into its source code.
+   For examples see the functions main() and check_compatibility() below.
+   --------------------------------------------------------------------------
+
+   The xorriso source is divided in two groups:
+
+   A set of source modules interacts with the lower level library APIs:
+
+   base_obj.[ch]    fundamental operations of the XorrisO object
+   lib_mgt.[ch]     manages the relation between xorriso and the libraries
+   drive_mgt.[ch]   operates on drives and media
+   iso_img.[ch]     operates on ISO images and their global properties
+   iso_tree.[ch]    access nodes of the libisofs tree model
+   iso_manip.[ch]   manipulates the libisofs tree model
+   sort_cmp.[ch]    sorts and compare tree nodes
+   write_run.[ch]   functions to write sessions
+   read_run.[ch]    functions to read data from ISO image
+   filters.[ch]     operates on data filter objects
+   xorrisoburn.h    declarations needed by the non-library modules
+
+   Another set is independent of the lower level APIs:
+
+   parse_exec.c     deals with parsing and interpretation of command input
+   sfile.c          functions around files and strings
+   aux_objects.c    various helper classes
+   misc_funct.c     miscellaneous helper functions
+   findjob.c        performs tree searches in libisofs or in POSIX filesystem
+   check_media.c    perform verifying runs on media resp. images
+   text_io.c        text i/o functions
+   match.c          functions for pattern matching
+   emulators.c      emulators for mkisofs and cdrecord
+   disk_ops.c       actions on onjects of disk filesystems
+   cmp_update.c     compare or update files between disk filesystem and
+                    ISO filesystem
+   opts_a_c.c       options -a* to -c*
+   opts_d_h.c       options -d* to -h*
+   opts_i_o.c       options -i* to -o*
+   opts_p_z.c       options -p* to -z*
+
+   xorriso_private.h contains the definition of struct Xorriso and for
+   convenience includes the .h files of the non-library group.
+
+*/
+
+#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 <locale.h>
+
+
+/* xorriso_main.c includes the internal copy of the API definition */
+/* The official xorriso options API is defined in <libisoburn/xorriso.h> */
+#include "xorriso.h"
+
+
+/* The minimum version of libisoburn xorriso API to be used with this
+   version of xorriso.
+*/
+#define Xorriso_req_majoR  0
+#define Xorriso_req_minoR  6
+#define Xorriso_req_micrO  2
+
+
+static void yell_xorriso()
+{
+ fprintf(stderr,
+         "%sxorriso %d.%d.%d%s : RockRidge filesystem manipulator, libburnia project.\n\n",
+#ifdef Xorriso_GNU_xorrisO
+        "GNU ",
+#else
+        "",
+#endif
+        Xorriso_header_version_majoR, Xorriso_header_version_minoR,
+        Xorriso_header_version_micrO, Xorriso_program_patch_leveL);
+}
+
+
+/* Check whether build configuration and runtime linking are consistent.
+*/
+static void check_compatibility()
+{
+ int lib_major, lib_minor, lib_micro;
+
+/* 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 above 
+     Xorriso_req_majoR
+     Xorriso_req_minoR
+     Xorriso_req_micrO
+   It gets compared against the version macros in xorriso.h :
+     Xorriso_header_version_majoR
+     Xorriso_header_version_minoR
+     Xorriso_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: 'XORRISO_MISCONFIGURATION' undeclared (first use in this function)
+      error: 'INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_xorriso_dot_h_TOO_OLD__SEE_xorriso_main_dot_c' undeclared (first use in this function)
+      error: 'XORRISO_MISCONFIGURATION_' undeclared (first use in this function)
+*/
+/* The indendation is an advise of man gcc to help old compilers ignoring */
+ #if Xorriso_req_majoR > Xorriso_header_version_majoR
+ #define Xorriso_dot_h_too_olD 1
+ #endif
+ #if Xorriso_req_majoR == Xorriso_header_version_majoR && Xorriso_req_minoR > Xorriso_header_version_minoR
+ #define Xorriso_dot_h_too_olD 1
+ #endif
+ #if Xorriso_req_minoR == Xorriso_header_version_minoR && Xorriso_req_micrO > Xorriso_header_version_micrO
+ #define Xorriso_dot_h_too_olD 1
+ #endif
+
+#ifdef Xorriso_dot_h_too_olD
+XORRISO_MISCONFIGURATION = 0;
+INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_xorriso_dot_h_TOO_OLD__SEE_xorriso_main_dot_c = 0;
+XORRISO_MISCONFIGURATION_ = 0;
+#endif
+
+/* End of ugly compile time test (scroll up for explanation) */
+
+
+ /* Needed are at least 44 bits in signed type off_t .
+    This is a popular mistake in configuration or compilation.
+ */
+ if(sizeof(off_t) < 6) {
+   yell_xorriso();
+   fprintf(stderr,
+    "xorriso : FATAL : Compile time misconfiguration. sizeof(off_t) too small.\n\n");
+   exit(4);
+ }
+
+ /* Check whether the linked xorriso code is young enough.
+ */
+ if(! Xorriso__is_compatible(Xorriso_header_version_majoR,
+                             Xorriso_header_version_minoR,
+                             Xorriso_header_version_micrO, 0)) {
+   yell_xorriso();
+   Xorriso__version(&lib_major, &lib_minor, &lib_micro);
+   fprintf(stderr,
+           "xorriso : FATAL : libisoburn/xorriso runtime version mismatch. Found %d.%d.%d, need %d.%d.%d\n\n",
+           lib_major, lib_minor, lib_micro,
+           Xorriso_header_version_majoR, Xorriso_header_version_minoR,
+           Xorriso_header_version_micrO);
+   exit(4);
+ }
+
+}
+
+
+int main(int argc, char **argv)
+{
+ int ret, i;
+ struct XorrisO *xorriso= NULL;
+ char **orig_argv= NULL;
+
+ check_compatibility(); /* might exit() */
+
+ if(argc < 2) {
+   yell_xorriso();
+   fprintf(stderr,"usage : %s [options]\n", argv[0]);
+   fprintf(stderr, "        More is told by option -help\n");
+   exit(2);
+ }
+ setlocale(LC_CTYPE, "");
+ ret= Xorriso_new(&xorriso, argv[0], 0);
+ if(ret <= 0) {
+   fprintf(stderr,"Creation of XorrisO object failed. (not enough memory ?)\n");
+   exit(3);
+ }
+
+ /* The prescan of arguments performs actions which have to happen before
+    the normal processing of startup files and arguments.
+ */
+ ret= Xorriso_prescan_args(xorriso,argc,argv,0);
+ if(ret == 0)
+   goto end_sucessfully;
+ if(ret < 0)
+   exit(5);
+
+ yell_xorriso();
+
+ /* The following command interpreters are allowed only after this
+    initialization.
+ */
+ ret= Xorriso_startup_libraries(xorriso, 0);
+ if(ret <= 0)
+   {ret= 4; goto emergency_exit;}
+ Xorriso_process_msg_queues(xorriso, 0);
+
+ /* Interpret startup files */
+ ret= Xorriso_read_rc(xorriso, 0);
+ if(ret == 3)
+   goto end_sucessfully;
+ if(ret <= 0)
+   {ret= 5; goto emergency_exit;}
+
+ /* Interpret program arguments */
+ orig_argv= argv;
+ ret= Xorriso_program_arg_bsl(xorriso, argc, &argv, 0); 
+ if(ret <= 0)
+   {ret= 5; goto emergency_exit;}
+ i= 1;
+ ret= Xorriso_interpreter(xorriso, argc, argv, &i, 2);
+ if(ret == 3)
+   goto end_sucessfully;
+ if(ret <= 0)
+   {ret= 5; goto emergency_exit;}
+
+ /* Enter dialog mode if it has been activated meanwhile */
+ ret= Xorriso_dialog(xorriso, 0);
+ if(ret <= 0)
+   {ret= 6; goto emergency_exit;}
+
+end_sucessfully:; /* normal shutdown, including eventual -commit */
+ Xorriso_process_msg_queues(xorriso, 0);
+ if(Xorriso_change_is_pending(xorriso, 0))
+   Xorriso_option_end(xorriso, 2);
+ Xorriso_process_msg_queues(xorriso, 0);
+ ret= Xorriso_make_return_value(xorriso, 0);
+ Xorriso_process_errfile(xorriso, 0, "xorriso end", 0, 1);
+ Xorriso_destroy(&xorriso, 1);
+ if(orig_argv != argv && orig_argv != NULL) {
+   for(i= 0; i < argc; i++)
+     if(argv[i] != NULL)
+       free(argv[i]);
+   free(argv);
+ }
+ exit(ret);
+
+emergency_exit:;
+ if(xorriso != NULL) { /* minimal shutdown */
+   Xorriso_process_msg_queues(xorriso, 0);
+   Xorriso_destroy(&xorriso, 1);
+ }
+ exit(ret);
+}
+
+

xorriso/xorriso_makefile_am.txt

@@ -21,13 +21,13 @@ bin_PROGRAMS = \
 
 xorriso_xorriso_CPPFLAGS = -I./libburn -I./libisofs -I./libisoburn -I./xorriso
 
-# No readline in the vanilla version because the necessary headers
-# are in a separate readline-development package.
-xorriso_xorriso_CFLAGS = -DXorriso_standalonE -DXorriso_with_maiN \
-                         $(READLINE_DEF) $(LIBACL_DEF) $(XATTR_DEF) \
-                         $(EXTF_DEF) $(EXTF_SUID_DEF) $(ZLIB_DEF) \
-                         $(LIBCDIO_DEF) \
-                         $(XORRISO_DVD_OBS_64K) $(LIBBURN_O_DIRECT_DEF)
+# ts B00518 : The configuration macros are now transmitted via config.h 
+# xorriso_xorriso_CFLAGS = -DXorriso_standalonE \
+#                          $(READLINE_DEF) $(LIBACL_DEF) $(XATTR_DEF) \
+#                          $(EXTF_DEF) $(EXTF_SUID_DEF) $(ZLIB_DEF) \
+#                          $(LIBCDIO_DEF) \
+#                          $(XORRISO_DVD_OBS_64K) $(LIBBURN_O_DIRECT_DEF)
+xorriso_xorriso_CFLAGS = 
 
 xorriso_xorriso_LDADD = $(THREAD_LIBS) $(LIBBURN_ARCH_LIBS)
 
@@ -48,9 +48,56 @@ xorriso_xorriso_SOURCES = \
 	\
 	xorriso/xorriso.h \
 	xorriso/xorriso_private.h \
-	xorriso/xorriso.c \
+	xorriso/xorriso_main.c \
+	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/xorrisoburn.c \
+	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 \
 	\
@@ -266,8 +313,10 @@ EXTRA_DIST = \
 	libburn/os-freebsd.h \
 	libburn/os-libcdio.h \
 	libburn/os-linux.h \
+	libburn/os-solaris.h \
 	libburn/sg-dummy.c \
 	libburn/sg-freebsd.c \
 	libburn/sg-libcdio.c \
-	libburn/sg-linux.c
+	libburn/sg-linux.c \
+	libburn/sg-solaris.c
 

xorriso/xorriso_timestamp.h

@@ -1 +1 @@
-#define Xorriso_timestamP "2010.05.04.100001"
+#define Xorriso_timestamP "2010.09.18.210001"

xorriso/xorrisoburn.h

@@ -18,8 +18,8 @@
 /* The minimum version of libisoburn to be used with this version of xorriso
 */
 #define xorriso_libisoburn_req_major  0
-#define xorriso_libisoburn_req_minor  5
-#define xorriso_libisoburn_req_micro  6
+#define xorriso_libisoburn_req_minor  6
+#define xorriso_libisoburn_req_micro  2
 
 
 struct SpotlisT;          /* List of intervals with different read qualities */
@@ -412,6 +412,15 @@ int Xorriso_setfattr(struct XorrisO *xorriso, void *in_node, char *path,
                      size_t num_attrs, char **names,
                      size_t *value_lengths, char **values, int flag);
 
+int Xorriso_perform_attr_from_list(struct XorrisO *xorriso, char *path,
+                      struct Xorriso_lsT *lst_start, int flag);
+
+int Xorriso_path_setfattr(struct XorrisO *xorriso, void *in_node, char *path,
+                       char *name, size_t value_length, char *value, int flag);
+
+int Xorriso_perform_acl_from_list(struct XorrisO *xorriso, char *file_path,
+                                  char *uid, char *gid, char *acl, int flag);
+
 int Xorriso_record_dev_inode(struct XorrisO *xorriso, char *disk_path,
                              dev_t dev, ino_t ino,
                              void *in_node, char *iso_path, int flag);
@@ -509,5 +518,27 @@ int Xorriso_boot_image_status(struct XorrisO *xorriso, char *filter, FILE *fp,
 #define Xorriso_IFBOOT S_IFMT
 
 
+int Exprtest_match(struct XorrisO *xorriso, struct ExprtesT *ftest,
+                   void *node_pt, char *name, char *path,
+                   struct stat *boss_stbuf, struct stat *stbuf, int flag);
+
+
+int Xorriso_toc_to_string(struct XorrisO *xorriso, char **toc_text, int flag);
+
+
+int Xorriso_reaquire_outdev(struct XorrisO *xorriso, int flag);
+
+int Xorriso_set_system_area_path(struct XorrisO *xorriso, char *path,
+                                 int flag);
+
+int Xorriso_set_hidden(struct XorrisO *xorriso, void *in_node, char *path,
+                       int hide_state, int flag);
+
+
+/* @param flag  bit0= avoid library calls
+ */
+int Xorriso_preparer_string(struct XorrisO *xorriso, char xorriso_id[129],
+                            int flag);
+
 #endif /* Xorrisoburn_includeD */