Version leap to 1.0.4

Now the cylinder size gets adjusted if the image does not fit into 1024 cyl.

ChangeLog

@@ -1,3 +1,74 @@
+bzr branch lp:libisofs/for-libisoburn (to become libisofs-1.0.6.tar.gz)
+===============================================================================
+- no novelties yet
+
+libisofs-1.0.4.tar.gz Thu Mar 10 2011
+===============================================================================
+* Bug fix: Compilation failed if --disable-zlib was configured
+* Bug fix: isohybrid image size was not aligned to cylinder boundary.
+* New no_md5 value 2 for API call iso_read_opts_set_no_md5()
+* New option bits 8 and 9 with iso_write_opts_set_system_area()
+
+libisofs-1.0.2.tar.gz Tue Feb 23 2011
+===============================================================================
+* Bug fix: iso_write_opts_set_aaip(opts, 1) could cause fatal miscalculation
+           of the root directory size. This eventually truncated directory
+           tree and spoiled all data file content.
+* Bug fix: Volume Descriptor Set Terminator contained non-zero bytes in
+           the reserved field (ECMA-119 8.3.4). The bytes stem from the
+           previously written Volume Descriptor.
+* New API calls iso_tree_clone(), iso_stream_clone.
+* New IsoFileSourceIface version 2 with method clone_src().
+* New IsoStreamIface version 4 with method clone_stream().
+* New public function prototype iso_node_xinfo_cloner.
+* New API calls iso_node_xinfo_make_clonable(), iso_node_xinfo_get_cloner().
+* New public iso_node_xinfo_cloner instance aaip_xinfo_cloner().
+* New API calls iso_node_get_next_xinfo(), iso_node_remove_all_xinfo().
+* New API call iso_node_remove_tree().
+* New API call iso_write_opts_set_old_empty().
+
+libisofs-1.0.0.tar.gz Mon Jan 17 2011
+===============================================================================
+* Bug fix: ECMA-119 directory names were truncated to 8 characters if
+           lowercase characters or full ASCII are allowed.
+* New API call iso_write_opts_set_untranslated_name_len()
+* New API call iso_write_opts_set_allow_dir_id_ext()
+* New API call iso_memory_stream_new(). (Was formely a private call.)
+
+libisofs-0.6.40.tar.gz Fri Dec 10 2010
+===============================================================================
+* New API call iso_write_opts_set_disc_label(), new system area type
+  3 = SUN Disk Label for booting SUN SPARC systems.
+* New API call iso_write_opts_set_will_cancel() avoids start of write thread
+  and is to be used to inquire the future image size.
+* New error reply code ISO_DISPLACE_ROLLOVER for external data sources with
+  address displacement.
+
+libisofs-0.6.38.tar.gz Sat Oct 23 2010
+===============================================================================
+* New API calls iso_write_opts_attach_jte() and iso_write_opts_detach_jte()
+  allow to use libjte for jigdo production.
+* New API call iso_write_opts_set_tail_blocks() for tail padding inside
+  ISO image.
+* New API call iso_image_generator_is_running() to learn when the write thread
+  is done.
+* New API calls iso_image_add_mips_boot_file(),
+  iso_image_get_mips_boot_files(), iso_image_give_up_mips_boot().
+* New API call iso_write_opts_set_partition_img() for appending e.g. a small
+  empty FAT12 filesystem which may be used on USB stick.
+
+libisofs-0.6.36.tar.gz Wed Sep 15 2010
+===============================================================================
+* New API function iso_write_opts_set_part_offset() controls creation of
+  an MBR with a first partiton table entry that bears non-zero start address.
+  A second set of volume descriptors and directory tree+tables gets created
+  which can be used to mount the image at the partition start.
+* Hiding all non-API symbols from the linker by use of --version-script
+* Automatic C++ detection in libisofs.h by using macro __cplusplus
+* Corrected several memory leaks and potential NULL pointer evaluations
+  in case of memory shortage.
+* Now with history of release notes in ./ChangeLog file.
+
 libisofs-0.6.34.tar.gz Tue Jun 29 2010
 ===============================================================================
 * New API call iso_image_set_boot_catalog_hidden()
@@ -169,28 +240,3 @@ Libisofs 0.6.2
 * Completely new API
 * Long term commitment to ABI libisofs.so.6
 
-libisofs-0.2.8.tar.gz Tue Jul 31 2007
-===============================================================================
-* Support for hidden files
-* Eltorito support
-* Charset support
-* Support for inode caching
-* Ordering files on image
-* Unit tests
-* A lot of other features and bugfixes
-* Note: ABI has been broken.
-
-libisofs-0.2.5.tar.gz Tue Jul 31 2007
-===============================================================================
-* Bugfix release. Fixed the ECMA-related problem with iso tree generation. 
-  There is newer release 0.2.8 with a lot of new features.
-
-libisofs-0.2.4.tar.gz Jan 03 2007
-===============================================================================
-* Bugfix release. Fixes lots of problems people have encountered, including but
-  not limited to broken docs generation.
-
-libisofs-0.2.3.tar.gz Sat Dec 02 2006
-===============================================================================
-* Bugfix release, with some improvements for freebsd support. 
-* Requires libburn to compile.

Makefile.am

@@ -16,7 +16,9 @@ libisofs_libisofs_la_LDFLAGS = \
 
 # Eventually enabling system adapters for ACL and EA.
 # ts A90409: Eventually enabling use of zlib.
-libisofs_libisofs_la_CFLAGS = $(LIBACL_DEF) $(XATTR_DEF) $(ZLIB_DEF)
+# ts B00927: Eventually enabling use of libjte (Jigdo Template Extraction)
+libisofs_libisofs_la_CFLAGS = $(LIBACL_DEF) $(XATTR_DEF) $(ZLIB_DEF) \
+                              $(LIBJTE_DEF)
 
 # ts A90114 : added aaip_0_2.*
 
@@ -80,6 +82,8 @@ libisofs_libisofs_la_LIBADD= \
 libinclude_HEADERS = \
 	libisofs/libisofs.h
 
+install-exec-hook:
+	$(LIBBURNIA_LDCONFIG_CMD) "$(DESTDIR)$(libdir)" || echo 'NOTE: Explicite dynamic library configuration failed. If needed, configure manually for:' "$(DESTDIR)$(libdir)"
 
 ## ========================================================================= ##
 

README

@@ -37,7 +37,25 @@ and execute
 To make the libraries accessible for running resp. developing applications 
    make install
 
-See INSTALL file for further details.
+On GNU/Linux it will try to run program ldconfig with the library installation
+directory as only argument. Failure to do so will not abort installation.
+One may disable ldconfig by ./configure option --disable-ldconfig-at-install .
+
+By use of a version script, the libisofs.so library exposes no other function
+names but those of the API definitions in <libisofs/libisofs.h>.
+If -Wl,--version-script=... makes problems with the local compiler, then
+disable this encapsulation feature by
+    ./configure --disable-versioned-libs
+    make clean ; make
+
+The ./configure script checks for the availability of supporting libraries.
+If found, they will become mandatory for the emerging libisofs.so and all
+applications which use it. This dependency can be avoided by configure options
+    --disable-libacl   avoid use of ACL functions like acl_to_text()
+    --disable-xattr    avoid use of xattr functions like listxattr()
+    --disable-zlib     avoid use of zlib functions like compress2()
+
+See INSTALL file for general options of ./configure.
 
 
 ------------------------------------------------------------------------------
@@ -113,7 +131,6 @@ a) Images with unsupported features, such as:
 	- UDF.
 	- HSF/HFS+ or other Mac extensions.
 	- ECMA-119 Extended attributes.
-	- Non El-Torito boot info.
 	- ...
    In all these cases, the resulting new image (or new session) could lack some
    features of the original image. Nevertheless, the ECMA-119 System Area with
@@ -122,22 +139,9 @@ a) Images with unsupported features, such as:
    or modify the image. Others remain undetected. Images created with libisofs
    do not have this problems.
 
-b) Bootable El-Torito images may have several problems, that result in a new
+b) Bootable El-Torito images may have problems, that result in a new image that
-   image that is not bootable, or that boots from an outdated session. In many
+   is not bootable, or that boots from an outdated session. In some cases it
-   cases it is recommended to add boot info again in the new session.
+   might be necessary to add boot info again in a new first session.
-   
-    - isolinux images won't be bootable after a modify. This is because 
-      isolinux images need to have hardcoded the root dir lba in their boot
-      information table.
-      libisofs makes an educated guess at load time whether a boot image
-      contains such a table. Its outcome can be inquired by call
-      el_torito_seems_boot_info_table().
-      If one knows to have isolinux or GRUB El-Torito-bootable images, or if
-      a boot information table seems to exist, it is advised to apply the
-      el_torito_patch_isolinux_image() function.
-      Most boot images are highly dependent of the image contents, so if the 
-      user moves or removes some files on image it is possible they won't boot 
-      anymore.
     - There is no safe way to modify hidden boot images, as the size of the 
       boot image can't be figured out.
 

acinclude.m4

@@ -16,10 +16,12 @@ AC_DEFUN([TARGET_SHIZZLE],
 
   AC_MSG_CHECKING([target operating system])
 
+  LIBBURNIA_LDCONFIG_CMD="echo 'No ldconfig run performed. If needed, configure manually for:'"
   case $target in
     *-*-linux*)
       ARCH=linux
       LIBBURN_ARCH_LIBS=
+      LIBBURNIA_LDCONFIG_CMD=ldconfig
       ;;
     *-*-freebsd*)
       ARCH=freebsd

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([libisofs], [0.6.36], [http://libburnia-project.org])
+AC_INIT([libisofs], [1.0.4], [http://libburnia-project.org])
 AC_PREREQ([2.50])
 dnl AC_CONFIG_HEADER([config.h])	
 
@@ -38,9 +38,9 @@ dnl It rather feeds the API function iso_lib_version().
 dnl
 dnl If LIBISOFS_*_VERSION changes, be sure to change AC_INIT above to match.
 dnl
-LIBISOFS_MAJOR_VERSION=0
+LIBISOFS_MAJOR_VERSION=1
-LIBISOFS_MINOR_VERSION=6
+LIBISOFS_MINOR_VERSION=0
-LIBISOFS_MICRO_VERSION=36
+LIBISOFS_MICRO_VERSION=4
 LIBISOFS_VERSION=$LIBISOFS_MAJOR_VERSION.$LIBISOFS_MINOR_VERSION.$LIBISOFS_MICRO_VERSION
 
 AC_SUBST(LIBISOFS_MAJOR_VERSION)
@@ -50,10 +50,10 @@ AC_SUBST(LIBISOFS_VERSION)
 
 dnl Libtool versioning
 LT_RELEASE=$LIBISOFS_MAJOR_VERSION.$LIBISOFS_MINOR_VERSION
-# 2010.09.15  development jump has not yet happened
+# 2011.03.10  development jump has not yet happened
-# SONAME = 38 - 32 = 6 . Library name = libisofs.6.32.0
+# SONAME = 48 - 42 = 6 . Library name = libisofs.6.42.0
-LT_CURRENT=38
+LT_CURRENT=48
-LT_AGE=32
+LT_AGE=42
 LT_REVISION=0
 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
 
@@ -133,15 +133,15 @@ AC_ARG_ENABLE(debug,
               , enable_debug=yes)
 if test x$enable_debug != xyes; then
     if test x$GCC = xyes; then
-        CFLAGS="$CFLAGS -O3"
+        CFLAGS="-O3 $CFLAGS"
-        CFLAGS="$CFLAGS -fexpensive-optimizations"
+        CFLAGS="-fexpensive-optimizations $CFLAGS"
     fi
-    CFLAGS="$CFLAGS -DNDEBUG"
+    CFLAGS="-DNDEBUG $CFLAGS"
 else
     if test x$GCC = xyes; then
-        CFLAGS="$CFLAGS -g -pedantic -Wall"
+        CFLAGS="-g -pedantic -Wall $CFLAGS"
     fi
-    CFLAGS="$CFLAGS -DDEBUG"
+    CFLAGS="-DDEBUG $CFLAGS"
 fi
 
 dnl Verbose debug to make libisofs issue more debug messages
@@ -205,6 +205,18 @@ else
 fi
 AC_SUBST(ZLIB_DEF)
 
+dnl ts B00927
+AC_ARG_ENABLE(libjte,
+[  --enable-libjte           Enable use of libjte by libisofs, default=yes],
+               , enable_libjte=yes)
+if test "x$enable_libjte" = xyes; then
+    LIBJTE_DEF="-DLibisofs_with_libjtE"
+    AC_CHECK_HEADER(libjte/libjte.h, AC_CHECK_LIB(jte, libjte_new, , LIBJTE_DEF= ), LIBJTE_DEF= )
+else
+    LIBJTE_DEF=
+fi
+AC_SUBST(LIBJTE_DEF)
+
 # Library versioning normally serves a complex purpose.
 # Since libisofs obeys strict ABI backward compatibility, it needs only the
 # simple feature to declare function names "global:" or "local:". Only the
@@ -225,6 +237,17 @@ else
     echo "disabled strict symbol encapsulation"
 fi
 
+AC_ARG_ENABLE(ldconfig-at-install,
+[  --enable-ldconfig-at-install    On GNU/Linux run ldconfig, default=yes],
+               , ldconfig_at_install=yes)
+if test x$ldconfig_at_install = xyes; then 
+    dummy=dummy
+else
+    LIBBURNIA_LDCONFIG_CMD="echo 'NOTE: ldconfig is disabled. If needed, configure manually for:'"
+    echo "disabled run of ldconfig during installation on GNU/Linux"
+fi  
+AC_SUBST(LIBBURNIA_LDCONFIG_CMD)
+
 AC_CONFIG_FILES([
 	Makefile
 	doc/doxygen.conf

doc/boot_sectors.txt

@@ -0,0 +1,727 @@
+
+
+
+            Collection of Boot Sector Formats for ISO 9660 Images
+
+
+            by Thomas Schmitt    - mailto:scdbackup@gmx.net
+            Libburnia project    - mailto:libburn-hackers@pykix.org
+
+This information is collected from various sources. Some is backed by
+specifications, some is just rumor which happens to work (maybe not even that).
+
+
+                                  Content
+
+EL Torito CD booting, for PC-BIOS x86, PowerPC, (old) Mac, EFI.
+
+MBR, for PC-BIOS x86 from (pseudo-) hard disk
+- SYSLINUX isohybrid MBR
+- GRUB2 grub-mkrescue MBR.
+
+MIPS Volume Header, for MIPS Big Endian, e.g. SGI Indigo2.
+
+DEC Boot Block, for MIPS Little Endian , e.g. DECstation.
+
+SUN Disk Label and boot images, for SUN SPARC
+
+
+------------------------------------------------------------------------------
+
+
+                         EL Torito CD booting
+                 for PC-BIOS x86, PowerPC, (old) Mac, EFI
+
+Sources:
+    El Torito, Bootable CD-ROM Format Specification, Version 1.0, 1995
+    which refers to ECMA-119, the standard for ISO 9660 filesystems.
+    libisofs/eltorito.[ch] by Vreixo Formoso.
+    man mkisofs by Joerg Schilling.
+
+
+ECMA-119 prescribes that the first 32 kB of an ISO 9660 image are System Area
+with arbitrary content. This prescription is obeyed by PC-BIOS systems only
+if the ISO 9660 image is presented on CD, DVD or BD media.
+In this case the El Torito Boot record is the starting point of booting.
+
+The Boot Record is a ECMA-119 Volume Descriptor which is eventually located
+at 2 kB block number 17 (decimal). Its content points to the location of the
+Boot Catalog.
+The format is described in part by ECMA-119 8.2 "Boot Record" and further
+specified by El Torito figure 7.
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -   0 |          0 | Volume Descriptor Type. 0= Boot record
+   1 -   5 |    "CD001" | Standard Identifier
+   6 -   6 |          1 | Volume Descriptor Version
+   7 -  38 |  el_torito | Boot System Identifier
+  39 -  70 |          0 | Boot Identifier
+           |            |
+  71 -2047 | ========== | Boot System Use
+           |            |
+  71 - 74  | cataloglba | The 2 kB block number of the Boot Catalog
+           |            | as little-endian 32 bit number.
+           |            |
+  75 -2047 |          0 | Unused
+---------- | ---------- | ----------------------------------------------------
+
+el_torito is the constant string "EL TORITO SPECIFICATION" padded by 9 zeros.
+cataloglba has to be provided by the file system generator.
+
+
+The Boot Catalog lists the available boot images which may be prepared for
+multiple system architectures, called "platforms".
+It consists of one or more 2 kB blocks. The content is a sequence of fixed
+format entries, 32 bytes each.
+The entries are grouped in sections, which assign the entries to a particular
+system architecture. The booting system will then choose an entry from an
+appropriate section.
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -  31 | ========== | Validation Entry
+           |            | begins the first section, specifies an architecture
+  32 -  63 | ========== | Initial/Default Entry
+           |            | points to a boot image for given architecture
+---------- | ---------- | ----------------------------------------------------
+Optional: 
+---------- | ---------- | ----------------------------------------------------
+  64 -  95 | ========== | Section Header entry
+           |            | begins new section, specifies an architecture
+  96 - 127 | ========== | Section Entry
+           |            | points to a boot image for given architecture
+    ...    | .......... | Optional more Section Entries
+    ...    | .......... | Optional more Section Headers and their Section
+           |            | Entries
+---------- | ---------- | ----------------------------------------------------
+
+An architecture is refered by a Platform Id number.
+Defined by El Torito are:
+    0 = "80x86" which is used for standard PCs with Intel x86 or compatible CPU
+    1 = "PowerPC" (possibly for IBM machines with PowerPC CPU)
+    2 = "Mac" (possibly for Apple computers with MC68000 or PowerPC CPU)
+Further in use by GRUB2 is:
+ 0xef = EFI, a competitor resp. successor to PC-BIOS, possibly in use with
+             Intel ia64 Itanium and possibly with newer Apple machines.
+
+Words resp. numbers are represented are little-endian. 
+
+Validation Entry:
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -   0 |          1 | Header Id
+           |            |
+   1 -   1 | platform_id| Platform Id. One of: 0, 1, 2, 0xef. See above.
+           |            |
+   2 -   3 |          0 | Reserved
+   4 -  27 |  manuf_dev | ID string identifies the manufacturer/developer
+           |            | (no non-zero examples known yet)
+           |            |
+  28 -  29 |   checksum | Checksum Word for the Validation Entry. 
+           |            | The sum of all words in the entry has to be 0.
+           |            |
+  30 -  30 |       0x55 | 
+  31 -  31 |       0xaa | 
+---------- | ---------- | ----------------------------------------------------
+
+
+Initial/Default Entry:
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -   0 | boot_indct | Boot Indicator: 0x88 = bootable, 0x00 = not bootable
+           |            |
+   1 -   1 | boot_media | Boot Media Type (i.e. media emulated by boot image):
+           |            | 0= no emulation , 1= 1.2 MB diskette, 2=1.44 MB,
+           |            | 3= 2.88 MB , 4= hard disk
+           |            | (About everybody uses 0 = no emulation)
+           |            |
+   2 -   3 |   load_seg | Load Segment. (meaning unclear)
+           |            | "If this value is 0 the system will use the
+           |            |  traditional segment of 7C0."
+           |            | libisofs default is 0
+           |            |
+   4 -   4 |   sys_type | System Type.
+           |            | "Must be a copy of byte 5 from the partition table
+           |            |  found in the boot image."
+           |            | libisofs reads the start the boot image as MBR
+           |            | if  boot_media == 4. This emulated MBR has a
+           |            | partition table from where a byte gets copied.
+           |            | Else this byte is 0.
+           |            |
+   5 -   5 |          0 | Unused
+           |            |
+   6 -   7 |  sec_count | Sector Count.
+           |            | "the number of virtual/emulated sectors the system
+           |            |  will store at Load Segment during the initial boot
+           |            |  procedure."
+           |            | libisofs stores 1 for emulated boot_media and a
+           |            | user defined value for boot_media == 0. Often: 4.
+           |            |
+   8 -  11 |  load_rba  | Load RBA. The 2 kB block address where the boot
+           |            | image file content is located in the ISO 9660 image.
+           |            |
+  12 -  31 |          0 | Unused
+---------- | ---------- | ----------------------------------------------------
+
+
+Section Header Entry:
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -   0 |   head_ind | Header Indicator: 0x90 = more headers follow
+           |            |                   0x91 = final header, last section
+           |            |
+   1 -   1 | platform_id| Platform Id. One of: 0, 1, 2, 0xef. See above.
+           |            |
+   2 -   3 | num_entries| Number of entries to follow in this section
+           |            |
+   4 -  31 |            | ID string identifies the manufacturer/developer
+---------- | ---------- | ----------------------------------------------------
+
+
+Section Entry:
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -   0 | boot_indct | Boot Indicator: 0x88 = bootable, 0x00 = not bootable
+           |            |
+   1 -   1 | boot_media | Boot Media Type (i.e. media emulated by boot image):
+           |            | Bit 0 to 3 govern emulation
+           |            |   0= no emulation , 1= 1.2 MB diskette, 2=1.44 MB,
+           |            |   3= 2.88 MB , 4= hard disk
+           |            |   (About everybody uses 0 = no emulation)
+           |            | Bit 4 is reserved and must be 0
+           |            | Bit 5 "Continuation entry follows" (meaning unclear)
+           |            |       Might be the indicator for Extension Entries,
+           |            |       which are not described here.
+           |            | Bit 6 "Image contains an ATAPI driver"
+           |            | Bit 7 "Image contains SCSI drivers"
+           |            |
+   2 -   3 |   load_seg | Load Segment. (meaning unclear)
+           |            | See above Initial/Default Entry
+           |            | libisofs default is 0.
+   4 -   4 |   sys_type | System Type.
+           |            | See above Initial/Default Entry
+           |            | 0 if not emulation == 4.
+   5 -   5 |          0 | Unused
+           |            |
+   6 -   7 |  sec_count | Sector Count.
+           |            | See above Initial/Default Entry
+           |            | libisofs stores 1 for emulated boot_media and a
+           |            | user defined value for boot_media == 0. Often: 4.
+           |            |
+   8 -  11 |  load_rba  | Load RBA. The 2 kB block address where the boot
+           |            | image file content is located in the ISO 9660 image.
+           |            |
+  12 -  31 |   sel_crit | "Vendor unique selection criteria."
+---------- | ---------- | ----------------------------------------------------
+
+
+The boot image file content is mostly opaque to the ISO 9660 image generator.
+Nevertheless there is a tradition named "Boot Info Table" which prescribes
+to write information into byte fields of the boot image file content.
+There are no general means known how a producer of ISO 9660 images could
+detect the need for Boot Info Table production.
+It rather needs a hint from the user who has to know whether the boot image
+expects a Boot Info Table.
+The Boot Info Table begins at byte 8 of the boot image content.
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   8 -  11 |    pvd_lba | Block address of the Primary Volume Descriptor
+           |            | This is the session start LBA + 16.
+           |            |
+  12 -  15 |   file_lba | Block address of the start of the boot image file
+           |            | content.
+           |            |
+  16 -  19 |   file_len | Number of bytes in boot image file content.
+           |            |
+  20 -  23 |   checksum | Little-endian: The sum of all 32-bit words of the
+           |            | file content from byte 64 to file end.
+           |            |
+  24 -  63 |          0 | Reserved
+---------- | ---------- | ----------------------------------------------------
+
+------------------------------------------------------------------------------
+
+
+                                   MBR
+                  for PC-BIOS x86 from (pseudo-) hard disk
+
+Sources:
+    http://en.wikipedia.org/wiki/Master_boot_record
+    Mailing list conversations with H. Peter Anvin and Vladimir Serbinenko.
+
+
+The candidates for MBR booting will normally use El Torito rather than MBR
+if the ISO image is presented on CD, DVD, or BD media.
+The eventual MBR comes into effect if the image is on a media that is
+interpreted by the BIOS as some kind of hard disk. Usually real hard disks,
+floppy disks, USB sticks, memory cards.
+
+An important part of an MBR is the DOS style partition table. It describes up
+to four primary partitions. There are two formats used for block address:
+Cylinder/Head/Sector (C/H/S) and Logical Block Address (LBA). Both are based
+on units of 512 bytes. So MBR_LBA = ISO_LBA * 4.
+
+For C/H/S, the sector address is broken up into whole cylinders, remaining
+heads, and remaining sectors + 1. The nomenclature seems to stem from antique
+drum storage.
+There are two parameters, sectors_per_head and heads_per_cylinder which are not
+stored in the MBR. So it is more or less arbitray how to convert a LBA into
+a C/H/S address and vice versa. For maximum range of C/H/S addresses one
+may use sectors_per_head = 63 , heads_per_cylinder = 255.
+
+
+Words are composed little-endian style.
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 - 439 | = opaque = | Code Area filled with bytes for some boot system,
+           |            | typically machine code.
+           |            |
+ 440 - 443 | disk_sgntr | Disc signature, an individual disk id of obscure
+           |            | usability.
+           |            | (The Code Area might extend up to this field.)
+           |            |
+ 444 - 445 |          0 | "usually nulls"
+           |            | (The Code Area might extend up to this field.)
+           |            |
+ 446 - 461 | ========== | Partition Table Entry for partition 1
+           |            |
+ 446 - 446 |     status | Governs bootability:
+           |            | 0x80 = bootable/active , 0x00 non-bootable/inactive
+           |            |
+ 447 - 449 | ========== | C/H/S address of partition start
+ 447 - 447 | start_head | Heads part of start address.
+ 448 - 448 |  start_c_s | Bits 0 to 5 : Sectors part of start address.
+           |            | Bits 6 to 7 : Bits 8 to 9 of cylinders part.
+ 449 - 449 |  start_cyl | Lower 8 bits of cylinders part of start address
+           |            |
+ 450 - 450 |  part_type | Partition type indicates the purpose or kind of
+           |            | filesystem in the partition.
+           |            |
+ 451 - 453 | ========== | C/H/S address of last absolute sector in partition
+ 451 - 451 |   end_head | Heads part of end address.
+ 452 - 452 |    end_c_s | Bits 0 to 5 : Sectors part of end address.
+                        |               Values: 1 to 63, not 0.
+           |            | Bits 6 to 7 : Bits 8 to 9 of cylinders part.
+ 453 - 453 |    end_cyl | Lower 8 bits of cylinders part of end address
+           |            |
+ 454 - 457 |  start_lba | LBA of first absolute sector in partiton. 
+           |            | Block size is 512. Counting starts at 0.
+           |            |
+ 458 - 461 | num_blocks | Number of sectors in partition.
+           |            |
+ 462 - 477 | ========== | Partition Table Entry for partition 2
+           | part_entr2 | 16 bytes. Format as with partition 1.
+           |            | All 0 means that partition is unused/undefined.
+           |            |
+ 478 - 493 | ========== | Partition Table Entry for partition 3
+           | part_entr3 | 16 bytes. See above.
+           |            |
+ 494 - 509 | ========== | Partition Table Entry for partition 4
+           | part_entr4 | 16 bytes. See above.
+           |            |
+ 510 - 510 |       0x55 | MBR signature
+ 511 - 511 |       0xaa | MBR signature
+           |            |
+---------- | ---------- | ----------------------------------------------------
+
+
+By tradition the MBR itself and possibly more blocks are not claimed by any
+partition. But starting the first partition at a non-zero block address causes
+on Linux a partition device file (e.g. /dev/sdb1) which cannot be used to mount
+the ISO filesystem.
+
+libisofs is able to produce a second set of trees and meta data which is
+suitable for being mounted at start block 16 (ISO) resp. 64 (MBR).
+See <libisofs/libisofs.h> for call iso_write_opts_set_part_offset()
+and http://libburnia-project.org/wiki/PartitionOffset for examples with
+program xorriso.
+
+
+------------------------------------------------------------------------------
+
+
+                             SYSLINUX Isohybrid MBR
+
+Sources:
+    syslinux-3.72/utils/isohybrid , a perl script by H. Peter Anvin = hpa.
+    Mailing list conversations with hpa.
+
+
+An isohybrid MBR directs the booting BIOS to an ISOLINUX boot image which
+is also the target of an El Torito boot catalog entry.
+For that purpose one has to take an MBR template and has to set a few bytes
+to values which sufficiently describe the ISO image and the boot image file.
+
+Words are composed little-endian style.
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 - 431 | = opaque = | Syslinux machine code provided by MBR template
+           |            |
+ 432 - 439 | hd_bootlba | Address of the ISOLINUX boot image file in the
+           |            | ISO image. Counted in 512 byte blocks.
+           |            |
+ 440 - 443 |     mbr_id | Random number
+ 444 - 445 |          0 | Padding
+           |            |
+ 446 - 509 | ========== | Partition table
+           |            |
+ 446 - 461 | part_entry | Partition table entry 1 describing ISO image size
+           |            | starting at LBA 0. I.e. contrary to tradition.
+           |            | See above for partition table entry format.
+           |            |
+ 462 - 509 |          0 | Unused partition entries 2 to 4
+ 510 - 511 |     0xaa55 | MBR signature
+---------- | ---------- | ----------------------------------------------------
+
+
+hpa about MBR templates and partition table filesystem types:
+
+"[MBR templates] are available in the Syslinux build tree under the names:
+   mbr/isohdp[fp]x*.bin
+ The default probably should be mbr/isohdppx.bin, but it's ultimately up
+ to the user.
+ [...]
+ Note: the filesystem type is largely arbitrary, in theory it can be any
+ value other than 0x00, 0x05, 0x0f, 0x85, 0xee, or 0xef.  0x17 ("Windows
+ IFS Hidden") seems safeish, some people believe 0x83 (Linux) is better.
+"
+
+------------------------------------------------------------------------------
+
+
+                          GRUB2 grub-mkrescue MBR
+
+Sources:
+    Mailing list conversations with Vladimir Serbinenko.
+
+
+The MBR file that is used with GRUB2 script grub-mkrescue needs only a
+partition table entry which describes the image size.
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 - 445 | = opaque = | GRUB2 machine code provided by MBR template
+           |            |
+ 446 - 509 | ========== | Partition table
+           |            |
+ 446 - 461 | part_entry | Partition table entry 1 describing ISO image size
+           |            | Peculiar is the start offset of 1 block.
+           |            | This prevents mounting of the partition.
+           |            | See above for partition table entry format.
+           |            |
+ 462 - 509 |          0 | Unused partition entries 2 to 4
+ 510 - 511 |     0xaa55 | MBR signature
+---------- | ---------- | ----------------------------------------------------
+
+Vladimir Serbinenko about the partition table entry:
+"Currently we use first and not last entry. You need to:
+ 1) Zero-fill 446-510
+ 2) Put 0x55, 0xAA into 510-512
+ 3) Put 0x80 (for bootable partition), 0, 2, 0 (C/H/S of the start), 0xcd
+   (partition type), [3 bytes of C/H/S end], 0x01, 0x00, 0x00, 0x00 (LBA
+   start in little endian), [LBA end in little endian] at 446-462
+"
+
+------------------------------------------------------------------------------
+
+
+                               MIPS Volume Header
+                       for MIPS Big Endian, e.g. SGI Indigo2
+
+Sources:
+   cdrkit-1.1.10/genisoimage/boot-mips.c
+   by Steve McIntyre <steve@einval.com>
+   which refers to
+      genisovh by Florian Lohoff <flo@rfc822.org>
+              and Thiemo Seufer <seufer@csv.ica.uni-stuttgart.de>
+      who seem to have learned parameter settings from IRIX CD media
+      There are traces in the web which relate this to specs by
+               MIPS Computer Systems, Inc. , 1985
+               Silicon Graphics Computer Systems, Inc. , 2000
+
+
+The first 512 bytes of the media constitute the Volume Header.
+Words are composed big-endian style.
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -   3 | 0x0be5a941 | Magic number
+   4 -   5 |          0 | Root partition number
+   6 -   7 |          0 | Swap partition number
+   8 -  23 |          0 | Name of file to boot (unclear what this means)
+           |            |
+  24 -  71 | ========== | Device Parameters
+           |            |
+  24 -  24 |          0 | Spiral addressing skew (unclear what this means)
+  25 -  25 |          0 | Words of 0 before header
+  26 -  26 |          0 | Words of 0 between hdr and data
+  27 -  27 |          0 | Spare sectors per cylinder
+  28 -  29 |  num_cyl_l | Number of usable cylinder, lower two bytes
+           |            |  ((iso_size + BYTES_PER_SECTOR - 1) /
+           |            |   (SECTORS_PER_TRACK * BYTES_PER_SECTOR)) & 0xffff
+  30 -  31 |          0 | Starting head of volume 0 
+  32 -  33 |          1 | Number of tracks per cylinder
+  34 -  34 |          0 | Depth of CTQ queue (unclear what this means)
+  35 -  35 |  num_cyl_h | Number of usable cylinders, high byte 
+           |            |  ((iso_size + BYTES_PER_SECTOR - 1) /
+           |            |   (SECTORS_PER_TRACK * BYTES_PER_SECTOR)) >> 16
+  36 -  37 |          0 | unused
+  38 -  39 |         32 | SECTORS_PER_TRACK
+  40 -  41 |        512 | BYTES_PER_SECTOR
+  42 -  43 |          0 | Sector interleave (unclear what this means)
+  44 -  47 | 0x00000034 | Controller characteristics composed from
+           |            | DP_RESEEK 0x00000020 /* recalibrate as last resort */
+           |            | DP_IGNOREERRORS 0x00000010
+           |            |              /* transfer data regardless of errors */
+           |            | DP_TRKFWD 0x00000004
+           |            |                    /* forward to replacement track */
+  48 -  51 |          0 | Bytes/sec for kernel stats
+  52 -  55 |          0 | Max num retries on data error
+  56 -  59 |          0 | ms per word to xfer, for iostat
+  60 -  71 |          0 | 6 parameter words for xylogics controllers
+           |            |
+  72 - 311 | ========== | Volume Directory with 15 entries of 16 bytes each
+           |            |
+  72 -  87 | ========== | Volume Directory Entry 1
+  72 -  79 |  boot_name | Boot file basename, eventually padded by 0 to lenght 8
+  80 -  83 | boot_block | ISO 9660 LBA of boot file * 4, i.e. in blocks of 512
+  84 -  87 | boot_bytes | File length in bytes
+           |            |
+  88 - 311 | see above  | Volume Directory Entries 2 to 15
+           |            |
+ 312 - 504 | ========== | Partition Table with 16 entries of 12 bytes each
+           |            |
+ 312 - 407 |          0 | Unused partition entries 1 to 8
+           |            |
+ 408 - 419 | ========== | Partition Table Entry 9 for Volume Header
+ 408 - 411 |  part_blks | Number of 512 byte blocks in partition
+           |            |(iso_size + (BYTES_PER_SECTOR - 1)) / BYTES_PER_SECTOR
+ 412 - 415 |          0 | Start block of partition
+ 416 - 419 |          0 | PTYPE_VOLHDR = Partition is volume header
+           |            |
+ 420 - 431 |          0 | Unused partition entry 10
+           |            |
+ 432 - 443 | ========== | Partition Table Entry 11 for Volume
+ 432 - 435 |  part_blks | Number of 512 byte blocks in partition
+           |            |(iso_size + (BYTES_PER_SECTOR - 1)) / BYTES_PER_SECTOR
+ 436 - 439 |          0 | Start block of partition
+ 440 - 443 |          6 | PTYPE_VOLUME = Partition is entire volume
+           |            |
+ 444 - 503 |          0 | Unused partition entries 12 to 16
+           |            |
+ 504 - 507 |   head_chk | Volume header checksum
+           |            | The two's complement of bytes 0 to 503 read as big
+           |            | endian unsigned 32 bit: sum(words) + head_chk == 0
+           |            |
+ 508 - 511 |          0 | Volume header end padding
+           |            |
+up to 2048 |          0 | ISO 9660 Block end padding
+---------- | ---------- | ----------------------------------------------------
+
+
+------------------------------------------------------------------------------
+
+
+                               DEC Boot Block
+                    for MIPS Little Endian , e.g. DECstation
+
+Sources:
+   cdrkit-1.1.10/genisoimage/boot-mipsel.c
+   by Steve McIntyre <steve@einval.com>
+   which refers to
+      delo   by Florian Lohoff <flo@rfc822.org>
+            and Thiemo Seufer <seufer@csv.ica.uni-stuttgart.de>
+   cdrkit-1.1.10/include/glibc_elf.h
+   by Steve McIntyre
+   which is based on
+      <elf.h> from GNUC C Library by Free Software Foundation, Inc. 
+
+
+There seems to be only one boot file possible.
+Some information needs to be read out of the ELF headers of this boot file.
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -   7 |          0 | Padding
+           |            |
+   8 -  11 | 0x0002757a | Magic number
+           |            |
+  12 -  15 |          1 | Mode /* 0: Single extent, 1: Multi extent boot */
+           |            |
+  16 -  19 |   load_adr | Load address /* Load below kernel */
+           |            | Stems from ELF header of boot file.
+           |            | See below Elf32_Phdr field p_vaddr.
+           |            |
+  20 -  23 |   exec_adr | Execution address /* And exec there */
+           |            | Stems from ELF header of boot file.
+           |            | See below Elf32_Ehdr field e_entry.
+           |            |
+  24 -  31 | ========== | Boot Map Entry 1
+           |            |
+  24 -  27 |   seg_size | Segment size in file. Blocks of 512 bytes.
+           |            | Stems from ELF header of boot file.
+           |            | (Elf32_Phdr field p_filesz + 511) / 512;
+           |            |
+  28 -  31 |  seg_start | Segment file offset. Blocks 512 bytes.
+           |            | ISO 9660 LBA of boot file * 4 plus offset
+           |            | + offset which stems from ELF header of boot file:
+           |            | (Elf32_Phdr field p_offset + 511) / 512;
+           |            |
+  32 - 431 | ========== | Boot Map Entries 2 to 51
+           |          0 |
+           |            |
+---------- | ---------- | ----------------------------------------------------
+
+
+Elf32_Ehdr gets loaded from boot file byte address 0:
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -  23 |            | ( Magic number, file information )
+           |            | 
+  24 -  27 |    e_entry | /* Entry point virtual address */
+           | = exec_adr | Needed for exec_adr
+           |            |
+  28 -  31 |    e_phoff | /* Program header table file offset */
+           |            | Byte address of Elf32_Phdr
+           |            |
+
+Elf32_Phdr gets loaded from boot file byte_address Elf32_Ehdr.e_phoff :
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 -   3 |            | ( Segment type )
+           |            |
+   4 -   7 |   p_offset | /* Segment file offset */
+           |-> seg_start| Needed for seg_start
+           |            |
+   8 -  11 |    p_vaddr | /* Segment virtual address */
+           |  =load_adr | Needed for load_adr
+           |            |
+  12 -  15 |            | (Segment physical address)
+           |            |
+  16 -  19 |   p_filesz | /* Segment size in file */
+           |-> seg_size | Needed for seg_size
+           |            |
+---------- | ---------- | ----------------------------------------------------
+
+
+------------------------------------------------------------------------------
+
+
+                          SUN Disk Label and boot images
+                                 for SUN SPARC
+
+Sources:
+   cdrtools-2.01.01a77/mkisofs/sunlabel.h
+   cdrtools-2.01.01a77/mkisofs/mkisofs.8
+   by Joerg Schilling
+
+
+The Disk Label is written to the first 512 bytes of the image. It can mark
+8 partitions (slices ) of which the first contains the ISO image. The other
+7 may contain boot images.
+Words are composed big-endian style.
+
+Boot images are provided externally. mkisofs arranges them after the end of
+the ISO image so that each starts at a cylinder boundary (320 kB).
+
+There is a mechanism in mkisofs which fills unused partitions by copies of
+their predecessor in the partition table:
+"If the special filename ... is used, the actual and all following
+ boot partitions are mapped to  the  previous  partition.
+ If mkisofs is called with -G image -B ... all boot partitions are
+ mapped to the partition that contains the ISO9660 filesystem."
+
+
+Disk Label components:
+
+Byte Range | Value      | Meaning
+---------- | ---------- | ----------------------------------------------------
+   0 - 127 |      label | ASCII Label
+           |            | "CD-ROM Disc with Sun sparc boot created by ..."
+           |            | mkisofs option -sparc-label
+           |            |
+ 128 - 263 | ========== | /* vtoc inclusions from AT&T SVr4 */
+           |            |
+ 128 - 131 |          1 | Layout version
+ 132 - 139 |          0 | /* volume name           */
+ 140 - 141 |          8 | Number of partitions
+           |            |
+ 142 - 173 | ========== | 8 partition entries of 4 bytes
+           |            |
+ 142 - 145 | ========== | Entry for partition 1
+ 142 - 143 |          4 | ID tag of partition: 4 = User partition
+ 144 - 145 |       0x10 | Permissions: 0x10 = read-only
+           |            |
+ 146 - 149 | ========== | Entry for partition 2 
+ 146 - 147 |    id_tag2 | ID tag of partition:
+           |            | 0 = unused
+           |            | 2 = Root partition with boot image
+ 148 - 149 |      perm2 | Permissions:
+           |            | 0 = unused
+           |            | 0x10 = read-only (if used)
+           |            |
+ 150 - 173 | ========== | Entries for partition 3 to 8.
+           |            | See above: Entry for partition 2
+           |            |
+ 174 - 175 |          0 | Padding
+           |            |
+ 176 - 187 |          0 | /* info for mboot       */
+           |            |
+ 188 - 191 | 0x600ddeee | /* to verify vtoc sanity */
+           |            |
+ 192 - 231 |          0 | Reserved
+           |            |
+ 232 - 263 |          0 | 8 Timestamps of yet unknown format
+           |            |
+ 264 - 419 |          0 | Padding
+           |            |
+ 420 - 443 | ========== | Disk properties
+           |            |
+ 420 - 421 |        350 | Rotations per minute
+ 422 - 423 |       2048 | Number of physical cylinders (fixely 640 MB)
+ 424 - 425 |          0 | /* alternates per cylinder */
+ 426 - 429 |          0 | /* obsolete */
+ 430 - 431 |          1 | /* interleave factor */
+ 432 - 433 |       2048 | Number of data cylinders (fixely 640 MB)
+ 434 - 435 |          0 | /* # of alternate cylinders */
+ 436 - 437 |          1 | Number of heads per cylinder (i.e. 1 cyl = 320 kB)
+ 438 - 439 |        640 | Number of sectors per head (i.e. 1 head = 320 kB)
+ 440 - 443 |          0 | /* obsolete */
+           |            |
+ 444 - 507 | ========== | Partition table
+           |            |
+ 444 - 451 | ========== | Partition table entry #1
+           |            |
+ 444 - 447 |  start_cyl | Start cylinder
+           |            |
+ 448 - 451 | num_blocks | Number of blocks in partition
+           |            |
+ 452 - 507 | ========== | Partition table entries #2 to #8
+           |        ... | See above Partition table entry #1
+           |            |
+ 508 - 509 |     0xdabe | Magic Number
+           |            |
+ 510 - 511 |   checksum | The result of exoring 2-byte words 0 to 254
+           |            |
+---------- | ---------- | ----------------------------------------------------
+
+
+------------------------------------------------------------------------------
+
+>>> ??? HP-PA
+
+------------------------------------------------------------------------------
+
+>>> ??? DEC Alpha
+
+------------------------------------------------------------------------------
+

doc/susp_aaip_isofs_names.txt

@@ -22,6 +22,8 @@ Purpose:
       END is also the block address of the start of the checksum recording
       area in the image.
       See also isofs.cx .
+      This attribute shall eventually be attached to the root directory entry
+      and be global for the whole image.
 
 Format of Value:
       START_LEN | START_BYTES | END_LEN | END_BYTES |
@@ -150,7 +152,7 @@ Registered:
 -------------------------------------------------------------------------------
 
 This text is under
-Copyright (c) 2009 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+Copyright (c) 2009 - 2011 Thomas Schmitt <scdbackup@gmx.net>
 It shall only be modified in sync with libisofs and other software which
 makes use of AAIP. Please mail change requests to mailing list
 <libburn-hackers@pykix.org> or to the copyright holder in private.

libisofs/aaip-os-linux.c

@@ -295,9 +295,9 @@ ex:;
    aaip_get_acl_text("", &a_acl_text, 1 << 15); /* free */
  if(d_acl_text != NULL)
    aaip_get_acl_text("", &d_acl_text, 1 << 15); /* free */
+ if(list != NULL)
+   free(list);
  if(ret <= 0 || (flag & (1 << 15))) {
-   if(list != NULL)
-     free(list);
    if(*names != NULL) {
      for(i= 0; i < *num_attrs; i++)
        free((*names)[i]);

libisofs/buffer.h

@@ -11,7 +11,14 @@
 #define LIBISO_BUFFER_H_
 
 #include <stdlib.h>
+
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
 
 #define BLOCK_SIZE          2048
 

libisofs/ecma119.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -15,7 +15,14 @@
 #include "util.h"
 #include "buffer.h"
 
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+
 #include <pthread.h>
 
 #define BLOCK_SIZE      2048
@@ -32,11 +39,44 @@
  */
 #define ISO_EXTENT_SIZE             0xFFFFF800
 
+/*
+ * The maximum number of partition images that can be registered. Depending
+ * on the system area type, the effectively usable number may be smaller or
+ * even 0.
+ */
+#define ISO_MAX_PARTITIONS 8
+
+/*
+ * The cylindersize with SUN Disk Label
+ * (512 bytes/sector, 640 sectors/head, 1 head/cyl = 320 KiB).
+ * Expressed in ECMA-119 blocks of 2048 bytes/block.
+ */
+#define ISO_SUN_CYL_SIZE 160
+
+/*
+ * Maximum length of a disc label text plus 1.
+ */
+#define ISO_DISC_LABEL_SIZE 129
+
+
+/* The maximum lenght of an specs violating ECMA-119 file identifier.
+   The theoretical limit is  254 - 34 - 28 (len of SUSP CE entry) = 192
+   Currently the practical limit is 254 - 34 - 96 (non-CE RR entries) - 28 (CE)
+*/
+#ifdef Libisofs_with_rrip_rR
+#define ISO_UNTRANSLATED_NAMES_MAX 92
+#else
+#define ISO_UNTRANSLATED_NAMES_MAX 96
+#endif
+
+
 /**
  * Holds the options for the image generation.
  */
 struct iso_write_opts {
 
+    int will_cancel;
+
     int level; /**< ISO level to write at. (ECMA-119, 10) */
 
     /** Which extensions to support. */
@@ -54,6 +94,14 @@ struct iso_write_opts {
      * but it is supposed to work on most moderns systems. Use with caution.
      */
 
+    /**
+     * Convert directory names for ECMA-119 the same way as other file names
+     * but do not force dots or add version numbers.
+     * This violates ECMA-119 by allowing one "." and especially ISO level 1
+     * by allowing DOS style 8.3 names rather than only 8 characters.
+     */
+    unsigned int allow_dir_id_ext :1;
+
     /**
      * Omit the version number (";1") at the end of the ISO-9660 identifiers.
      * Version numbers are usually not used.
@@ -196,6 +244,26 @@ struct iso_write_opts {
     uid_t uid; /** uid to use when replace_uid == 2. */
     gid_t gid; /** gid to use when replace_gid == 2. */
 
+    /**
+     * See API call iso_write_opts_set_old_empty().
+     */ 
+    unsigned int old_empty :1;
+
+    /**
+     * Extra Caution: This option breaks any assumptions about names that
+     *                are supported by ECMA-119 specifications. 
+     * Omit any translation which would make a file name compliant to the
+     * ECMA-119 rules. This includes and exceeds omit_version_numbers,
+     * max_37_char_filenames, no_force_dots bit0, allow_lowercase.
+     * The maximum name length is given by this variable.
+     * There is a length limit of ISO_UNTRANSLATED_NAMES_MAX characters,
+     * because ECMA-119 allows 254 byte in a directory record, some
+     * of them are occupied by ECMA-119, some more are needed for SUSP CE,
+     * and some are fixely occupied by libisofs Rock Ridge code.
+     * The default value 0 disables this feature.
+     */
+    unsigned int untranslated_name_len;
+
     /**
      * 0 to use IsoNode timestamps, 1 to use recording time, 2 to use
      * values from timestamp field. This has only meaning if RR extensions
@@ -324,6 +392,25 @@ struct iso_write_opts {
     /* 1 to 255, 0= disabled/default */
     int partition_heads_per_cyl;
 
+#ifdef Libisofs_with_libjtE
+    /* Parameters and state of Jigdo Template Export environment.
+    */
+    struct libjte_env *libjte_handle;
+#endif /* Libisofs_with_libjtE */
+
+    /* A trailing padding of zero bytes which belongs to the image
+    */
+    uint32_t tail_blocks;
+
+    /* Eventual disk file paths of prepared images which shall be appended
+       after the ISO image and described by partiton table entries in a MBR
+    */
+    char *appended_partitions[ISO_MAX_PARTITIONS]; 
+    uint8_t appended_part_types[ISO_MAX_PARTITIONS];
+
+    /* Eventual name of the non-ISO aspect of the image. E.g. SUN ASCII label.
+     */
+    char ascii_disc_label[ISO_DISC_LABEL_SIZE];
 };
 
 typedef struct ecma119_image Ecma119Image;
@@ -335,9 +422,13 @@ typedef struct Iso_Image_Writer IsoImageWriter;
 
 struct ecma119_image
 {
+    int refcount;
+
     IsoImage *image;
     Ecma119Node *root;
 
+    int will_cancel :1;
+
     unsigned int iso_level :2;
 
     /* extensions */
@@ -354,6 +445,7 @@ struct ecma119_image
     unsigned int always_gmt :1;
 
     /* relaxed constraints */
+    unsigned int allow_dir_id_ext :1;
     unsigned int omit_version_numbers :2;
     unsigned int allow_deep_paths :1;
     unsigned int allow_longer_paths :1;
@@ -398,6 +490,9 @@ struct ecma119_image
     mode_t dir_mode;
     time_t timestamp;
 
+    unsigned int old_empty :1;
+    unsigned int untranslated_name_len;
+
     /**
      *  if sort files or not. Sorting is based of the weight of each file
      */
@@ -425,6 +520,17 @@ struct ecma119_image
      */
     uint32_t curblock;
 
+    /*
+     * The address to be used for the content pointer of empty data files.
+     */
+    uint32_t empty_file_block;
+
+    /*
+     * The calculated block address after ECMA-119 tree and eventual
+     * tree checksum tag.
+     */
+    uint32_t tree_end_block;
+
     /*
      * number of dirs in ECMA-119 tree, computed together with dir position,
      * and needed for path table computation in a efficient way
@@ -469,14 +575,27 @@ struct ecma119_image
      */
     char *system_area_data;
     /*
-     * bit0= make bytes 446 - 512 of the system area a partition
+     * bit0= Only with DOS MBR
+     *       Make bytes 446 - 512 of the system area a partition
      *       table which reserves partition 1 from byte 63*512 to the
      *       end of the ISO image. Assumed are 63 secs/hed, 255 head/cyl.
      *       (GRUB protective msdos label.)
      *       This works with and without system_area_data.
-     * bit1= apply isohybrid MBR patching to the system area.
+     * bit1= Only with DOS MBR
+     *       Apply isohybrid MBR patching to the system area.
      *       This works only with system_area_data plus ISOLINUX boot image
      *       and only if not bit0 is set.
+     * bit2-7= System area type
+     *       0= DOS MBR
+     *       1= MIPS Big Endian Volume Header
+     *       2= DEC Boot Block for MIPS Little Endian
+     *       3= SUN Disk Label for SUN SPARC
+     * bit8-9= Only with DOS MBR
+     *       Cylinder alignment mode eventually pads the image to make it
+     *       end at a cylinder boundary.
+     *       0 = auto (align if bit1)
+     *       1 = always align to cylinder boundary
+     *       2 = never align to cylinder boundary
      */
     int system_area_options;
 
@@ -493,7 +612,7 @@ struct ecma119_image
      * file data is written in the first 64 KiB, that are the bytes we usually
      * overwrite.
      */
-    uint32_t pad_blocks;
+    uint32_t mspad_blocks;
 
     size_t nwriters;
     IsoImageWriter **writers;
@@ -531,6 +650,7 @@ struct ecma119_image
 
     /* writer thread descriptor */
     pthread_t wthread;
+    int wthread_is_running;
     pthread_attr_t th_attr;
 
     /* User settable PVD time stamps */
@@ -567,6 +687,27 @@ struct ecma119_image
     uint32_t j_part_l_path_table_pos;
     uint32_t j_part_m_path_table_pos;
 
+#ifdef Libisofs_with_libjtE
+    struct libjte_env *libjte_handle;
+#endif /* Libisofs_with_libjtE */
+
+    uint32_t tail_blocks;
+
+    /* Memorized ELF parameters from MIPS Little Endian boot file */
+    uint32_t mipsel_e_entry;
+    uint32_t mipsel_p_offset;
+    uint32_t mipsel_p_vaddr;
+    uint32_t mipsel_p_filesz;
+
+    char *appended_partitions[ISO_MAX_PARTITIONS]; 
+    uint8_t appended_part_types[ISO_MAX_PARTITIONS];
+    /* Counted in blocks of 2048 */
+    uint32_t appended_part_prepad[ISO_MAX_PARTITIONS];
+    uint32_t appended_part_start[ISO_MAX_PARTITIONS];
+    uint32_t appended_part_size[ISO_MAX_PARTITIONS];
+
+    char ascii_disc_label[ISO_DISC_LABEL_SIZE];
+
 };
 
 #define BP(a,b) [(b) - (a) + 1]

libisofs/ecma119_tree.c

@@ -12,6 +12,9 @@
 #include "../config.h"
 #endif
 
+/* Must be before ecma119.h because of eventual Libisofs_with_rrip_rR */
+#include "libisofs.h"
+
 #include "ecma119_tree.h"
 #include "ecma119.h"
 #include "node.h"
@@ -29,7 +32,7 @@
 static
 int get_iso_name(Ecma119Image *img, IsoNode *iso, char **name)
 {
-    int ret, relaxed;
+    int ret, relaxed, free_ascii_name= 0, force_dots = 0, max_len;
     char *ascii_name;
     char *isoname= NULL;
 
@@ -38,9 +41,16 @@ int get_iso_name(Ecma119Image *img, IsoNode *iso, char **name)
         return ISO_SUCCESS;
     }
 
-    ret = str2ascii(img->input_charset, iso->name, &ascii_name);
+    if (img->untranslated_name_len > 0) {
+        ascii_name = iso->name;
+        ret = 1;
+    } else {
+        ret = str2ascii(img->input_charset, iso->name, &ascii_name);
+        free_ascii_name = 1;
+    }
     if (ret < 0) {
-        iso_msg_submit(img->image->id, ret, 0, "Can't convert %s", iso->name);
+        iso_msg_submit(img->image->id, ret, 0,
+                       "Cannot convert name '%s' to ASCII", iso->name);
         return ret;
     }
 
@@ -49,8 +59,18 @@ int get_iso_name(Ecma119Image *img, IsoNode *iso, char **name)
     } else {
         relaxed = (int)img->allow_lowercase;
     }
-    if (iso->type == LIBISO_DIR) {
+    if (iso->type == LIBISO_DIR && !(img->allow_dir_id_ext)) {
-        if (img->max_37_char_filenames) {
+        if (img->untranslated_name_len > 0) {
+            if (strlen(ascii_name) > img->untranslated_name_len) {
+needs_transl:;
+                iso_msg_submit(img->image->id, ISO_NAME_NEEDS_TRANSL, 0,
+              "File name too long (%d > %d) for untranslated recording:  '%s'",
+                               strlen(ascii_name), img->untranslated_name_len,
+                               ascii_name);
+                return ISO_NAME_NEEDS_TRANSL;
+            }
+            isoname = strdup(ascii_name);
+        } else if (img->max_37_char_filenames) {
             isoname = iso_r_dirid(ascii_name, 37, relaxed);
         } else if (img->iso_level == 1) {
             if (relaxed) {
@@ -60,32 +80,40 @@ int get_iso_name(Ecma119Image *img, IsoNode *iso, char **name)
             }
         } else {
             if (relaxed) {
-                isoname = iso_r_dirid(ascii_name, 8, relaxed);
+                isoname = iso_r_dirid(ascii_name, 31, relaxed);
             } else {
                 isoname = iso_2_dirid(ascii_name);
             }
         }
     } else {
-        if (img->max_37_char_filenames) {
+        force_dots = !((img->no_force_dots & 1) || iso->type == LIBISO_DIR);
-            isoname = iso_r_fileid(ascii_name, 36, relaxed,
+        if (img->untranslated_name_len > 0) {
-                                   (img->no_force_dots & 1) ? 0 : 1);
+            if (strlen(ascii_name) > img->untranslated_name_len)
+                goto needs_transl;
+            isoname = strdup(ascii_name);
+        } else if (img->max_37_char_filenames) {
+            isoname = iso_r_fileid(ascii_name, 36, relaxed, force_dots);
         } else if (img->iso_level == 1) {
-            if (relaxed) {
+            if (relaxed || !force_dots) {
-                isoname = iso_r_fileid(ascii_name, 11, relaxed,
+                if (strchr(ascii_name, '.') == NULL)
-                                       (img->no_force_dots & 1) ? 0 : 1);
+                    max_len = 8;
+                else
+                    max_len = 11;
+                isoname = iso_r_fileid(ascii_name, max_len, relaxed,
+                                       force_dots);
             } else {
                 isoname = iso_1_fileid(ascii_name);
             }
         } else {
-            if (relaxed) {
+            if (relaxed || !force_dots) {
-                isoname = iso_r_fileid(ascii_name, 30, relaxed,
+                isoname = iso_r_fileid(ascii_name, 30, relaxed, force_dots);
-                                       (img->no_force_dots & 1) ? 0 : 1);
             } else {
                 isoname = iso_2_fileid(ascii_name);
             }
         }
     }
-    free(ascii_name);
+    if (free_ascii_name)
+        free(ascii_name);
     if (isoname != NULL) {
         *name = isoname;
         return ISO_SUCCESS;
@@ -416,8 +444,6 @@ int create_tree(Ecma119Image *image, IsoNode *iso, Ecma119Node **tree,
                                    !!hidden);
                 if (cret < 0) {
                     /* error */
-                    if (!hidden)
-                        ecma119_node_free(node);
                     ret = cret;
                     break;
                 } else if (cret == ISO_SUCCESS && !hidden) {
@@ -537,6 +563,18 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
             continue;
         }
 
+        if (img->untranslated_name_len) {
+            /* This should not happen because no two IsoNode names should be
+               identical and only unaltered IsoNode names should be seen here.
+               Thus the Ema119Node names should be unique.
+            */
+            iso_msg_submit(img->image->id, ISO_NAME_NEEDS_TRANSL, 0,
+                           "ECMA-119 file name collision: '%s'",
+                           children[i]->iso_name);
+            ret = ISO_NAME_NEEDS_TRANSL;
+            goto mangle_cleanup;
+        }
+
         /*
          * A max of 7 characters is good enought, it allows handling up to
          * 9,999,999 files with same name. We can increment this to
@@ -553,10 +591,11 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
 
             /* compute name and extension */
             dot = strrchr(full_name, '.');
-            if (dot != NULL && children[i]->type != ECMA119_DIR) {
+            if (dot != NULL &&
+                (children[i]->type != ECMA119_DIR || img->allow_dir_id_ext)) {
 
                 /*
-                 * File (not dir) with extension
+                 * File (normally not dir) with extension
                  * Note that we don't need to check for placeholders, as
                  * tree reparent happens later, so no placeholders can be
                  * here at this time.
@@ -596,10 +635,10 @@ int mangle_single_dir(Ecma119Image *img, Ecma119Node *dir, int max_file_len,
                     name[max] = '\0';
                 }
             } else {
-                /* Directory, or file without extension */
+                /* Directory (normally), or file without extension */
                 if (children[i]->type == ECMA119_DIR) {
                     max = max_dir_len - digits;
-                    dot = NULL; /* dots have no meaning in dirs */
+                    dot = NULL; /* dots (normally) have no meaning in dirs */
                 } else {
                     max = max_file_len - digits;
                 }
@@ -716,7 +755,9 @@ int mangle_tree(Ecma119Image *img, int recurse)
     int max_file, max_dir;
     Ecma119Node *root;
 
-    if (img->max_37_char_filenames) {
+    if (img->untranslated_name_len > 0) {
+        max_file = max_dir = img->untranslated_name_len;
+    } else if (img->max_37_char_filenames) {
         max_file = max_dir = 37;
     } else if (img->iso_level == 1) {
         max_file = 12; /* 8 + 3 + 1 */
@@ -1033,11 +1074,12 @@ int match_hardlinks(Ecma119Image *img, Ecma119Node *dir, int flag)
     iso_node_get_id(nodes[0]->node, &fs_id, &dev_id, &img_ino, 1);
     family_start = 0;
     for (i = 1; i < node_count; i++) {
-        if (ecma119_node_cmp_hard(nodes + (i - 1), nodes + i) == 0) {
+        if (nodes[i]->type != ECMA119_DIR &&
+            ecma119_node_cmp_hard(nodes + (i - 1), nodes + i) == 0) {
             /* Still in same ino family */
             if (img_ino == 0) { /* Just in case any member knows its img_ino */
                 iso_node_get_id(nodes[0]->node, &fs_id, &dev_id, &img_ino, 1);
-           }
+            }
     continue;
         }
         family_set_ino(img, nodes, family_start, i, img_ino, prev_ino, 0);
@@ -1109,3 +1151,35 @@ int ecma119_tree_create(Ecma119Image *img)
 
     return ISO_SUCCESS;
 }
+
+/**
+ * Search the tree for a certain IsoNode and return its owning Ecma119Node
+ * or NULL.
+ */
+static
+Ecma119Node *search_iso_node(Ecma119Node *root, IsoNode *node)
+{
+    size_t i;
+    Ecma119Node *res = NULL;
+
+    if (root->node == node)
+        return root;
+    for (i = 0; i < root->info.dir->nchildren && res == NULL; i++) {
+        if (root->info.dir->children[i]->type == ECMA119_DIR)
+            res = search_iso_node(root->info.dir->children[i], node);
+        else if (root->info.dir->children[i]->node == node)
+            res = root->info.dir->children[i];
+    }
+    return res;
+}
+
+
+Ecma119Node *ecma119_search_iso_node(Ecma119Image *img, IsoNode *node)
+{
+    Ecma119Node *res = NULL;
+
+    if (img->root != NULL)
+        res = search_iso_node(img->root, node);
+    return res;
+}
+

libisofs/ecma119_tree.h

@@ -90,4 +90,11 @@ int ecma119_tree_create(Ecma119Image *img);
  */
 void ecma119_node_free(Ecma119Node *node);
 
+/**
+ * Search the tree for a certain IsoNode and return its owning Ecma119Node
+ * or NULL.
+ */
+Ecma119Node *ecma119_search_iso_node(Ecma119Image *img, IsoNode *node);
+
+
 #endif /*LIBISO_ECMA119_TREE_H_*/

libisofs/eltorito.c

@@ -12,8 +12,8 @@
 #include "../config.h"
 #endif
 
+#include "libisofs.h"
 #include "eltorito.h"
-#include "stream.h"
 #include "fsource.h"
 #include "filesrc.h"
 #include "image.h"
@@ -309,6 +309,7 @@ int create_image(IsoImage *image, const char *image_path,
     int boot_media_type = 0;
     int load_sectors = 0; /* number of sector to load */
     unsigned char partition_type = 0;
+    off_t size;
     IsoNode *imgfile;
     IsoStream *stream;
 
@@ -317,6 +318,9 @@ int create_image(IsoImage *image, const char *image_path,
         return ret;
     }
     if (ret == 0) {
+        iso_msg_submit(image->id, ISO_NODE_DOESNT_EXIST, 0,
+                       "El Torito boot image file missing in ISO image: '%s'",
+                       image_path);
         return ISO_NODE_DOESNT_EXIST;
     }
 
@@ -331,9 +335,16 @@ int create_image(IsoImage *image, const char *image_path,
         return ISO_BOOT_IMAGE_NOT_VALID;
     }
 
+    size = iso_stream_get_size(stream);
+    if (size <= 0) {
+        iso_msg_submit(image->id, ISO_BOOT_IMAGE_NOT_VALID, 0,
+                       "Boot image file is empty");
+        return ISO_BOOT_IMAGE_NOT_VALID;
+    }
+
     switch (type) {
     case ELTORITO_FLOPPY_EMUL:
-        switch (iso_stream_get_size(stream)) {
+        switch (size) {
         case 1200 * 1024:
             boot_media_type = 1; /* 1.2 meg diskette */
             break;
@@ -471,6 +482,9 @@ int iso_image_set_boot_image(IsoImage *image, const char *image_path,
             catname[0] = '\0';
             ret = iso_tree_path_to_node(image, catdir, &p);
             if (ret <= 0) {
+                iso_msg_submit(image->id, ISO_NODE_DOESNT_EXIST, 0,
+         "Cannot find directory for El Torito boot catalog in ISO image: '%s'",
+                               catdir);
                 free(catdir);
                 return ret < 0 ? ret : ISO_NODE_DOESNT_EXIST;
             }
@@ -1150,7 +1164,6 @@ int eltorito_writer_write_vol_desc(IsoImageWriter *writer)
 
     t = writer->target;
     cat = t->catalog;
-
     iso_msg_debug(t->image->id, "Write El-Torito boot record");
 
     memset(&vol, 0, sizeof(struct ecma119_boot_rec_vol_desc));

libisofs/filesrc.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
+ *               2010 - 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -11,6 +12,7 @@
 #include "../config.h"
 #endif
 
+#include "libisofs.h"
 #include "filesrc.h"
 #include "node.h"
 #include "util.h"
@@ -25,6 +27,21 @@
 #include <limits.h>
 
 
+#ifdef Xorriso_standalonE
+
+#ifdef Xorriso_with_libjtE
+#include "../libjte/libjte.h"
+#endif
+
+#else
+
+#ifdef Libisofs_with_libjtE
+#include <libjte/libjte.h>
+#endif
+
+#endif /* ! Xorriso_standalonE */
+
+
 #ifndef PATH_MAX
 #define PATH_MAX Libisofs_default_path_maX
 #endif
@@ -215,6 +232,12 @@ int filesrc_writer_compute_data_blocks(IsoImageWriter *writer)
 
     t = writer->target;
 
+    /* Normally reserve a single zeroed block for all files which have
+       no block address: symbolic links, device files, empty data files.
+    */
+    if (! t->old_empty)
+        t->curblock++;
+
     /* on appendable images, ms files shouldn't be included */
     if (t->appendable) {
         inc_item = is_ms_file;
@@ -249,7 +272,12 @@ int filesrc_writer_compute_data_blocks(IsoImageWriter *writer)
         /*
          * final section
          */
-        file->sections[extent].block = t->curblock + extent * (ISO_EXTENT_SIZE / BLOCK_SIZE);
+        if (section_size <= 0) {
+            file->sections[extent].block = t->empty_file_block;
+        } else {
+            file->sections[extent].block =
+                         t->curblock + extent * (ISO_EXTENT_SIZE / BLOCK_SIZE);
+        }
         file->sections[extent].size = (uint32_t)section_size;
 
         t->curblock += DIV_UP(iso_file_src_get_size(file), BLOCK_SIZE);
@@ -317,16 +345,30 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
     void *ctx= NULL;
     char md5[16], pre_md5[16];
     int pre_md5_valid = 0;
+#ifdef Libisofs_with_libjtE
+    int jte_begun = 0;
+#endif
 
     if (writer == NULL) {
         return ISO_ASSERT_FAILURE;
     }
 
+    memset(buffer, 0, BLOCK_SIZE);
     t = writer->target;
     filelist = writer->data;
 
     iso_msg_debug(t->image->id, "Writing Files...");
 
+    /* Normally write a single zeroed block as block address target for all
+       files which have no block address:
+       symbolic links, device files, empty data files.
+    */
+    if (! t->old_empty) {
+        ret = iso_write(t, buffer, BLOCK_SIZE);
+        if (ret < 0)
+            goto ex;
+    }
+
     i = 0;
     while ((file = filelist[i++]) != NULL) {
         was_error = 0;
@@ -380,6 +422,23 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
         }
 #endif
 
+#ifdef Libisofs_with_libjtE
+        if (t->libjte_handle != NULL) {
+            res = libjte_begin_data_file(t->libjte_handle, name,
+                                         BLOCK_SIZE, file_size);
+            if (res <= 0) {
+                res = iso_libjte_forward_msgs(t->libjte_handle, t->image->id,
+                                        ISO_LIBJTE_FILE_FAILED, 0);
+                if (res < 0) {
+                    filesrc_close(file);
+                    ret = ISO_LIBJTE_FILE_FAILED;
+                    goto ex;
+                }
+            }
+            jte_begun = 1;
+        }
+#endif /* Libisofs_with_libjtE */
+
         if (file->checksum_index > 0) {
             /* initialize file checksum */
             res = iso_md5_start(&ctx);
@@ -481,12 +540,35 @@ int filesrc_writer_write_data(IsoImageWriter *writer)
             /* Write md5 into checksum buffer at file->checksum_index */
             memcpy(t->checksum_buffer + 16 * file->checksum_index, md5, 16);
         }
+
+#ifdef Libisofs_with_libjtE
+        if (t->libjte_handle != NULL) {
+            res = libjte_end_data_file(t->libjte_handle);
+            if (res <= 0) {
+                iso_libjte_forward_msgs(t->libjte_handle, t->image->id,
+                                        ISO_LIBJTE_FILE_FAILED, 0);
+                ret = ISO_LIBJTE_FILE_FAILED;
+                goto ex;
+            }
+            jte_begun = 0;
+        }
+#endif /* Libisofs_with_libjtE */
+
     }
 
     ret = ISO_SUCCESS;
 ex:;
     if (ctx != NULL) /* avoid any memory leak */
         iso_md5_end(&ctx, md5);
+
+#ifdef Libisofs_with_libjtE
+    if (jte_begun) {
+        libjte_end_data_file(t->libjte_handle);
+        iso_libjte_forward_msgs(t->libjte_handle, t->image->id,
+                                ISO_LIBJTE_END_FAILED, 0);
+    }
+#endif /* Libisofs_with_libjtE */
+
     return ret;
 }
 

libisofs/filesrc.h

@@ -13,7 +13,13 @@
 #include "stream.h"
 #include "ecma119.h"
 
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
 
 struct Iso_File_Src
 {

libisofs/filters/external.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  * 
  * This file is part of the libisofs project; you can redistribute it and/or 
  * modify it under the terms of the GNU General Public License version 2 
@@ -20,6 +20,7 @@
 #include "../libisofs.h"
 #include "../filter.h"
 #include "../fsource.h"
+#include "../stream.h"
 
 #include <sys/types.h>
 #include <sys/time.h>
@@ -40,7 +41,7 @@
  * for classical pipe filtering.
  */
 
-
+/* IMPORTANT: Any change must be reflected by extf_clone_stream() */
 /*
  * Individual runtime properties exist only as long as the stream is opened.
  */
@@ -598,6 +599,36 @@ IsoStream *extf_get_input_stream(IsoStream *stream, int flag)
     return data->orig;
 }
 
+static
+int extf_clone_stream(IsoStream *old_stream, IsoStream **new_stream, int flag)
+{
+    int ret;
+    IsoStream *new_input_stream, *stream;
+    ExternalFilterStreamData *stream_data, *old_stream_data;
+    
+    if (flag)
+        return ISO_STREAM_NO_CLONE; /* unknown option required */
+
+    stream_data = calloc(1, sizeof(ExternalFilterStreamData));
+    if (stream_data == NULL)
+        return ISO_OUT_OF_MEM;
+    ret = iso_stream_clone_filter_common(old_stream, &stream,
+                                         &new_input_stream, 0);
+    if (ret < 0) {
+        free((char *) stream_data);
+        return ret;
+    }
+    old_stream_data = (ExternalFilterStreamData *) old_stream->data;
+    stream_data->id = ++extf_ino_id;
+    stream_data->orig = new_input_stream;
+    stream_data->cmd = old_stream_data->cmd;
+    stream_data->cmd->refcount++;
+    stream_data->size = old_stream_data->size;
+    stream_data->running = NULL;
+    stream->data = stream_data;
+    *new_stream = stream;
+    return ISO_SUCCESS;
+}
 
 static
 int extf_cmp_ino(IsoStream *s1, IsoStream *s2);
@@ -605,7 +636,7 @@ int extf_cmp_ino(IsoStream *s1, IsoStream *s2);
 
 
 IsoStreamIface extf_stream_class = {
-    3,
+    4,
     "extf",
     extf_stream_open,
     extf_stream_close,
@@ -616,7 +647,8 @@ IsoStreamIface extf_stream_class = {
     extf_stream_free,
     extf_update_size,
     extf_get_input_stream,
-    extf_cmp_ino
+    extf_cmp_ino,
+    extf_clone_stream
 };
 
 

libisofs/filters/gzip.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  * 
  * This file is part of the libisofs project; you can redistribute it and/or 
  * modify it under the terms of the GNU General Public License version 2 
@@ -25,6 +25,7 @@
 #include "../filter.h"
 #include "../fsource.h"
 #include "../util.h"
+#include "../stream.h"
 
 #include <sys/types.h>
 #include <sys/time.h>
@@ -153,6 +154,7 @@ static int gzip_compression_level = 6;
 /*
  * The data payload of an individual Gzip Filter IsoStream
  */
+/* IMPORTANT: Any change must be reflected by gzip_clone_stream() */
 typedef struct
 {
     IsoStream *orig;
@@ -529,12 +531,51 @@ IsoStream *gzip_get_input_stream(IsoStream *stream, int flag)
 }
 
 
+static
+int gzip_clone_stream(IsoStream *old_stream, IsoStream **new_stream, int flag)
+{
+
+#ifdef Libisofs_with_zliB
+
+    int ret;
+    IsoStream *new_input_stream, *stream;
+    GzipFilterStreamData *stream_data, *old_stream_data;
+
+    if (flag)
+        return ISO_STREAM_NO_CLONE; /* unknown option required */
+
+    stream_data = calloc(1, sizeof(GzipFilterStreamData));
+    if (stream_data == NULL)
+        return ISO_OUT_OF_MEM;
+    ret = iso_stream_clone_filter_common(old_stream, &stream,
+                                         &new_input_stream, 0);
+    if (ret < 0) {
+        free((char *) stream_data);
+        return ret;
+    }
+    old_stream_data = (GzipFilterStreamData *) old_stream->data;
+    stream_data->orig = new_input_stream;
+    stream_data->size = old_stream_data->size;
+    stream_data->running = NULL;
+    stream_data->id = ++gzip_ino_id;
+    stream->data = stream_data;
+    *new_stream = stream;
+    return ISO_SUCCESS;
+
+#else /* Libisofs_with_zliB */
+
+    return ISO_STREAM_NO_CLONE;
+
+#endif /* ! Libisofs_with_zliB */
+
+}
+
 static
 int gzip_cmp_ino(IsoStream *s1, IsoStream *s2);
 
 
 IsoStreamIface gzip_stream_compress_class = {
-    3,
+    4,
     "gzip",
     gzip_stream_open,
     gzip_stream_close,
@@ -545,12 +586,13 @@ IsoStreamIface gzip_stream_compress_class = {
     gzip_stream_free,
     gzip_update_size,
     gzip_get_input_stream,
-    gzip_cmp_ino
+    gzip_cmp_ino,
+    gzip_clone_stream
 };
 
 
 IsoStreamIface gzip_stream_uncompress_class = {
-    3,
+    4,
     "pizg",
     gzip_stream_open,
     gzip_stream_close,
@@ -561,7 +603,8 @@ IsoStreamIface gzip_stream_uncompress_class = {
     gzip_stream_free,
     gzip_update_size,
     gzip_get_input_stream,
-    gzip_cmp_ino
+    gzip_cmp_ino,
+    gzip_clone_stream
 };
 
     

libisofs/filters/zisofs.c

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  * 
  * This file is part of the libisofs project; you can redistribute it and/or 
  * modify it under the terms of the GNU General Public License version 2 
@@ -22,6 +22,7 @@
 #include "../filter.h"
 #include "../fsource.h"
 #include "../util.h"
+#include "../stream.h"
 
 #include <sys/types.h>
 #include <sys/time.h>
@@ -167,6 +168,7 @@ static int ziso_compression_level = 6;
 
 /*
  * The common data payload of an individual Zisofs Filter IsoStream
+ * IMPORTANT: Any change must be reflected by ziso_clone_stream().
  */
 typedef struct
 {
@@ -183,6 +185,7 @@ typedef struct
 
 /*
  * The data payload of an individual Zisofs Filter Compressor IsoStream
+ * IMPORTANT: Any change must be reflected by ziso_clone_stream().
  */
 typedef struct
 {   
@@ -198,6 +201,7 @@ typedef struct
 
 /*
  * The data payload of an individual Zisofs Filter Uncompressor IsoStream
+ * IMPORTANT: Any change must be reflected by ziso_clone_stream().
  */
 typedef struct
 {
@@ -779,13 +783,63 @@ IsoStream *ziso_get_input_stream(IsoStream *stream, int flag)
     return data->orig;
 }
 
+static
+int ziso_clone_stream(IsoStream *old_stream, IsoStream **new_stream, int flag)
+{
+    int ret;
+    IsoStream *new_input_stream = NULL, *stream = NULL;
+    ZisofsFilterStreamData *stream_data, *old_stream_data;
+    ZisofsUncomprStreamData *uncompr, *old_uncompr;
+    ZisofsComprStreamData *compr, *old_compr;
+
+    if (flag)
+        return ISO_STREAM_NO_CLONE; /* unknown option required */
+
+    ret = iso_stream_clone_filter_common(old_stream, &stream,
+                                         &new_input_stream, 0);
+    if (ret < 0)
+        return ret;
+
+    if (old_stream->class->read == &ziso_stream_uncompress) {
+        uncompr = calloc(1, sizeof(ZisofsUncomprStreamData));
+        if (uncompr == NULL)
+            goto no_mem;
+        stream_data = (ZisofsFilterStreamData *) uncompr;
+        old_uncompr = (ZisofsUncomprStreamData *) old_stream->data;
+        uncompr->header_size_div4 = old_uncompr->header_size_div4;
+        uncompr->block_size_log2 = old_uncompr->block_size_log2;
+    } else {
+        compr = calloc(1, sizeof(ZisofsComprStreamData));
+        if (compr == NULL)
+            goto no_mem;
+        stream_data = (ZisofsFilterStreamData *) compr;
+        old_compr = (ZisofsComprStreamData *) old_stream->data;
+        compr->orig_size = old_compr->orig_size;
+        compr->block_pointers = NULL;
+    }
+    old_stream_data = (ZisofsFilterStreamData *) old_stream->data;
+    stream_data->orig = new_input_stream;
+    stream_data->size = old_stream_data->size;
+    stream_data->running = NULL;
+    stream_data->id = ++ziso_ino_id;
+    stream->data = stream_data;
+    *new_stream = stream;
+    return ISO_SUCCESS;
+no_mem:
+    if (new_input_stream != NULL)
+        iso_stream_unref(new_input_stream);
+    if (stream != NULL)
+        iso_stream_unref(stream);
+    return ISO_OUT_OF_MEM;
+}
+
 
 static
 int ziso_cmp_ino(IsoStream *s1, IsoStream *s2);
 
 
 IsoStreamIface ziso_stream_compress_class = {
-    3,
+    4,
     "ziso",
     ziso_stream_open,
     ziso_stream_close,
@@ -796,12 +850,13 @@ IsoStreamIface ziso_stream_compress_class = {
     ziso_stream_free,
     ziso_update_size,
     ziso_get_input_stream,
-    ziso_cmp_ino
+    ziso_cmp_ino,
+    ziso_clone_stream
 };
 
 
 IsoStreamIface ziso_stream_uncompress_class = {
-    3,
+    4,
     "osiz",
     ziso_stream_open,
     ziso_stream_close,
@@ -812,7 +867,8 @@ IsoStreamIface ziso_stream_uncompress_class = {
     ziso_stream_free,
     ziso_update_size,
     ziso_get_input_stream,
-    ziso_cmp_ino
+    ziso_cmp_ino,
+    ziso_clone_stream
 };
 
 

libisofs/fs_image.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 - 2010 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -72,7 +72,7 @@ struct iso_read_opts
     unsigned int nojoliet : 1; /*< Do not read Joliet extensions */
     unsigned int noiso1999 : 1; /*< Do not read ISO 9660:1999 enhanced tree */
     unsigned int noaaip : 1; /* Do not read AAIP extension for xattr and ACL */
-    unsigned int nomd5 : 1;  /* Do not read MD5 array */
+    unsigned int nomd5 : 2;  /* Do not read MD5 array */
 
     /**
      * Hand out new inode numbers and overwrite eventually read PX inode
@@ -267,7 +267,7 @@ typedef struct
     int aaip_load;
 
     /** Whether the MD5 array shall be read if available.
-     *  1 = yes , 0 = no
+     *  2 = yes, but do not check tags , 1 = yes , 0 = no
      */
     int md5_load;
 
@@ -317,6 +317,7 @@ typedef struct
 
 typedef struct image_fs_data ImageFileSourceData;
 
+/* IMPORTANT: Any change must be reflected by ifs_clone_src */
 struct image_fs_data
 {
     IsoImageFilesystem *fs; /**< reference to the image it belongs to */
@@ -1043,10 +1044,87 @@ int ifs_get_aa_string(IsoFileSource *src, unsigned char **aa_string, int flag)
     return 1;
 }
 
+static
+int ifs_clone_src(IsoFileSource *old_source,
+                  IsoFileSource **new_source, int flag)
+{
+    IsoFileSource *src = NULL;
+    ImageFileSourceData *old_data, *new_data = NULL;
+    char *new_name = NULL;
+    struct iso_file_section *new_sections = NULL;
+    void *new_aa_string = NULL;
+    int i, ret;
+
+    if (flag)
+        return ISO_STREAM_NO_CLONE; /* unknown option required */
+
+    old_data = (ImageFileSourceData *) old_source->data;
+    *new_source = NULL; 
+    src = calloc(1, sizeof(IsoFileSource));
+    if (src == NULL)
+        goto no_mem;
+    new_name = strdup(old_data->name);
+    if (new_name == NULL)
+        goto no_mem;
+    new_data = calloc(1, sizeof(ImageFileSourceData));
+
+    if (new_data == NULL)
+        goto no_mem;
+    if (old_data->nsections > 0) {
+        new_sections = calloc(old_data->nsections,
+                              sizeof(struct iso_file_section));
+        if (new_sections == NULL)
+            goto no_mem;
+    }
+    ret = aaip_xinfo_cloner(old_data->aa_string, &new_aa_string, 0);
+    if (ret < 0)
+        goto no_mem;
+
+    new_data->fs = old_data->fs;
+
+    new_data->parent = old_data->parent;
+
+    memcpy(&(new_data->info), &(old_data->info), sizeof(struct stat));
+    new_data->name = new_name;
+    new_data->sections = new_sections;
+    new_data->nsections = old_data->nsections;
+    for (i = 0; i < new_data->nsections; i++) 
+        memcpy(new_data->sections + i, old_data->sections + i,
+               sizeof(struct iso_file_section));
+    new_data->opened = old_data->opened;
+#ifdef Libisofs_with_zliB
+    new_data->header_size_div4 = old_data->header_size_div4;
+    new_data->block_size_log2 = old_data->block_size_log2;
+    new_data->uncompressed_size = old_data->uncompressed_size;
+#endif
+    new_data->data.content = NULL;
+    new_data->aa_string = (unsigned char *) new_aa_string;
+    
+    src->class = old_source->class;
+    src->refcount = 1;
+    src->data = new_data;
+    *new_source = src;
+    iso_file_source_ref(new_data->parent);
+    iso_filesystem_ref(new_data->fs);
+    return ISO_SUCCESS;
+no_mem:;
+    if (src != NULL)
+        free((char *) src);
+    if (new_data != NULL)
+        free((char *) new_data);
+    if (new_name != NULL)
+        free(new_name);
+    if (new_sections != NULL)
+        free((char *) new_sections);
+    if (new_aa_string != NULL)
+        aaip_xinfo_func(new_aa_string, 1);
+    return ISO_OUT_OF_MEM;
+}
+
 
 IsoFileSourceIface ifs_class = {
 
-    1, /* version */
+    2, /* version */
     ifs_get_path,
     ifs_get_name,
     ifs_lstat,
@@ -1060,7 +1138,8 @@ IsoFileSourceIface ifs_class = {
     ifs_get_filesystem,
     ifs_free,
     ifs_lseek,
-    ifs_get_aa_string
+    ifs_get_aa_string,
+    ifs_clone_src
 
 };
 
@@ -2339,6 +2418,10 @@ int iso_src_check_sb_tree(IsoDataSource *src, uint32_t start_lba, int flag)
             ret = iso_util_eval_md5_tag(block, desired, start_lba + i,
                                       ctx, start_lba, &tag_type, &next_tag, 0);
         iso_md5_compute(ctx, block, 2048);
+        if (ret == ISO_MD5_TAG_COPIED) { /* growing without emulated TOC */
+            ret = 2;
+            goto ex;
+        }
         if (ret == ISO_MD5_AREA_CORRUPTED || ret == ISO_MD5_TAG_MISMATCH)
             ret = ISO_SB_TREE_CORRUPTED;
         if (ret < 0)
@@ -2425,7 +2508,12 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
     data->dir_mode = opts->dir_mode & ~S_IFMT;
     data->msgid = msgid;
     data->aaip_load = !opts->noaaip;
-    data->md5_load = !opts->nomd5;
+    if (opts->nomd5 == 0)
+        data->md5_load = 1;
+    else if (opts->nomd5 == 2)
+        data->md5_load = 2;
+    else
+        data->md5_load = 0;
     data->aaip_version = -1;
     data->make_new_ino = opts->make_new_ino;
     data->num_bootimgs = 0;
@@ -2453,7 +2541,7 @@ int iso_image_filesystem_new(IsoDataSource *src, struct iso_read_opts *opts,
     ifs->free = ifs_fs_free;
 
     /* read Volume Descriptors and ensure it is a valid image */
-    if (data->md5_load) {
+    if (data->md5_load == 1) {
         /* From opts->block on : check for superblock and tree tags */;
         ret = iso_src_check_sb_tree(src, opts->block, 0);
         if (ret < 0) {
@@ -2796,8 +2884,17 @@ int image_builder_create_node(IsoNodeBuilder *builder, IsoImage *image,
                 break;
                 if (idx < fsdata->num_bootimgs) {
                     /* it is boot image node */
-
                     if (image->bootcat->bootimages[idx]->image != NULL) {
+                        /* idx is already occupied, try to find unoccupied one
+                           which has the same block address.
+                        */
+                        for (; idx < fsdata->num_bootimgs; idx++)
+                            if (fsdata->eltorito && data->sections[0].block ==
+                                fsdata->bootblocks[idx] &&
+                                image->bootcat->bootimages[idx]->image == NULL)
+                        break;
+                    }
+                    if (idx >= fsdata->num_bootimgs) {
                         ret = iso_msg_submit(image->id, ISO_EL_TORITO_WARN, 0,
              "More than one ISO node has been found for the same boot image.");
                         if (ret < 0) {
@@ -3146,6 +3243,8 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
     size_t size;
     void *ctx = NULL;
     char md5[16];
+    struct el_torito_boot_catalog *catalog = NULL;
+    ElToritoBootImage *boot_image = NULL;
 
     if (image == NULL || src == NULL || opts == NULL) {
         return ISO_NULL_POINTER;
@@ -3233,8 +3332,6 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
 
     /* if old image has el-torito, add a new catalog */
     if (data->eltorito) {
-        struct el_torito_boot_catalog *catalog;
-        ElToritoBootImage *boot_image= NULL;
 
         catalog = calloc(1, sizeof(struct el_torito_boot_catalog));
         if (catalog == NULL) {
@@ -3260,11 +3357,13 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
             memcpy(boot_image->selection_crit, data->selection_crits, 20);
 
             catalog->bootimages[catalog->num_bootimages] = boot_image;
+            boot_image = NULL;
             catalog->num_bootimages++;
         }
         for ( ; idx < Libisofs_max_boot_imageS; idx++)
             catalog->bootimages[idx] = NULL;
         image->bootcat = catalog;
+        catalog = NULL; /* So it does not get freed */
     }
 
     /* recursively add image */
@@ -3443,6 +3542,10 @@ int iso_image_import(IsoImage *image, IsoDataSource *src,
     image->fs = fsback;
     image->builder = blback;
 
+    if (catalog != NULL)
+        el_torito_boot_catalog_free(catalog);
+    if (boot_image != NULL)
+        free((char *) boot_image);
     iso_file_source_unref(newroot);
     fs->close(fs);
     iso_filesystem_unref(fs);
@@ -3594,7 +3697,7 @@ int iso_read_opts_set_no_md5(IsoReadOpts *opts, int no_md5)
     if (opts == NULL) {
         return ISO_NULL_POINTER;
     }
-    opts->nomd5 = no_md5 ? 1 : 0;
+    opts->nomd5 = no_md5 == 2 ? 2 : no_md5 == 1 ? 1 : 0;
     return ISO_SUCCESS;
 }
 

libisofs/fs_local.c

@@ -39,7 +39,7 @@ int iso_file_source_new_lfs(IsoFileSource *parent, const char *name,
  */
 IsoFilesystem *lfs= NULL;
 
-
+/* IMPORTANT: Any change must be reflected by lfs_clone_src() */
 typedef struct
 {
     /** reference to the parent (if root it points to itself) */
@@ -534,10 +534,56 @@ ex:;
     return ret;
 }
 
+static
+int lfs_clone_src(IsoFileSource *old_source,
+                  IsoFileSource **new_source, int flag)
+{
+    IsoFileSource *src = NULL;
+    char *new_name = NULL;
+    _LocalFsFileSource *old_data, *new_data = NULL;
+
+    if (flag)
+        return ISO_STREAM_NO_CLONE; /* unknown option required */
+
+    old_data = (_LocalFsFileSource *) old_source->data;
+    *new_source = NULL;  
+    src = calloc(1, sizeof(IsoFileSource));
+    if (src == NULL)
+        goto no_mem;
+    new_name = strdup(old_data->name);
+    if (new_name == NULL) 
+        goto no_mem;
+
+    new_data = calloc(1, sizeof(_LocalFsFileSource));
+    if (new_data == NULL)
+        goto no_mem;
+    new_data->openned = 0;
+    new_data->info.fd = -1; /* the value does not matter with (openned == 0) */
+    new_data->name = new_name;
+    new_data->parent = old_data->parent;
+
+    src->class = old_source->class;
+    src->refcount = 1;
+    src->data = new_data;
+    *new_source = src;
+
+    iso_file_source_ref(new_data->parent);
+    iso_filesystem_ref(lfs);
+    return ISO_SUCCESS;
+no_mem:;
+    if (src != NULL)
+        free((char *) src);
+    if (new_data != NULL)
+        free((char *) new_data);
+    if (new_name != NULL)
+        free(new_name);
+    return ISO_OUT_OF_MEM;
+}
+
 
 IsoFileSourceIface lfs_class = { 
 
-    1, /* version */
+    2, /* version */
     lfs_get_path,
     lfs_get_name,
     lfs_lstat,
@@ -551,7 +597,8 @@ IsoFileSourceIface lfs_class = {
     lfs_get_filesystem,
     lfs_free,
     lfs_lseek,
-    lfs_get_aa_string
+    lfs_get_aa_string,
+    lfs_clone_src
 
 };
 

libisofs/fsource.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  * 
  * This file is part of the libisofs project; you can redistribute it and/or 
  * modify it under the terms of the GNU General Public License version 2 
@@ -33,9 +33,16 @@
 int iso_local_filesystem_new(IsoFilesystem **fs);
 
 
-/* Rank two IsoFileSource by their eventual old image LBAs.
+/* Rank two IsoFileSource of ifs_class by their eventual old image LBAs.
    Other IsoFileSource classes will be ranked only roughly.
 */
 int iso_ifs_sections_cmp(IsoFileSource *s1, IsoFileSource *s2, int flag);
 
+
+/* Create an independent copy of an ifs_class IsoFileSource.
+*/
+int iso_ifs_source_clone(IsoFileSource *old_source, IsoFileSource **new_source,
+                         int flag);
+
+
 #endif /*LIBISO_FSOURCE_H_*/

libisofs/image.c

@@ -36,7 +36,7 @@
  */
 int iso_image_new(const char *name, IsoImage **image)
 {
-    int res;
+    int res, i;
     IsoImage *img;
 
     if (image == NULL) {
@@ -80,6 +80,9 @@ int iso_image_new(const char *name, IsoImage **image)
     }
     img->system_area_data = NULL;
     img->system_area_options = 0;
+    img->num_mips_boot_files = 0;
+    for (i = 0; i < 15; i++)
+         img->mips_boot_file_paths[i] = NULL;
     img->builder_ignore_acl = 1;
     img->builder_ignore_ea = 1;
     img->inode_counter = 0;
@@ -89,6 +92,7 @@ int iso_image_new(const char *name, IsoImage **image)
     img->checksum_end_lba = 0;
     img->checksum_idx_count = 0;
     img->checksum_array = NULL;
+    img->generator_is_running = 0;
     *image = img;
     return ISO_SUCCESS;
 }
@@ -102,7 +106,7 @@ void iso_image_ref(IsoImage *image)
 }
 
 /**
- * Decrements the reference couting of the given image.
+ * Decrements the reference counting of the given image.
  * If it reaches 0, the image is free, together with its tree nodes (whether
  * their refcount reach 0 too, of course).
  */
@@ -126,6 +130,7 @@ void iso_image_unref(IsoImage *image)
         iso_node_builder_unref(image->builder);
         iso_filesystem_unref(image->fs);
         el_torito_boot_catalog_free(image->bootcat);
+        iso_image_give_up_mips_boot(image, 0);
         free(image->volset_id);
         free(image->volume_id);
         free(image->publisher_id);
@@ -607,3 +612,46 @@ int iso_image_set_checksums(IsoImage *image, char *checksum_array,
     return 1;
 }
 
+int iso_image_generator_is_running(IsoImage *image)
+{
+    return image->generator_is_running;
+}
+
+
+/* API */
+int iso_image_add_mips_boot_file(IsoImage *image, char *path, int flag)
+{
+    if (image->num_mips_boot_files >= 15)
+        return ISO_BOOT_TOO_MANY_MIPS;
+    image->mips_boot_file_paths[image->num_mips_boot_files] = strdup(path);
+    if (image->mips_boot_file_paths[image->num_mips_boot_files] == NULL)
+        return ISO_OUT_OF_MEM;
+    image->num_mips_boot_files++;
+    return ISO_SUCCESS;
+}
+
+/* API */
+int iso_image_get_mips_boot_files(IsoImage *image, char *paths[15], int flag)
+{
+    int i;
+
+    for (i = 0; i < image->num_mips_boot_files; i++)
+         paths[i] = image->mips_boot_file_paths[i];
+    for (; i < 15; i++)
+         paths[i] = NULL;
+    return image->num_mips_boot_files;
+}
+
+/* API */
+int iso_image_give_up_mips_boot(IsoImage *image, int flag)
+{
+    int i;
+
+    for (i = 0; i < image->num_mips_boot_files; i++)
+        if (image->mips_boot_file_paths[i] != NULL) {
+            free(image->mips_boot_file_paths[i]);
+            image->mips_boot_file_paths[i] = NULL;
+        }
+    image->num_mips_boot_files = 0;
+    return ISO_SUCCESS;
+}

libisofs/image.h

@@ -58,6 +58,14 @@ struct Iso_Image
     /* Prescribed/detected options, see iso_write_opts_set_system_area() */
     int system_area_options;
 
+   /*
+    * Up to 15 boot files can be referred by a MIPS Big Endian Volume Header.
+      The mips_boot_file_paths are ISO 9660 Rock Ridge paths.
+    */
+    int num_mips_boot_files;
+    char *mips_boot_file_paths[15]; /* ISO 9660 Rock Ridge Paths */
+
+
     /* image identifier, for message origin identifier */
     int id;
 
@@ -166,6 +174,12 @@ struct Iso_Image
     uint32_t checksum_idx_count;
     char *checksum_array;
 
+    /**
+     * Whether a write run has been started by iso_image_create_burn_source()
+     * and has not yet been finished.
+     */
+    int generator_is_running;
+
 };
 
 

libisofs/joliet.c

@@ -248,7 +248,7 @@ int create_tree(Ecma119Image *t, IsoNode *iso, JolietNode **tree, int pathlen)
             char *ipath = iso_tree_get_node_path(iso);
             ret = iso_msg_submit(t->image->id, ISO_FILE_IGNORED, 0,
                  "Can't add %s to Joliet tree. %s can only be added to a "
-                 "Rock Ridget tree.", ipath, (iso->type == LIBISO_SYMLINK ?
+                 "Rock Ridge tree.", ipath, (iso->type == LIBISO_SYMLINK ?
                                              "Symlinks" : "Special files"));
             free(ipath);
         }

libisofs/libisofs.ver

@@ -1,5 +1,6 @@
 LIBISOFS6 {
 global:
+aaip_xinfo_cloner;
 aaip_xinfo_func;
 el_torito_get_bootable;
 el_torito_get_boot_media_type;
@@ -68,6 +69,7 @@ iso_get_local_charset;
 iso_get_messenger;
 iso_gzip_get_refcounts;
 iso_image_add_boot_image;
+iso_image_add_mips_boot_file;
 iso_image_attach_data;
 iso_image_create_burn_source;
 iso_image_filesystem_new;
@@ -80,6 +82,7 @@ iso_image_fs_get_publisher_id;
 iso_image_fs_get_system_id;
 iso_image_fs_get_volset_id;
 iso_image_fs_get_volume_id;
+iso_image_generator_is_running;
 iso_image_get_abstract_file_id;
 iso_image_get_all_boot_imgs;
 iso_image_get_application_id;
@@ -88,6 +91,7 @@ iso_image_get_biblio_file_id;
 iso_image_get_boot_image;
 iso_image_get_copyright_file_id;
 iso_image_get_data_preparer_id;
+iso_image_get_mips_boot_files;
 iso_image_get_msg_id;
 iso_image_get_publisher_id;
 iso_image_get_root;
@@ -96,6 +100,7 @@ iso_image_get_system_area;
 iso_image_get_system_id;
 iso_image_get_volset_id;
 iso_image_get_volume_id;
+iso_image_give_up_mips_boot;
 iso_image_import;
 iso_image_new;
 iso_image_ref;
@@ -129,6 +134,7 @@ iso_md5_compute;
 iso_md5_end;
 iso_md5_match;
 iso_md5_start;
+iso_memory_stream_new;
 iso_msgs_submit;
 iso_new_find_conditions_and;
 iso_new_find_conditions_atime;
@@ -151,6 +157,7 @@ iso_node_get_hidden;
 iso_node_get_mode;
 iso_node_get_mtime;
 iso_node_get_name;
+iso_node_get_next_xinfo;
 iso_node_get_old_image_lba;
 iso_node_get_parent;
 iso_node_get_permissions;
@@ -161,6 +168,8 @@ iso_node_get_xinfo;
 iso_node_lookup_attr;
 iso_node_ref;
 iso_node_remove;
+iso_node_remove_all_xinfo;
+iso_node_remove_tree;
 iso_node_remove_xinfo;
 iso_node_set_acl_text;
 iso_node_set_atime;
@@ -175,6 +184,8 @@ iso_node_set_sort_weight;
 iso_node_set_uid;
 iso_node_take;
 iso_node_unref;
+iso_node_xinfo_get_cloner;
+iso_node_xinfo_make_clonable;
 iso_node_zf_by_magic;
 iso_obtain_msgs;
 iso_read_image_features_destroy;
@@ -205,6 +216,7 @@ iso_set_local_charset;
 iso_set_msgs_severities;
 iso_sev_to_text;
 iso_special_get_dev;
+iso_stream_clone;
 iso_stream_close;
 iso_stream_cmp_ino;
 iso_stream_get_external_filter;
@@ -230,6 +242,7 @@ iso_tree_add_new_node;
 iso_tree_add_new_special;
 iso_tree_add_new_symlink;
 iso_tree_add_node;
+iso_tree_clone;
 iso_tree_get_follow_symlinks;
 iso_tree_get_ignore_hidden;
 iso_tree_get_ignore_special;
@@ -243,12 +256,15 @@ iso_tree_set_ignore_special;
 iso_tree_set_replace_mode;
 iso_tree_set_report_callback;
 iso_util_decode_md5_tag;
+iso_write_opts_attach_jte;
+iso_write_opts_detach_jte;
 iso_write_opts_free;
 iso_write_opts_get_data_start;
 iso_write_opts_new;
 iso_write_opts_set_aaip;
 iso_write_opts_set_aaip_susp_1_10;
 iso_write_opts_set_allow_deep_paths;
+iso_write_opts_set_allow_dir_id_ext;
 iso_write_opts_set_allow_full_ascii;
 iso_write_opts_set_allow_longer_paths;
 iso_write_opts_set_allow_lowercase;
@@ -260,6 +276,7 @@ iso_write_opts_set_default_gid;
 iso_write_opts_set_default_timestamp;
 iso_write_opts_set_default_uid;
 iso_write_opts_set_dir_rec_mtime;
+iso_write_opts_set_disc_label;
 iso_write_opts_set_fifo_size;
 iso_write_opts_set_hardlinks;
 iso_write_opts_set_iso1999;
@@ -269,10 +286,12 @@ iso_write_opts_set_joliet_longer_paths;
 iso_write_opts_set_max_37_char_filenames;
 iso_write_opts_set_ms_block;
 iso_write_opts_set_no_force_dots;
+iso_write_opts_set_old_empty;
 iso_write_opts_set_omit_version_numbers;
 iso_write_opts_set_output_charset;
 iso_write_opts_set_overwrite_buf;
 iso_write_opts_set_part_offset;
+iso_write_opts_set_partition_img;
 iso_write_opts_set_pvd_times;
 iso_write_opts_set_record_md5;
 iso_write_opts_set_relaxed_vol_atts;
@@ -284,6 +303,9 @@ iso_write_opts_set_rrip_version_1_10;
 iso_write_opts_set_scdbackup_tag;
 iso_write_opts_set_sort_files;
 iso_write_opts_set_system_area;
+iso_write_opts_set_tail_blocks;
+iso_write_opts_set_untranslated_name_len;
+iso_write_opts_set_will_cancel;
 iso_zisofs_get_params;
 iso_zisofs_get_refcounts;
 iso_zisofs_set_params;

libisofs/make_isohybrid_mbr.c

@@ -4,7 +4,15 @@
 #endif
 
 #include <ctype.h>
+
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+
 #include <sys/types.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -378,21 +386,19 @@ int make_isolinux_mbr(int32_t *img_blocks, uint32_t boot_lba,
                       int part_offset, int part_number, int fs_type,
                       uint8_t *buf, int flag)
 {
-    uint32_t spc, id, part, nominal_part_size;
+    uint32_t id, part, nominal_part_size;
     off_t hd_img_blocks, hd_boot_lba;
     char *wpt;
     /* For generating a weak random number */
     struct timeval tv;
     struct timezone tz;
 
-    /* Pad image_size to a multiple of sector_count*head_count
-    */
-    spc = head_count * sector_count;
     hd_img_blocks = ((off_t) *img_blocks) * (off_t) 4;
-    if (hd_img_blocks % spc) {
+
-        hd_img_blocks += spc - (hd_img_blocks % spc);
+    /* Padding of image_size to a multiple of sector_count*head_count
-        *img_blocks = hd_img_blocks / 4 + !!(hd_img_blocks % 4);
+       happens already at compute time and is implemented by
-    }
+       an appropriate increase of Ecma119Image->tail_blocks.
+    */
 
     wpt = (char *) buf + 432;
 

libisofs/md5.c

@@ -12,7 +12,14 @@
 #include "../config.h"
 #endif
 
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
@@ -417,6 +424,22 @@ int checksum_cx_xinfo_func(void *data, int flag)
     return 1;
 }
 
+/* The iso_node_xinfo_cloner function which gets associated to
+ * checksum_cx_xinfo_func by iso_init() resp. iso_init_with_flag() via
+ * iso_node_xinfo_make_clonable()
+ */
+int checksum_cx_xinfo_cloner(void *old_data, void **new_data, int flag)
+{
+    *new_data = NULL;
+    if (flag)
+        return ISO_XINFO_NO_CLONE;
+    if (old_data == NULL)
+        return 0;
+    /* data is an int disguised as pointer. It does not point to memory. */
+    *new_data = old_data;
+    return 0;
+}
+
 
 /* Function to identify and manage md5 sums of unspecified providence stored
  * directly in this xinfo.
@@ -429,6 +452,24 @@ int checksum_md5_xinfo_func(void *data, int flag)
     return 1;
 }
 
+/* The iso_node_xinfo_cloner function which gets associated to
+ * checksum_md5_xinfo_func by iso_init() resp. iso_init_with_flag() via
+ * iso_node_xinfo_make_clonable()
+ */
+int checksum_md5_xinfo_cloner(void *old_data, void **new_data, int flag)
+{
+    *new_data = NULL;
+    if (flag)
+        return ISO_XINFO_NO_CLONE;
+    if (old_data == NULL)
+        return 0;
+    *new_data = calloc(1, 16);
+    if (*new_data == NULL)
+        return ISO_OUT_OF_MEM;
+    memcpy(*new_data, old_data, 16);
+    return 16;
+}
+
 
 /* ----------------------------------------------------------------------- */
 

libisofs/messages.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -17,11 +18,26 @@
 #include <stdio.h>
 #include <stdarg.h>
 
+#ifdef Xorriso_standalonE
+
+#ifdef Xorriso_with_libjtE
+#include "../libjte/libjte.h"
+#endif
+
+#else
+
+#ifdef Libisofs_with_libjtE
+#include <libjte/libjte.h>
+#endif
+
+#endif /* ! Xorriso_standalonE */
+
 #include "libiso_msgs.h"
 #include "libisofs.h"
 #include "messages.h"
 
 #include "util.h"
+#include "node.h"
 
 
 /*
@@ -65,11 +81,110 @@ int abort_threshold = LIBISO_MSGS_SEV_FAILURE;
 struct libiso_msgs *libiso_msgr = NULL;
 
 
+/* ------------- List of xinfo clone functions ----------- */
+
+struct iso_xinfo_cloner_assoc {
+    iso_node_xinfo_func proc;
+    iso_node_xinfo_cloner cloner;
+    struct iso_xinfo_cloner_assoc *next;
+};
+
+struct iso_xinfo_cloner_assoc *iso_xinfo_cloner_list = NULL;
+
+/* API */
+int iso_node_xinfo_make_clonable(iso_node_xinfo_func proc,
+                                 iso_node_xinfo_cloner cloner, int flag)
+{
+    struct iso_xinfo_cloner_assoc *assoc;
+
+    /* Look for existing assoc of proc */
+    for (assoc = iso_xinfo_cloner_list; assoc != NULL; assoc = assoc->next) 
+        if (assoc->proc == proc)
+    break;
+
+    if (assoc == NULL) {
+        assoc = calloc(1, sizeof(struct iso_xinfo_cloner_assoc));
+        if (assoc == NULL)
+            return ISO_OUT_OF_MEM;
+        assoc->proc = proc;
+        assoc->next = iso_xinfo_cloner_list;
+        iso_xinfo_cloner_list = assoc;
+    }
+    assoc->cloner = cloner;
+    return ISO_SUCCESS;
+}
+
+/* API */
+int iso_node_xinfo_get_cloner(iso_node_xinfo_func proc,
+                              iso_node_xinfo_cloner *cloner, int flag)
+{
+    struct iso_xinfo_cloner_assoc *assoc;
+
+    *cloner = NULL;
+    for (assoc = iso_xinfo_cloner_list; assoc != NULL; assoc = assoc->next) {
+        if (assoc->proc != proc)
+    continue;
+        *cloner = assoc->cloner;
+        return 1;
+    }
+    return 0;
+}
+
+static
+int iso_node_xinfo_dispose_cloners(int flag)
+{
+    struct iso_xinfo_cloner_assoc *assoc, *next;
+
+    for (assoc = iso_xinfo_cloner_list; assoc != NULL; assoc = next) {
+        next = assoc->next;
+        free((char *) assoc);
+    }
+    return(1);
+}
+
+/* ------------- End of xinfo clone functions list ----------- */
+
+
 /*
   @param flag  bit0= do not set up locale by LC_* environment variables
 */
 int iso_init_with_flag(int flag)
 {
+    int ret;
+
+#ifdef Libisofs_with_libjtE
+
+ /* Ugly compile time check for header version compatibility.
+    If everthing matches, then it produces no C code. In case of mismatch,
+    intentionally faulty C code will be inserted.
+ */ 
+ /* The indendation is an advise of man gcc to help old compilers ignoring */
+ #if iso_libjte_req_major > LIBJTE_VERSION_MAJOR
+ #define Libisofs_libjte_dot_h_too_olD 1
+ #endif
+ #if iso_libjte_req_major == LIBJTE_VERSION_MAJOR && iso_libjte_req_minor > LIBJTE_VERSION_MINOR
+ #define Libisofs_libjte_dot_h_too_olD 1
+ #endif
+ #if iso_libjte_req_minor == LIBJTE_VERSION_MINOR && iso_libjte_req_micro > LIBJTE_VERSION_MICRO
+ #define Libisofs_libjte_dot_h_too_olD 1
+ #endif
+
+#ifdef Libisofs_libjte_dot_h_too_olD
+LIBJTE_MISCONFIGURATION = 0;
+INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libjte_dot_h_TOO_OLD__SEE_libisofs_dot_h_AND_messages_c = 0;
+LIBJTE_MISCONFIGURATION_ = 0;
+#endif
+
+    if (! libjte__is_compatible(LIBJTE_VERSION_MAJOR, LIBJTE_VERSION_MINOR,
+                                LIBJTE_VERSION_MICRO, 0)) {
+        fprintf(stderr,
+              "\nlibisofs: libjte TOO OLD ! Need at least libjte-%d.%d.%d\n\n",
+              LIBJTE_VERSION_MAJOR, LIBJTE_VERSION_MINOR,
+              LIBJTE_VERSION_MICRO);
+        return ISO_FATAL_ERROR;
+    }
+
+#endif /* Libisofs_with_libjtE */
 
     if (! (flag & 1)) {
         iso_init_locale(0);
@@ -80,10 +195,29 @@ int iso_init_with_flag(int flag)
     }
     libiso_msgs_set_severities(libiso_msgr, LIBISO_MSGS_SEV_NEVER,
                    LIBISO_MSGS_SEV_FATAL, "libisofs: ", 0);
+
+    ret = iso_node_xinfo_make_clonable(aaip_xinfo_func, aaip_xinfo_cloner, 0);
+    if (ret < 0)
+        return ret;
+    ret = iso_node_xinfo_make_clonable(checksum_cx_xinfo_func,
+                                       checksum_cx_xinfo_cloner, 0);
+    if (ret < 0)
+        return ret;
+    ret = iso_node_xinfo_make_clonable(checksum_md5_xinfo_func,
+                                       checksum_md5_xinfo_cloner, 0);
+    if (ret < 0)
+        return ret;
+    ret = iso_node_xinfo_make_clonable(zisofs_zf_xinfo_func,
+                                       zisofs_zf_xinfo_cloner, 0);
+    if (ret < 0)
+        return ret;
+    ret = iso_node_xinfo_make_clonable(iso_px_ino_xinfo_func,
+                                       iso_px_ino_xinfo_cloner, 0);
+    if (ret < 0)
+        return ret;
     return 1;
 }
 
-
 int iso_init()
 {
     return iso_init_with_flag(0);
@@ -92,6 +226,7 @@ int iso_init()
 void iso_finish()
 {
     libiso_msgs_destroy(&libiso_msgr, 0);
+    iso_node_xinfo_dispose_cloners(0);
 }
 
 int iso_set_abort_severity(char *severity)
@@ -292,6 +427,34 @@ const char *iso_error_to_msg(int errcode)
         return "Partition offset too small for first tree root.";
     case ISO_OVWRT_FIFO_TOO_SMALL:
         return "The ring buffer is too small for overwrite buffer";
+    case ISO_LIBJTE_NOT_ENABLED:
+        return "Use of libjte was not enabled at compile time";
+    case ISO_LIBJTE_START_FAILED:
+        return "Failed to start up Jigdo Template Extraction";
+    case ISO_LIBJTE_END_FAILED:
+        return "Failed to finish Jigdo Template Extraction";
+    case ISO_LIBJTE_FILE_FAILED:
+        return "Failed to process file for Jigdo Template Extraction";
+    case ISO_BOOT_TOO_MANY_MIPS:
+        return "Too many MIPS Big Endian boot files given (max. 15)";
+    case ISO_BOOT_FILE_MISSING:
+        return "Boot file missing in image";
+    case ISO_BAD_PARTITION_NO:
+        return "Partition number out of range";
+    case ISO_BAD_PARTITION_FILE:
+        return "Cannot open data file for appended partition";
+    case ISO_NON_MBR_SYS_AREA:
+        return "May not combine appended partition with non-MBR system area";
+    case ISO_DISPLACE_ROLLOVER:
+        return "Displacement offset leads outside 32 bit range";
+    case ISO_NAME_NEEDS_TRANSL:
+        return "File name cannot be written into ECMA-119 untranslated";
+    case ISO_STREAM_NO_CLONE:
+        return "Data file input stream object offers no cloning method";
+    case ISO_XINFO_NO_CLONE:
+        return "Extended information class offers no cloning method";
+    case ISO_MD5_TAG_COPIED:
+        return "Found copied superblock checksum tag";
     default:
         return "Unknown error";
     }
@@ -515,3 +678,33 @@ int iso_report_errfile(char *path, int error_code, int os_errno, int flag)
                        path, os_errno, 0);
     return(1);
 }
+
+
+int iso_libjte_forward_msgs(void *libjte_handle,
+                            int imgid, int errcode, int flag)
+{
+
+#ifdef Libisofs_with_libjtE
+
+    char *msg = NULL;
+    int res;
+    struct libjte_env *handle = (struct libjte_env *) libjte_handle;
+
+    res = ISO_SUCCESS;
+    while(1) {
+       msg= libjte_get_next_message(handle);
+       if(msg == NULL)
+    break;
+       res = iso_msg_submit(imgid, errcode, 0, msg);
+       free(msg);
+    }
+    return res;
+
+#else /* Libisofs_with_libjtE */
+
+    return ISO_SUCCESS;
+
+#endif /* ! Libisofs_with_libjtE */
+
+}
+

libisofs/messages.h

@@ -46,7 +46,6 @@ int iso_msg_is_abort(int errcode);
 int iso_msg_submit(int imgid, int errcode, int causedby, const char *fmt, ...);
 
 
-/* ts A80222 */
 /* To be called with events which report incidents with individual input 
    files from the local filesystem. Not with image nodes, files containing an
    image or similar file-like objects.
@@ -54,4 +53,10 @@ int iso_msg_submit(int imgid, int errcode, int causedby, const char *fmt, ...);
 int iso_report_errfile(char *path, int error_code, int os_errno, int flag);
 
 
+/* Drains the libjte message list and puts out the messages via
+   iso_msg_submit()
+*/
+int iso_libjte_forward_msgs(void *libjte_handle,
+                            int imgid, int errcode, int flag);
+
 #endif /*MESSAGES_H_*/

libisofs/node.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -226,6 +226,89 @@ int iso_node_get_xinfo(IsoNode *node, iso_node_xinfo_func proc, void **data)
     return 0;
 }
 
+/* API */
+int iso_node_get_next_xinfo(IsoNode *node, void **handle,
+                            iso_node_xinfo_func *proc, void **data)
+{
+    IsoExtendedInfo *xinfo;
+
+    if (node == NULL || handle == NULL || proc == NULL || data == NULL)
+        return ISO_NULL_POINTER;
+    *proc = NULL;
+    *data = NULL;
+    xinfo = (IsoExtendedInfo *) *handle;
+    if (xinfo == NULL)
+        xinfo = node->xinfo;
+    else
+        xinfo = xinfo->next;
+    *handle = xinfo;
+    if (xinfo == NULL)
+        return 0;
+    *proc = xinfo->process;
+    *data = xinfo->data;
+    return ISO_SUCCESS;
+}
+
+int iso_node_remove_all_xinfo(IsoNode *node, int flag)
+{
+    IsoExtendedInfo *pos, *next;
+
+    for (pos = node->xinfo; pos != NULL; pos = next) {
+        next = pos->next;
+        pos->process(pos->data, 1);
+        free((char *) pos);
+    }
+    node->xinfo = NULL;
+    return ISO_SUCCESS;
+}
+
+static
+int iso_node_revert_xinfo_list(IsoNode *node, int flag)
+{
+
+    IsoExtendedInfo *pos, *next, *prev = NULL;
+
+    for (pos = node->xinfo; pos != NULL; pos = next) {
+        next = pos->next;
+        pos->next = prev;
+        prev = pos;
+    }
+    node->xinfo = prev;
+    return ISO_SUCCESS;
+}
+
+int iso_node_clone_xinfo(IsoNode *from_node, IsoNode *to_node, int flag)
+{
+    void *handle = NULL, *data, *new_data;
+    iso_node_xinfo_func proc;
+    iso_node_xinfo_cloner cloner;
+    int ret;
+
+    iso_node_remove_all_xinfo(to_node, 0);
+    while (1) {
+        ret = iso_node_get_next_xinfo(from_node, &handle, &proc, &data);
+        if (ret <= 0)
+    break;
+        ret = iso_node_xinfo_get_cloner(proc, &cloner, 0);
+        if (ret == 0)
+            return ISO_XINFO_NO_CLONE;
+        if (ret < 0)
+            return ret;
+        ret = (*cloner)(data, &new_data, 0);
+        if (ret < 0)
+    break;
+        ret = iso_node_add_xinfo(to_node, proc, new_data);
+        if (ret < 0)
+    break;
+    }
+    if (ret < 0) {
+        iso_node_remove_all_xinfo(to_node, 0);
+    } else {
+        ret = iso_node_revert_xinfo_list(to_node, 0);
+    }
+    return ret;
+}
+
 /**
  * Get the type of an IsoNode.
  */
@@ -651,6 +734,9 @@ int iso_node_take(IsoNode *node)
     if (dir == NULL) {
         return ISO_NODE_NOT_ADDED_TO_DIR;
     }
+
+    /* >>> Do not take root directory ! (dir == node) ? */;
+
     pos = iso_dir_find_node(dir, node);
     if (pos == NULL) {
         /* should never occur */
@@ -686,6 +772,44 @@ int iso_node_remove(IsoNode *node)
     return ret;
 }
 
+/* API */
+int iso_node_remove_tree(IsoNode *node, IsoDirIter *boss_iter)
+{
+    IsoDirIter *iter = NULL;
+    IsoNode *sub_node;
+    int ret;
+
+    if (node->type != LIBISO_DIR) {
+
+        /* >>> Do not remove root directory ! (node->parent == node) ? */;
+
+        ret = iso_dir_get_children((IsoDir *) node, &iter);
+        if (ret < 0)
+            goto ex;
+        while(1) {
+            ret = iso_dir_iter_next(iter, &sub_node);
+            if (ret == 0)
+        break;
+            ret = iso_node_remove_tree(sub_node, iter);
+            if (ret < 0)
+                goto ex;
+        }
+        if (node->parent == NULL) {
+            /* node is not grafted into a boss directory */
+            iso_node_unref(node);
+            goto ex;
+        }
+    }
+    if (boss_iter != NULL)
+        ret = iso_dir_iter_remove(boss_iter);
+    else
+        ret = iso_node_remove(node);
+ex:;
+    if (iter != NULL)
+        iso_dir_iter_free(iter);
+    return ret;
+}
+
 /*
  * Get the parent of the given iso tree node. No extra ref is added to the
  * returned directory, you must take your ref. with iso_node_ref() if you
@@ -2153,6 +2277,23 @@ int zisofs_zf_xinfo_func(void *data, int flag)
     return 1;
 }
 
+/* The iso_node_xinfo_cloner function which gets associated to
+ * zisofs_zf_xinfo_func by iso_init() resp. iso_init_with_flag() via
+ * iso_node_xinfo_make_clonable()
+ */
+int zisofs_zf_xinfo_cloner(void *old_data, void **new_data, int flag)
+{
+    *new_data = NULL;
+    if (flag)
+        return ISO_XINFO_NO_CLONE;
+    if (old_data == NULL)
+        return 0;
+    *new_data = calloc(1, sizeof(struct zisofs_zf_info));
+    if (*new_data == NULL)
+        return ISO_OUT_OF_MEM;
+    memcpy(*new_data, old_data, sizeof(struct zisofs_zf_info));
+    return (int) sizeof(struct zisofs_zf_info);
+}
 
 /* Checks whether a file effectively bears a zisofs file header and eventually
  * marks this by a struct zisofs_zf_info as xinfo of the file node.
@@ -2274,6 +2415,21 @@ int iso_px_ino_xinfo_func(void *data, int flag)
     return 1;
 }
 
+/* The iso_node_xinfo_cloner function which gets associated to
+ * iso_px_ino_xinfo_func by iso_init() resp. iso_init_with_flag() via
+ * iso_node_xinfo_make_clonable()
+ */
+int iso_px_ino_xinfo_cloner(void *old_data, void **new_data, int flag)
+{
+    *new_data = NULL;
+    if (flag)
+        return ISO_XINFO_NO_CLONE; 
+    *new_data = calloc(1, sizeof(ino_t));
+    if (*new_data == NULL)
+        return ISO_OUT_OF_MEM;
+    memcpy(*new_data, old_data, sizeof(ino_t));
+    return (int) sizeof(ino_t);
+}
 
 /*
  * @param flag
@@ -2364,7 +2520,6 @@ int iso_node_set_ino_xinfo(IsoNode *node, ino_t ino, int flag)
     return ret;
 }
 
-
 int iso_node_set_ino(IsoNode *node, ino_t ino, int flag)
 {
     int ret;

libisofs/node.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -20,7 +20,15 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
+
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+
 
 /**
  * The extended information is a way to attach additional information to each
@@ -113,6 +121,7 @@ struct Iso_Dir
     IsoNode *children; /**< list of children. ptr to first child */
 };
 
+/* IMPORTANT: Any change must be reflected by iso_tree_clone_file. */
 struct Iso_File
 {
     IsoNode node;
@@ -473,4 +482,35 @@ int iso_root_get_isofsca(IsoNode *node, uint32_t *start_lba, uint32_t *end_lba,
                          int flag);
 
 
+/**
+ * Copy the xinfo list from one node to the another.
+ */
+int iso_node_clone_xinfo(IsoNode *from_node, IsoNode *to_node, int flag);
+
+
+/**
+ * The iso_node_xinfo_func instance which governs the storing of the inode
+ * number from Rock Ridge field PX.
+ */
+int iso_px_ino_xinfo_func(void *data, int flag);
+
+/* The iso_node_xinfo_cloner function which gets associated to
+ * iso_px_ino_xinfo_func by iso_init() resp. iso_init_with_flag() via
+ * iso_node_xinfo_make_clonable()
+ */
+int iso_px_ino_xinfo_cloner(void *old_data, void **new_data, int flag);
+
+
+/* Function to identify and manage ZF parameters of zisofs compression.
+ * data is supposed to be a pointer to struct zisofs_zf_info
+ */
+int zisofs_zf_xinfo_func(void *data, int flag);
+
+/* The iso_node_xinfo_cloner function which gets associated to
+ * zisofs_zf_xinfo_func by iso_init() resp. iso_init_with_flag() via
+ * iso_node_xinfo_make_clonable()
+ */
+int zisofs_zf_xinfo_cloner(void *old_data, void **new_data, int flag);
+
+
 #endif /*LIBISO_NODE_H_*/

libisofs/rockridge.c

@@ -13,6 +13,9 @@
 #include "../config.h"
 #endif
 
+#include <string.h>
+#include <stdio.h>
+
 #include "rockridge.h"
 #include "node.h"
 #include "ecma119_tree.h"
@@ -22,7 +25,12 @@
 #include "aaip_0_2.h"
 #include "libisofs.h"
 
-#include <string.h>
+
+#ifdef Libisofs_with_rrip_rR
+#define ISO_ROCKRIDGE_IN_DIR_REC 128
+#else
+#define ISO_ROCKRIDGE_IN_DIR_REC 124
+#endif
 
 
 static
@@ -897,7 +905,7 @@ int add_zf_field(Ecma119Image *t, Ecma119Node *n, struct susp_info *info,
     return 1;
 }
 
-
+/* API */
 int aaip_xinfo_func(void *data, int flag)
 {
     if (flag & 1) {
@@ -906,6 +914,23 @@ int aaip_xinfo_func(void *data, int flag)
     return 1;
 }
 
+/* API */
+int aaip_xinfo_cloner(void *old_data, void **new_data, int flag)
+{
+    size_t aa_size;
+
+    *new_data = NULL;
+    if (old_data == NULL)
+        return 0;
+    aa_size = aaip_count_bytes((unsigned char *) old_data, 0);
+    if (aa_size <= 0)
+        return ISO_AAIP_BAD_AASTRING;
+    *new_data = calloc(1, aa_size);
+    if (*new_data == NULL)
+        return ISO_OUT_OF_MEM;
+    memcpy(*new_data, old_data, aa_size);
+    return (int) aa_size;
+}
 
 /**
  * Compute SUA length and eventual Continuation Area length of field NM and
@@ -1097,6 +1122,44 @@ unannounced_ca:;
 }
 
 
+/* @param flag bit0= Do not add data but only count sua_free and ce_len
+                     param info may be NULL in this case
+*/
+static
+int add_aa_string(Ecma119Image *t, Ecma119Node *n, struct susp_info *info,
+                  size_t *sua_free, size_t *ce_len, int flag)
+{
+    int ret;
+    uint8_t *aapt;
+    void *xipt;
+    size_t num_aapt= 0;
+
+    if (!t->aaip)
+        return 1;
+
+    ret = iso_node_get_xinfo(n->node, aaip_xinfo_func, &xipt);
+    if (ret == 1) {
+        num_aapt = aaip_count_bytes((unsigned char *) xipt, 0);
+        if (num_aapt > 0) {
+            if (flag & 1) {
+                ret = aaip_add_AL(t, NULL,NULL, num_aapt, sua_free, ce_len, 1);
+            } else {
+                aapt = malloc(num_aapt);
+                if (aapt == NULL)
+                    return ISO_OUT_OF_MEM;
+                memcpy(aapt, xipt, num_aapt);
+                ret = aaip_add_AL(t, info, &aapt, num_aapt, sua_free, ce_len,
+                                  0);
+            }
+            if (ret < 0) 
+                return ret;
+            /* aapt is NULL now and the memory is owned by t */
+        }
+    }
+    return 1;
+}
+
+
 /**
  * Compute the length needed for write all RR and SUSP entries for a given
  * node.
@@ -1104,27 +1167,31 @@ unannounced_ca:;
  * @param type
  *      0 normal entry, 1 "." entry for that node (it is a dir), 2 ".."
  *      for that node (i.e., it will refer to the parent)
- * @param space
+ * @param used_up
- *      Available space in the System Use Area for the directory record.
+ *      Already occupied space in the directory record.
  * @param ce
  *      Will be filled with the space needed in a CE
  * @return
  *      The size needed for the RR entries in the System Use Area
  */
-size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t space,
+size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t used_up,
                      size_t *ce)
 {
-    size_t su_size;
+    size_t su_size, space;
     int ret;
+    size_t aaip_sua_free= 0, aaip_len= 0;
+
+    /* Directory record length must be even (ECMA-119, 9.1.13). Maximum is 254.
+    */
+    space = 254 - used_up - (used_up % 2);
+    if (type < 0 || type > 2 || space < ISO_ROCKRIDGE_IN_DIR_REC) {
+        iso_msg_submit(t->image->id, ISO_ASSERT_FAILURE, 0,
+          "Unknown node type %d or short RR space %d < %d in directory record",
+          type, (int) space, ISO_ROCKRIDGE_IN_DIR_REC);
+        return ISO_ASSERT_FAILURE;
+    }
 
-    /* space min is 255 - 33 - 37 = 185
-     * At the same time, it is always an odd number, but we need to pad it
-     * propertly to ensure the length of a directory record is a even number
-     * (ECMA-119, 9.1.13). Thus, in fact the real space is always space - 1
-     */
-    space--;
     *ce = 0;
-
     su_size = 0;
 
     /* If AAIP enabled and announced by ER : account for 5 bytes of ES */;
@@ -1190,9 +1257,15 @@ size_t rrip_calc_len(Ecma119Image *t, Ecma119Node *n, int type, size_t space,
             } else {
                 *ce = 182;
             }
-            if (t->aaip) {
+            if (t->aaip && !t->aaip_susp_1_10) {
                 *ce += 160; /* ER of AAIP */
             }
+            /* Compute length of AAIP string of root node */
+            aaip_sua_free= 0;
+            ret = add_aa_string(t, n, NULL, &aaip_sua_free, &aaip_len, 1);
+            if (ret < 0)
+               return ret;
+            *ce += aaip_len;
         }
     }
 
@@ -1224,43 +1297,6 @@ void susp_info_free(struct susp_info* susp)
 }
 
 
-/* @param flag bit0= Do not add data but only count sua_free and ce_len
-*/
-static
-int add_aa_string(Ecma119Image *t, Ecma119Node *n, struct susp_info *info,
-                  size_t *sua_free, size_t *ce_len, int flag)
-{
-    int ret;
-    uint8_t *aapt;
-    void *xipt;
-    size_t num_aapt= 0;
-
-    if (!t->aaip)
-        return 1;
-
-    ret = iso_node_get_xinfo(n->node, aaip_xinfo_func, &xipt);
-    if (ret == 1) {
-        num_aapt = aaip_count_bytes((unsigned char *) xipt, 0);
-        if (num_aapt > 0) {
-            if (flag & 1) {
-                ret = aaip_add_AL(t, NULL,NULL, num_aapt, sua_free, ce_len, 1);
-            } else {
-                aapt = malloc(num_aapt);
-                if (aapt == NULL)
-                    return ISO_OUT_OF_MEM;
-                memcpy(aapt, xipt, num_aapt);
-                ret = aaip_add_AL(t, info, &aapt, num_aapt, sua_free, ce_len,
-                                  0);
-            }
-            if (ret < 0) 
-                return ret;
-            /* aapt is NULL now and the memory is owned by t */
-        }
-    }
-    return 1;
-}
-
-
 /**
  * Fill a struct susp_info with the RR/SUSP entries needed for a given
  * node.
@@ -1268,8 +1304,8 @@ int add_aa_string(Ecma119Image *t, Ecma119Node *n, struct susp_info *info,
  * @param type
  *      0 normal entry, 1 "." entry for that node (it is a dir), 2 ".."
  *      for that node (i.e., it will refer to the parent)
- * @param space
+ * @param used_up
- *      Available space in the System Use Area for the directory record.
+ *      Already occupied space in the directory record.
  * @param info
  *      Pointer to the struct susp_info where the entries will be stored.
  *      If some entries need to go to a Continuation Area, they will be added
@@ -1279,7 +1315,7 @@ int add_aa_string(Ecma119Image *t, Ecma119Node *n, struct susp_info *info,
  *      1 success, < 0 error
  */
 int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
-                         size_t space, struct susp_info *info)
+                         size_t used_up, struct susp_info *info)
 {
     int ret;
     size_t i;
@@ -1291,13 +1327,20 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
     size_t su_size_pd, ce_len_pd; /* predicted sizes of SUA and CA */
     int ce_is_predicted = 0;
     size_t aaip_sua_free= 0, aaip_len= 0;
+    size_t space;
 
     if (t == NULL || n == NULL || info == NULL) {
         return ISO_NULL_POINTER;
     }
-    if (type < 0 || type > 2 || space < 185) {
+
-        /* space min is 255 - 33 - 37 = 185 */
+    /* Directory record length must be even (ECMA-119, 9.1.13). Maximum is 254.
-        return ISO_WRONG_ARG_VALUE;
+    */
+    space = 254 - used_up - (used_up % 2);
+    if (type < 0 || type > 2 || space < ISO_ROCKRIDGE_IN_DIR_REC) {
+        iso_msg_submit(t->image->id, ISO_ASSERT_FAILURE, 0,
+          "Unknown node type %d or short RR space %d < %d in directory record",
+          type, (int) space, ISO_ROCKRIDGE_IN_DIR_REC);
+        return ISO_ASSERT_FAILURE;
     }
 
     if (type == 2 && n->parent != NULL) {
@@ -1306,13 +1349,6 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
         node = n;
     }
 
-    /* space min is 255 - 33 - 37 = 185
-     * At the same time, it is always an odd number, but we need to pad it
-     * propertly to ensure the length of a directory record is a even number
-     * (ECMA-119, 9.1.13). Thus, in fact the real space is always space - 1
-     */
-    space--;
-
     /* 
      * SP must be the first entry for the "." record of the root directory
      * (SUSP, 5.3)
@@ -1384,6 +1420,13 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
         }
     }
 
+    if (info->suf_len + 28 > space) {
+        iso_msg_submit(t->image->id, ISO_ASSERT_FAILURE, 0,
+         "Directory Record overflow. name='%s' , suf_len=%d > space=%d - 28\n", 
+         node->iso_name, (int) info->suf_len, (int) space);
+        return ISO_ASSERT_FAILURE;
+    }
+
     if (type == 0) {
         size_t sua_free; /* free space in the SUA */
         int nm_type = 0; /* 0 whole entry in SUA, 1 part in CE */
@@ -1670,7 +1713,7 @@ int rrip_get_susp_fields(Ecma119Image *t, Ecma119Node *n, int type,
 
             /* Compute length of AAIP string of root node */
             aaip_sua_free= 0;
-            ret = add_aa_string(t, n, info, &aaip_sua_free, &aaip_len, 1);
+            ret = add_aa_string(t, n, NULL, &aaip_sua_free, &aaip_len, 1);
             if (ret < 0)
                 goto add_susp_cleanup;
 

libisofs/rockridge_read.c

@@ -443,7 +443,7 @@ int read_rr_PN(struct susp_sys_user_entry *pn, struct stat *st)
 }
 
 
-/* AA is the field signature of AAIP versions < 2.0
+/* AA is the obsolete field signature of AAIP versions < 2.0
 */
 int read_aaip_AA(struct susp_sys_user_entry *sue,
                  unsigned char **aa_string, size_t *aa_size, size_t *aa_len,
@@ -514,7 +514,7 @@ int read_aaip_AA(struct susp_sys_user_entry *sue,
 }
 
 
-/* AL is the obsolete field signature of AAIP versions >= 2.0
+/* AL is the field signature of AAIP versions >= 2.0
 */
 int read_aaip_AL(struct susp_sys_user_entry *sue,
                  unsigned char **aa_string, size_t *aa_size, size_t *aa_len,

libisofs/stream.c

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -157,8 +157,64 @@ int fsrc_update_size(IsoStream *stream)
     return ISO_SUCCESS;
 }
 
+static 
+IsoStream *fsrc_get_input_stream(IsoStream *stream, int flag)
+{
+    return NULL;
+}
+
+static 
+int fsrc_cmp_ino(IsoStream *s1, IsoStream *s2)
+{
+    int ret;
+
+    ret = iso_stream_cmp_ino(s1, s2, 1);
+    return ret;
+}
+
+int fsrc_clone_stream(IsoStream *old_stream, IsoStream **new_stream,
+                      int flag)
+{
+    FSrcStreamData *data, *new_data;
+    IsoStream *stream;
+    int ret;
+
+    if (flag)
+        return ISO_STREAM_NO_CLONE; /* unknown option required */
+
+    data = (FSrcStreamData*) old_stream->data;
+    if (data->src->class->version < 2)
+        return ISO_STREAM_NO_CLONE; /* No clone_src() method available */
+
+    *new_stream = NULL;
+    stream = calloc(1, sizeof(IsoStream));
+    if (stream == NULL)
+        return ISO_OUT_OF_MEM;
+    new_data = calloc(1, sizeof(FSrcStreamData));
+    if (new_data == NULL) {
+        free((char *) stream);
+        return ISO_OUT_OF_MEM;
+    }
+    *new_stream = stream;
+    stream->class = old_stream->class;
+    stream->refcount = 1;
+    stream->data = new_data;
+
+    ret = data->src->class->clone_src(data->src, &(new_data->src), 0);
+    if (ret < 0) {
+        free((char *) stream);
+        free((char *) new_data);
+        return ret;
+    }
+    new_data->dev_id = data->dev_id;
+    new_data->ino_id = data->ino_id;
+    new_data->size = data->size;
+
+    return ISO_SUCCESS;
+}
+
 IsoStreamIface fsrc_stream_class = {
-    1, /* update_size is defined for this stream */
+    4, /* version */
     "fsrc",
     fsrc_open,
     fsrc_close,
@@ -167,7 +223,10 @@ IsoStreamIface fsrc_stream_class = {
     fsrc_is_repeatable,
     fsrc_get_id,
     fsrc_free,
-    fsrc_update_size
+    fsrc_update_size,
+    fsrc_get_input_stream,
+    fsrc_cmp_ino,
+    fsrc_clone_stream
 };
 
 int iso_file_source_stream_new(IsoFileSource *src, IsoStream **stream)
@@ -375,11 +434,76 @@ void cut_out_free(IsoStream *stream)
     free(data);
 }
 
+static
+int cut_out_update_size(IsoStream *stream)
+{
+    return ISO_SUCCESS;
+}
+
+static 
+IsoStream* cut_out_get_input_stream(IsoStream *stream, int flag)
+{
+    return NULL;
+}
+
+static
+int cut_out_cmp_ino(IsoStream *s1, IsoStream *s2)
+{
+    int ret;
+
+    ret = iso_stream_cmp_ino(s1, s2, 1);
+    return ret;
+}
+
+static
+int cut_out_clone_stream(IsoStream *old_stream, IsoStream **new_stream,
+                      int flag)
+{
+    struct cut_out_stream *data, *new_data;
+    IsoStream *stream;
+    int ret;
+
+    if (flag)
+        return ISO_STREAM_NO_CLONE; /* unknown option required */
+
+    data = (struct cut_out_stream *) old_stream->data;
+    if (data->src->class->version < 2)
+        return ISO_STREAM_NO_CLONE; /* No clone_src() method available */
+
+    *new_stream = NULL;
+    stream = calloc(1, sizeof(IsoStream));
+    if (stream == NULL)
+        return ISO_OUT_OF_MEM;
+    stream->refcount = 1;
+    stream->class = old_stream->class;
+    new_data = calloc(1, sizeof(struct cut_out_stream));
+    if (new_data == NULL) {
+        free((char *) stream);
+        return ISO_OUT_OF_MEM;
+    }
+    ret = data->src->class->clone_src(data->src, &(new_data->src), 0);
+    if (ret < 0) {
+        free((char *) stream);
+        free((char *) new_data);
+        return ret;
+    }
+
+    new_data->dev_id = (dev_t) 0;
+    new_data->ino_id = cut_out_serial_id++;
+    new_data->offset = data->offset;
+    new_data->size = data->size;
+    new_data->pos = 0;
+
+    stream->data = new_data;
+    *new_stream = stream;
+    return ISO_SUCCESS;
+}
+
 /*
  * TODO update cut out streams to deal with update_size(). Seems hard.
  */
 IsoStreamIface cut_out_stream_class = {
-    0,
+    4, /* version */
     "cout",
     cut_out_open,
     cut_out_close,
@@ -387,7 +511,12 @@ IsoStreamIface cut_out_stream_class = {
     cut_out_read,
     cut_out_is_repeatable,
     cut_out_get_id,
-    cut_out_free
+    cut_out_free,
+    cut_out_update_size,
+    cut_out_get_input_stream,
+    cut_out_cmp_ino,
+    cut_out_clone_stream
+    
 };
 
 int iso_cut_out_stream_new(IsoFileSource *src, off_t offset, off_t size,
@@ -549,12 +678,77 @@ void mem_free(IsoStream *stream)
 {
     MemStreamData *data;
     data = (MemStreamData*)stream->data;
-    free(data->buf);
+    if (data->buf != NULL)
+        free(data->buf);
     free(data);
 }
 
+static
+int mem_update_size(IsoStream *stream)
+{
+    return ISO_SUCCESS;
+}
+
+static 
+IsoStream* mem_get_input_stream(IsoStream *stream, int flag)
+{
+    return NULL;
+}
+
+static
+int mem_cmp_ino(IsoStream *s1, IsoStream *s2)
+{
+    int ret;
+
+    ret = iso_stream_cmp_ino(s1, s2, 1);
+    return ret;
+}
+
+static
+int mem_clone_stream(IsoStream *old_stream, IsoStream **new_stream,
+                      int flag)
+{
+    MemStreamData *data, *new_data;
+    IsoStream *stream;
+    uint8_t *new_buf = NULL;
+
+    if (flag)
+        return ISO_STREAM_NO_CLONE; /* unknown option required */
+
+    *new_stream = NULL;
+    stream = calloc(1, sizeof(IsoStream));
+    if (stream == NULL)
+        return ISO_OUT_OF_MEM;
+    stream->refcount = 1;
+    stream->class = old_stream->class;
+    new_data = calloc(1, sizeof(MemStreamData));
+    if (new_data == NULL) {
+        free((char *) stream);
+        return ISO_OUT_OF_MEM;
+    }
+    data = (MemStreamData *) old_stream->data;
+    if (data->size > 0) {
+        new_buf = calloc(1, data->size);
+        if (new_buf == NULL) {
+            free((char *) stream);
+            free((char *) new_data);
+            return ISO_OUT_OF_MEM;
+        }
+        memcpy(new_buf, data->buf, data->size);
+    }
+    new_data->buf = new_buf;
+    new_data->offset = -1;
+    new_data->ino_id = mem_serial_id++;
+    new_data->size = data->size;
+
+    stream->data = new_data;
+    *new_stream = stream;
+    return ISO_SUCCESS;
+}
+
+
 IsoStreamIface mem_stream_class = {
-    0,
+    4, /* version */
     "mem ",
     mem_open,
     mem_close,
@@ -562,7 +756,12 @@ IsoStreamIface mem_stream_class = {
     mem_read,
     mem_is_repeatable,
     mem_get_id,
-    mem_free
+    mem_free,
+    mem_update_size,
+    mem_get_input_stream,
+    mem_cmp_ino,
+    mem_clone_stream
+
 };
 
 /**
@@ -924,3 +1123,42 @@ ex:;
         iso_md5_end(&ctx, md5);
     return res;
 }
+
+/* API */
+int iso_stream_clone(IsoStream *old_stream, IsoStream **new_stream, int flag)
+{
+    int ret;
+
+    if (old_stream->class->version < 4)
+        return ISO_STREAM_NO_CLONE;
+    ret = old_stream->class->clone_stream(old_stream, new_stream, 0);
+    return ret;
+}
+
+int iso_stream_clone_filter_common(IsoStream *old_stream,
+                                   IsoStream **new_stream,
+                                   IsoStream **new_input, int flag)
+{
+    IsoStream *stream, *input_stream;
+    int ret;
+
+    *new_stream = NULL;
+    *new_input = NULL;
+    input_stream = iso_stream_get_input_stream(old_stream, 0);
+    if (input_stream == NULL)
+        return ISO_STREAM_NO_CLONE;
+    stream = calloc(1, sizeof(IsoStream));
+    if (stream == NULL)
+        return ISO_OUT_OF_MEM;
+    ret = iso_stream_clone(input_stream, new_input, 0);
+    if (ret < 0) {
+        free((char *) stream);
+        return ret;
+    }
+    stream->class = old_stream->class;
+    stream->refcount = 1;
+    stream->data = NULL;
+    *new_stream = stream;
+    return ISO_SUCCESS;
+}
+

libisofs/stream.h

@@ -1,6 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  *
  * This file is part of the libisofs project; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version 2 
@@ -15,6 +15,7 @@
  */
 #include "fsource.h"
 
+/* IMPORTANT: Any change must be reflected by fsrc_clone_stream */
 typedef struct
 {
     IsoFileSource *src;
@@ -55,15 +56,6 @@ int iso_file_source_stream_new(IsoFileSource *src, IsoStream **stream);
 int iso_cut_out_stream_new(IsoFileSource *src, off_t offset, off_t size,
                            IsoStream **stream);
 
-/**
- * Create a stream for reading from a arbitrary memory buffer.
- * When the Stream refcount reach 0, the buffer is free(3).
- *
- * @return
- *      1 sucess, < 0 error
- */
-int iso_memory_stream_new(unsigned char *buf, size_t size, IsoStream **stream);
-
 /**
  * Obtain eventual zisofs ZF field entry parameters from a file source out
  * of a loaded ISO image.
@@ -103,5 +95,20 @@ int iso_stream_read_buffer(IsoStream *stream, char *buf, size_t count,
 int iso_stream_make_md5(IsoStream *stream, char md5[16], int flag);
 
 
+/**
+ * Create a clone of the input stream of old_stream and a roughly initialized
+ * clone of old_stream which has the same class and refcount 1. Its data
+ * pointer will be NULL and needs to be filled by an expert which knows how
+ * to clone the data of old_stream.
+ * @param old_stream  The existing stream which is in process of cloning
+ * @param new_stream  Will return the uninitialized memory object which shall
+ *                    later become the clone of old_stream.
+ * @param new_input   The clone of the input stream of old stream.
+ * @param flag        Submit 0 for now.
+ * @return            ISO_SUCCESS or an error code <0 
+ */
+int iso_stream_clone_filter_common(IsoStream *old_stream, 
+                                   IsoStream **new_stream, 
+                                   IsoStream **new_input, int flag);
 
 #endif /*STREAM_H_*/

libisofs/system_area.c

@@ -12,12 +12,20 @@
 #include "../config.h"
 #endif
 
+#include "libisofs.h"
 #include "system_area.h"
 #include "eltorito.h"
 #include "filesrc.h"
+#include "ecma119_tree.h"
+#include "image.h"
+#include "messages.h"
+#include "ecma119.h"
 
 #include <string.h>
 #include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
 
 
 /*
@@ -68,6 +76,91 @@ void iso_compute_cyl_head_sec(uint32_t *img_blocks, int hpc, int sph,
 }
 
 
+/* Compute size and position of appended partitions.
+*/
+int iso_compute_append_partitions(Ecma119Image *t, int flag)
+{
+    int ret, i, sa_type;
+    uint32_t pos, size, add_pos = 0;
+    struct stat stbuf;
+
+    sa_type = (t->system_area_options >> 2) & 0x3f;
+    pos = (t->vol_space_size + t->ms_block);
+    for (i = 0; i < ISO_MAX_PARTITIONS; i++) {
+        if (t->appended_partitions[i] == NULL)
+    continue;
+        if (t->appended_partitions[i][0] == 0)
+    continue;
+        ret = stat(t->appended_partitions[i], &stbuf);
+        if (ret == -1)
+            return ISO_BAD_PARTITION_FILE;
+        if (! S_ISREG(stbuf.st_mode))
+            return ISO_BAD_PARTITION_FILE;
+        size = ((stbuf.st_size + 2047) / 2048);
+        if (sa_type == 3 && (pos % ISO_SUN_CYL_SIZE))
+            add_pos = ISO_SUN_CYL_SIZE - (pos % ISO_SUN_CYL_SIZE);
+        t->appended_part_prepad[i] = add_pos;
+        t->appended_part_start[i] = pos + add_pos;
+        t->appended_part_size[i] = size;
+        pos += add_pos + size;
+        t->total_size += (add_pos + size) * 2048;
+    }
+    return ISO_SUCCESS;
+}
+
+
+/* Note: partition_offset and partition_size are counted in 2048 blocks
+ */
+static int write_mbr_partition_entry(int partition_number, int partition_type,
+                  uint32_t partition_offset, uint32_t partition_size,
+                  int sph, int hpc, uint8_t *buf, int flag)
+{
+    uint8_t *wpt;
+    uint32_t end_lba, end_sec, end_head, end_cyl;
+    uint32_t start_lba, start_sec, start_head, start_cyl;
+    uint32_t after_end;
+    int i;
+
+    after_end = partition_offset + partition_size;
+    iso_compute_cyl_head_sec(&partition_offset, hpc, sph,
+                           &start_lba, &start_sec, &start_head, &start_cyl, 1);
+    iso_compute_cyl_head_sec(&after_end, hpc, sph,
+                             &end_lba, &end_sec, &end_head, &end_cyl, 0);
+    wpt = buf + 446 + (partition_number - 1) * 16;
+
+    /* Not bootable */
+    *(wpt++) = 0x00;
+
+    /* C/H/S of the start */
+    *(wpt++) = start_head;
+    *(wpt++) = start_sec | ((start_cyl & 0x300) >> 2);
+    *(wpt++) = start_cyl & 0xff;
+
+    /* (partition type) */
+    *(wpt++) = partition_type;
+
+    /* 3 bytes of C/H/S end */
+    *(wpt++) = end_head;
+    *(wpt++) = end_sec | ((end_cyl & 0x300) >> 2);
+    *(wpt++) = end_cyl & 0xff;
+    
+    /* LBA start in little endian */
+    for (i = 0; i < 4; i++)
+       *(wpt++) = (start_lba >> (8 * i)) & 0xff;
+
+    /* Number of sectors in partition, little endian */
+    end_lba = end_lba - start_lba + 1;
+    for (i = 0; i < 4; i++)
+       *(wpt++) = (end_lba >> (8 * i)) & 0xff;
+
+    /* Afaik, partition tables are recognize donly with MBR signature */
+    buf[510] = 0x55;
+    buf[511] = 0xAA;
+
+    return ISO_SUCCESS;
+}
+
+
 /* This is the gesture of grub-mkisofs --protective-msdos-label as explained by
    Vladimir Serbinenko <phcoder@gmail.com>, 2 April 2010, on grub-devel@gnu.org
    "Currently we use first and not last entry. You need to:
@@ -88,11 +181,12 @@ void iso_compute_cyl_head_sec(uint32_t *img_blocks, int hpc, int sph,
           bit1= do not mark partition as bootable
 */
 static
-int make_grub_msdos_label(uint32_t img_blocks, uint8_t *buf, int flag)
+int make_grub_msdos_label(uint32_t img_blocks, int sph, int hpc,
+                          uint8_t *buf, int flag)
 {
     uint8_t *wpt;
     uint32_t end_lba, end_sec, end_head, end_cyl;
-    int sph = 63, hpc = 255, i;
+    int i;
 
     iso_compute_cyl_head_sec(&img_blocks, hpc, sph,
                              &end_lba, &end_sec, &end_head, &end_cyl, 0);
@@ -151,17 +245,13 @@ int make_grub_msdos_label(uint32_t img_blocks, uint8_t *buf, int flag)
 */
 static
 int iso_offset_partition_start(uint32_t img_blocks, uint32_t partition_offset,
-                               int sph_in, int hpc_in, uint8_t *buf, int flag)
+                               int sph, int hpc, uint8_t *buf, int flag)
 {
     uint8_t *wpt;
     uint32_t end_lba, end_sec, end_head, end_cyl;
     uint32_t start_lba, start_sec, start_head, start_cyl;
-    int sph = 63, hpc = 255, i;
+    int i;
 
-    if (sph_in > 0)
-      sph = sph_in;
-    if (hpc_in > 0)
-      hpc = hpc_in;
     iso_compute_cyl_head_sec(&partition_offset, hpc, sph,
                            &start_lba, &start_sec, &start_head, &start_cyl, 1);
     iso_compute_cyl_head_sec(&img_blocks, hpc, sph,
@@ -176,7 +266,7 @@ int iso_offset_partition_start(uint32_t img_blocks, uint32_t partition_offset,
     /* C/H/S of the start */
     *(wpt++) = start_head;
     *(wpt++) = start_sec | ((start_cyl & 0x300) >> 2);
-    *(wpt++) = end_cyl & 0xff;
+    *(wpt++) = start_cyl & 0xff;
 
     /* (partition type) */
     wpt++;
@@ -208,9 +298,396 @@ int iso_offset_partition_start(uint32_t img_blocks, uint32_t partition_offset,
 }
 
 
+static int boot_nodes_from_iso_path(Ecma119Image *t, char *path, 
+                                   IsoNode **iso_node, Ecma119Node **ecma_node,
+                                   char *purpose, int flag)
+{
+    int ret;
+
+    ret = iso_tree_path_to_node(t->image, path, iso_node);
+    if (ret < 0) {
+        iso_msg_submit(t->image->id, ISO_BOOT_FILE_MISSING, 0,
+                       "Cannot find %s '%s'", purpose, path);
+        return ISO_BOOT_FILE_MISSING;
+    }
+    if ((*iso_node)->type != LIBISO_FILE) {
+        iso_msg_submit(t->image->id, ISO_BOOT_IMAGE_NOT_VALID, 0,
+                       "Designated boot file is not a data file: '%s'", path);
+        return ISO_BOOT_IMAGE_NOT_VALID;
+    }
+
+    *ecma_node= ecma119_search_iso_node(t, *iso_node);
+    if (*ecma_node == NULL) {
+        iso_msg_submit(t->image->id, ISO_BOOT_IMAGE_NOT_VALID, 0,
+                      "Program error: IsoFile has no Ecma119Node: '%s'", path);
+        return ISO_ASSERT_FAILURE;
+    } else {
+        if ((*ecma_node)->type != ECMA119_FILE) {
+            iso_msg_submit(t->image->id, ISO_BOOT_IMAGE_NOT_VALID, 0,
+              "Program error: Ecma119Node of IsoFile is no ECMA119_FILE: '%s'",
+                          path);
+            return ISO_ASSERT_FAILURE;
+        }
+    }
+    return ISO_SUCCESS;
+}
+
+
+/* This function was implemented according to doc/boot_sectors.txt section
+   "MIPS Volume Header" which was derived by Thomas Schmitt from
+   cdrkit-1.1.10/genisoimage/boot-mips.c by Steve McIntyre which is based
+   on work of Florian Lohoff and Thiemo Seufer who possibly learned from
+   documents of MIPS Computer Systems, Inc. and Silicon Graphics Computer
+   Systems, Inc.
+   This function itself is entirely under copyright (C) 2010 Thomas Schmitt.
+*/
+static int make_mips_volume_header(Ecma119Image *t, uint8_t *buf, int flag)
+{
+    char *namept, *name_field;
+    uint32_t num_cyl, idx, blocks, num, checksum;
+    off_t image_size;
+    static uint32_t bps = 512, spt = 32;
+    Ecma119Node *ecma_node;
+    IsoNode *node;
+    IsoStream *stream;
+    off_t file_size;
+    uint32_t file_lba;
+    int ret;
+
+    /* Bytes 512 to 32767 may come from image or external file */
+    memset(buf, 0, 512);
+
+    image_size = t->curblock * 2048;
+
+    /* 0 -   3 | 0x0be5a941 | Magic number */
+    iso_msb(buf, 0x0be5a941, 4);
+
+    /* 28 -  29 |  num_cyl_l | Number of usable cylinder, lower two bytes */
+    num_cyl = (image_size + (bps * spt) - 1) / (bps * spt);
+    iso_msb(buf + 28, num_cyl & 0xffff, 2);
+
+    /* 32 -  33 |          1 | Number of tracks per cylinder */
+    iso_msb(buf + 32, 1, 2);
+
+    /* 35 -  35 |  num_cyl_h | Number of usable cylinders, high byte */
+    buf[35] = (num_cyl >> 16) & 0xff;
+    
+    /* 38 -  39 |         32 | Sectors per track */
+    iso_msb(buf + 38, spt, 2);
+
+    /* 40 -  41 |        512 | Bytes per sector */
+    iso_msb(buf + 40, bps, 2);
+
+    /* 44 -  47 | 0x00000034 | Controller characteristics */
+    iso_msb(buf + 44, 0x00000034, 4);
+
+    /*  72 -  87 | ========== | Volume Directory Entry 1 */
+    /*  72 -  79 |  boot_name | Boot file basename */
+    /*  80 -  83 | boot_block | ISO 9660 LBA of boot file * 4 */
+    /*  84 -  87 | boot_bytes | File length in bytes */
+    /*  88 - 311 |          0 | Volume Directory Entries 2 to 15 */
+
+    for (idx = 0; idx < t->image->num_mips_boot_files; idx++) {
+        ret = boot_nodes_from_iso_path(t, t->image->mips_boot_file_paths[idx], 
+                                       &node, &ecma_node, "MIPS boot file", 0);
+        if (ret < 0)
+            return ret;
+
+        namept = (char *) iso_node_get_name(node);
+        name_field = (char *) (buf + (72 + 16 * idx));
+        strncpy(name_field, namept, 8);
+
+        file_lba = ecma_node->info.file->sections[0].block;
+
+        iso_msb(buf + (72 + 16 * idx) + 8, file_lba * 4, 4);
+
+        stream = iso_file_get_stream((IsoFile *) node);
+        file_size = iso_stream_get_size(stream);
+
+        /* Shall i really round up to 2048 ? Steve says yes.*/
+        iso_msb(buf + (72 + 16 * idx) + 12,
+                ((file_size + 2047) / 2048 ) * 2048, 4);
+        
+    }
+
+    /* 408 - 411 |  part_blks | Number of 512 byte blocks in partition */
+    blocks = (image_size + bps - 1) / bps;
+    iso_msb(buf + 408, blocks, 4);
+    /* 416 - 419 |          0 | Partition is volume header */
+    iso_msb(buf + 416, 0, 4);
+
+    /* 432 - 435 |  part_blks | Number of 512 byte blocks in partition */
+    iso_msb(buf + 432, blocks, 4);
+    iso_msb(buf + 444, 6, 4);
+
+    /* 504 - 507 |   head_chk | Volume header checksum  
+                                The two's complement of bytes 0 to 503 read
+                                as big endian unsigned 32 bit:
+                                  sum(32-bit-words) + head_chk == 0
+    */
+    checksum = 0;
+    for (idx = 0; idx < 504; idx += 4) {
+        num = iso_read_msb(buf + idx, 4);
+        /* Addition modulo a natural number is commutative and associative.
+           Thus the inverse of a sum is the sum of the inverses of the addends.
+        */
+        checksum -= num;
+    }
+    iso_msb(buf + 504, checksum, 4);
+
+    return ISO_SUCCESS;
+}
+
+
+/* The following two functions were implemented according to
+   doc/boot_sectors.txt section "MIPS Little Endian" which was derived
+   by Thomas Schmitt from
+   cdrkit-1.1.10/genisoimage/boot-mipsel.c by Steve McIntyre which is based
+   on work of Florian Lohoff and Thiemo Seufer,
+   and from <elf.h> by Free Software Foundation, Inc.
+
+   Both functions are entirely under copyright (C) 2010 Thomas Schmitt.
+*/
+
+/**
+ * Read the necessary ELF information from the first MIPS boot file.
+ * This is done before image writing starts.
+ */
+int iso_read_mipsel_elf(Ecma119Image *t, int flag)
+{
+    uint32_t phdr_adr, todo, count;
+    int ret;
+    uint8_t elf_buf[2048];
+    IsoNode *iso_node;
+    Ecma119Node *ecma_node;
+    IsoStream *stream;
+    
+    if (t->image->num_mips_boot_files <= 0)
+        return ISO_SUCCESS;
+
+    ret = boot_nodes_from_iso_path(t, t->image->mips_boot_file_paths[0],
+                                   &iso_node, &ecma_node, "MIPS boot file", 0);
+    if (ret < 0)
+        return ret;
+    stream = iso_file_get_stream((IsoFile *) iso_node);
+
+    ret = iso_stream_open(stream);
+    if (ret < 0) {
+        iso_msg_submit(t->image->id, ret, 0,
+                       "Cannot open designated MIPS boot file '%s'",
+                       t->image->mips_boot_file_paths[0]);
+        return ret;
+    }
+    ret = iso_stream_read(stream, elf_buf, 32);
+    if (ret != 32) {
+cannot_read:;
+        iso_stream_close(stream);
+        iso_msg_submit(t->image->id, ret, 0,
+                       "Cannot read from designated MIPS boot file '%s'",
+                       t->image->mips_boot_file_paths[0]);
+        return ret;
+    }
+
+
+    /*  24 -  27 |    e_entry | Entry point virtual address */
+    t->mipsel_e_entry = iso_read_lsb(elf_buf + 24, 4);
+
+    /* 28 -  31 |    e_phoff | Program header table file offset */
+    phdr_adr = iso_read_lsb(elf_buf + 28, 4);
+
+    /* Skip stream up to byte address phdr_adr */
+    todo = phdr_adr - 32;
+    while (todo > 0) {
+        if (todo > 2048)
+            count = 2048;
+        else
+            count = todo;
+        todo -= count;
+        ret = iso_stream_read(stream, elf_buf, count);
+        if (ret != count)
+            goto cannot_read;
+    }
+    ret = iso_stream_read(stream, elf_buf, 20);
+    if (ret != 20)
+        goto cannot_read;
+
+    /*  4 -   7 |   p_offset | Segment file offset */
+    t->mipsel_p_offset = iso_read_lsb(elf_buf + 4, 4);
+
+    /*  8 -  11 |    p_vaddr | Segment virtual address */
+    t->mipsel_p_vaddr = iso_read_lsb(elf_buf + 8, 4);
+
+    /* 16 -  19 |   p_filesz | Segment size in file */
+    t->mipsel_p_filesz = iso_read_lsb(elf_buf + 16, 4);
+
+    iso_stream_close(stream);
+    return ISO_SUCCESS;
+}
+
+
+/**
+ * Write DEC Bootblock from previously read ELF parameters.
+ * This is done when image writing has already begun.
+ */
+static int make_mipsel_boot_block(Ecma119Image *t, uint8_t *buf, int flag)
+{
+    int ret;
+    uint32_t seg_size, seg_start;
+    IsoNode *iso_node;
+    Ecma119Node *ecma_node;
+    
+    /* Bytes 512 to 32767 may come from image or external file */
+    memset(buf, 0, 512);
+
+    if (t->image->num_mips_boot_files <= 0)
+        return ISO_SUCCESS;
+
+    ret = boot_nodes_from_iso_path(t, t->image->mips_boot_file_paths[0],
+                                   &iso_node, &ecma_node, "MIPS boot file", 0);
+    if (ret < 0)
+        return ret;
+
+    /*  8 -  11 | 0x0002757a | Magic number */
+    iso_lsb(buf + 8, 0x0002757a, 4);
+
+    /* 12 -  15 |          1 | Mode  1: Multi extent boot */
+    iso_lsb(buf + 12, 1, 4);
+
+    /* 16 -  19 |   load_adr | Load address */
+    iso_lsb(buf + 16, t->mipsel_p_vaddr, 4);
+
+    /* 20 -  23 |   exec_adr | Execution address */
+    iso_lsb(buf + 20, t->mipsel_e_entry, 4);
+
+    /* 24 -  27 |   seg_size | Segment size in file. */
+    seg_size = (t->mipsel_p_filesz + 511) / 512;
+    iso_lsb(buf + 24, seg_size, 4);
+    
+    /* 28 -  31 |  seg_start | Segment file offset */
+    seg_start = ecma_node->info.file->sections[0].block * 4
+                + (t->mipsel_p_offset + 511) / 512;
+    iso_lsb(buf + 28, seg_start, 4);
+    
+    return ISO_SUCCESS;
+}
+
+
+/* The following two functions were implemented according to
+   doc/boot_sectors.txt section "SUN Disk Label and boot images" which
+   was derived by Thomas Schmitt from
+     cdrtools-2.01.01a77/mkisofs/sunlabel.h
+     cdrtools-2.01.01a77/mkisofs/mkisofs.8
+     by Joerg Schilling
+
+   Both functions are entirely under copyright (C) 2010 Thomas Schmitt.
+*/
+
+/* @parm flag bit0= copy from next lower valid partition table entry
+ */
+static int write_sun_partition_entry(int partition_number,
+                  char *appended_partitions[],
+                  uint32_t partition_offset[], uint32_t partition_size[],
+                  uint32_t cyl_size, uint8_t *buf, int flag)
+{
+    uint8_t *wpt;
+    int read_idx, i;
+
+    if (partition_number < 1 || partition_number > 8)
+        return ISO_ASSERT_FAILURE;
+    
+    /* 142 - 173 | ========== | 8 partition entries of 4 bytes */
+    wpt = buf + 142 + (partition_number - 1) * 4;
+    if (partition_number == 1)
+        iso_msb(wpt, 4, 2);                            /* 4 = User partition */
+    else
+        iso_msb(wpt, 2, 2);            /* 2 = Root partition with boot image */
+    iso_msb(wpt + 2, 0x10, 2);              /* Permissions: 0x10 = read-only */
+
+    /* 444 - 507 | ========== | Partition table */
+    wpt = buf + 444 + (partition_number - 1) * 8;
+    read_idx = partition_number - 1;
+    if (flag & 1) {
+        /* Search next lower valid partition table entry. #1 is default */
+        for (read_idx = partition_number - 2; read_idx > 0; read_idx--)
+            if (appended_partitions[read_idx] != NULL)
+                if (appended_partitions[read_idx][0] != 0)
+        break;
+    }
+    iso_msb(wpt, partition_offset[read_idx] / (uint32_t) ISO_SUN_CYL_SIZE, 4);
+    iso_msb(wpt + 4, partition_size[read_idx] * 4, 4);
+
+    /* 510 - 511 |   checksum | The result of exoring 2-byte words 0 to 254 */
+    buf[510] = buf[511] = 0;
+    for (i = 0; i < 510; i += 2) {
+        buf[510] ^= buf[i];
+        buf[511] ^= buf[i + 1];
+    }
+
+    return ISO_SUCCESS;
+}
+
+/**
+ * Write SUN Disk Label with ISO in partition 1 and unused 2 to 8
+ */
+static int make_sun_disk_label(Ecma119Image *t, uint8_t *buf, int flag)
+{
+    int ret;
+
+    /* Bytes 512 to 32767 may come from image or external file */
+    memset(buf, 0, 512);
+
+    /* 0 - 127 |      label | ASCII Label */
+    if (t->ascii_disc_label[0])
+        strncpy((char *) buf, t->ascii_disc_label, 128);
+    else
+        strcpy((char *) buf,
+               "CD-ROM Disc with Sun sparc boot created by libisofs");
+    
+    /* 128 - 131 |          1 | Layout version */
+    iso_msb(buf + 128, 1, 4);
+
+    /* 140 - 141 |          8 | Number of partitions */
+    iso_msb(buf + 140, 8, 2);
+
+    /* 188 - 191 | 0x600ddeee | vtoc sanity */
+    iso_msb(buf + 188, 0x600ddeee, 4);
+
+    /* 420 - 421 |        350 | Rotations per minute */
+    iso_msb(buf + 420, 350, 2);
+
+    /* 422 - 423 |       2048 | Number of physical cylinders (fixely 640 MB) */
+    iso_msb(buf + 422, 2048, 2);
+
+    /* 430 - 431 |          1 | interleave factor */
+    iso_msb(buf + 430, 1, 2);
+
+    /* 432 - 433 |       2048 | Number of data cylinders (fixely 640 MB) */
+    iso_msb(buf + 432, 2048, 2);
+
+    /* 436 - 437 |          1 | Number of heads per cylinder (1 cyl = 320 kB)*/
+    iso_msb(buf + 436, 1, 2);
+
+    /* 438 - 439 |        640 | Number of sectors per head (1 head = 320 kB) */
+    iso_msb(buf + 438, 640, 2);
+
+    /* 508 - 509 |     0xdabe | Magic Number */
+    iso_msb(buf + 508, 0xdabe, 2);
+
+    /* Set partition 1 to describe ISO image and compute checksum */
+    t->appended_part_start[0] = 0;
+    t->appended_part_size[0] = t->curblock;
+    ret = write_sun_partition_entry(1, t->appended_partitions,
+                  t->appended_part_start, t->appended_part_size,
+                  ISO_SUN_CYL_SIZE, buf, 0);
+ 
+    return ISO_SUCCESS;
+}
+
+
 int iso_write_system_area(Ecma119Image *t, uint8_t *buf)
 {
-    int ret, int_img_blocks;
+    int ret, int_img_blocks, sa_type, i, will_append = 0;
+    int first_partition = 1, last_partition = 4;
     uint32_t img_blocks;
 
     if ((t == NULL) || (buf == NULL)) {
@@ -220,12 +697,23 @@ int iso_write_system_area(Ecma119Image *t, uint8_t *buf)
     /* set buf to 0s */
     memset(buf, 0, 16 * BLOCK_SIZE);
 
+    sa_type = (t->system_area_options >> 2) & 0x3f;
+    if (sa_type == 3) {
+        first_partition = 2;
+        last_partition = 8;
+    }
+    for (i = first_partition - 1; i <= last_partition - 1; i++)
+        if (t->appended_partitions[i] != NULL) {
+            will_append = 1;
+    break;
+        }
+
     img_blocks = t->curblock;
     if (t->system_area_data != NULL) {
         /* Write more or less opaque boot image */
         memcpy(buf, t->system_area_data, 16 * BLOCK_SIZE);
 
-    } else if (t->catalog != NULL &&
+    } else if (sa_type == 0 && t->catalog != NULL &&
                (t->catalog->bootimages[0]->isolinux_options & 0x0a) == 0x02) {
         /* Check for isolinux image with magic number of 3.72 and produce
            an MBR from our built-in template. (Deprecated since 31 Mar 2010)
@@ -243,12 +731,13 @@ int iso_write_system_area(Ecma119Image *t, uint8_t *buf)
         }
         return ISO_SUCCESS;
     }
-    if (t->system_area_options & 1) {
+    if (sa_type == 0 && (t->system_area_options & 1)) {
         /* Write GRUB protective msdos label, i.e. a simple partition table */
-        ret = make_grub_msdos_label(img_blocks, buf, 0);
+        ret = make_grub_msdos_label(img_blocks, t->partition_secs_per_head,
+                                    t->partition_heads_per_cyl, buf, 0);
         if (ret != ISO_SUCCESS) /* error should never happen */
             return ISO_ASSERT_FAILURE;
-    } else if(t->system_area_options & 2) {
+    } else if(sa_type == 0 && (t->system_area_options & 2)) {
         /* Patch externally provided system area as isohybrid MBR */
         if (t->catalog == NULL || t->system_area_data == NULL) {
             /* isohybrid makes only sense together with ISOLINUX boot image
@@ -257,17 +746,39 @@ int iso_write_system_area(Ecma119Image *t, uint8_t *buf)
             return ISO_ISOLINUX_CANT_PATCH;
         }
         ret = make_isolinux_mbr(&img_blocks, t->bootsrc[0]->sections[0].block,
-                                (uint32_t) 0, 64, 32, 0, 1, 0x17, buf, 1);
+                               (uint32_t) 0, t->partition_heads_per_cyl,
+                               t->partition_secs_per_head, 0, 1, 0x17, buf, 1);
         if (ret != 1)
             return ret;
-    } else if(t->partition_offset > 0) {
+    } else if (sa_type == 1) {
+        ret = make_mips_volume_header(t, buf, 0);
+        if (ret != ISO_SUCCESS)
+            return ret;
+    } else if (sa_type == 2) {
+        ret = make_mipsel_boot_block(t, buf, 0);
+        if (ret != ISO_SUCCESS)
+            return ret;
+    } else if ((t->partition_offset > 0 || will_append) && sa_type == 0) {
         /* Write a simple partition table. */
-        ret = make_grub_msdos_label(img_blocks, buf, 2);
+        ret = make_grub_msdos_label(img_blocks, t->partition_secs_per_head,
+                                    t->partition_heads_per_cyl, buf, 2);
         if (ret != ISO_SUCCESS) /* error should never happen */
             return ISO_ASSERT_FAILURE;
+        if (t->partition_offset == 0) {
+            /* Re-write partion entry 1 : start at 0, type Linux */
+            ret = write_mbr_partition_entry(1, 0x83, 0, img_blocks,
+                        t->partition_secs_per_head, t->partition_heads_per_cyl,
+                        buf, 0);
+            if (ret < 0)
+                return ret;
+        }
+    } else if (sa_type == 3) {
+        ret = make_sun_disk_label(t, buf, 0);
+        if (ret != ISO_SUCCESS)
+            return ret;
     }
 
-    if (t->partition_offset > 0) {
+    if (t->partition_offset > 0 && sa_type == 0) {
         /* Adjust partition table to partition offset */
         img_blocks = t->curblock;                  /* value might be altered */
         ret = iso_offset_partition_start(img_blocks, t->partition_offset,
@@ -277,5 +788,139 @@ int iso_write_system_area(Ecma119Image *t, uint8_t *buf)
             return ISO_ASSERT_FAILURE;
     }
 
+    /* This eventually overwrites the partition table entries made so far */
+    for (i = first_partition - 1; i <= last_partition - 1; i++) {
+        if (t->appended_partitions[i] == NULL)
+    continue;
+        if (sa_type == 3) {
+          ret = write_sun_partition_entry(i + 1, t->appended_partitions,
+                        t->appended_part_start, t->appended_part_size,
+                        ISO_SUN_CYL_SIZE,
+                        buf, t->appended_partitions[i][0] == 0);
+        } else {
+          ret = write_mbr_partition_entry(i + 1, t->appended_part_types[i],
+                        t->appended_part_start[i], t->appended_part_size[i],
+                        t->partition_secs_per_head, t->partition_heads_per_cyl,
+                        buf, 0);
+        }
+        if (ret < 0)
+            return ret;
+    }
+
+    return ISO_SUCCESS;
+}
+
+/* Choose *heads_per_cyl so that
+   - *heads_per_cyl * secs_per_head * 1024 >= imgsize / 512
+   - *heads_per_cyl * secs_per_head is divisible by 4
+   - it is as small as possible (to reduce aligment overhead)
+   - it is <= 255
+   @return 1= success , 0= cannot achieve goals
+*/
+static
+int try_sph(off_t imgsize, int secs_per_head, int *heads_per_cyl, int flag)
+{
+    off_t hd_blocks, hpc;
+
+    hd_blocks= imgsize / 512;
+    hpc = hd_blocks / secs_per_head / 1024;
+    if (hpc * secs_per_head * 1024 < hd_blocks)
+        hpc++;
+    if ((secs_per_head % 4) == 0) {
+        ;
+    } else if ((secs_per_head % 2) == 0) {
+        hpc += (hpc % 2);
+    } else if(hpc % 4) {
+        hpc += 4 - (hpc % 4);
+    }
+    if (hpc > 255)
+        return 0;
+    *heads_per_cyl = hpc;
+    return 1;
+}
+
+int iso_align_isohybrid(Ecma119Image *t, int flag)
+{
+    int sa_type, ret, always_align;
+    uint32_t img_blocks;
+    off_t imgsize, cylsize = 0, frac;
+    char msg[160];
+
+    sa_type = (t->system_area_options >> 2) & 0x3f;
+    if (sa_type != 0)
+        return ISO_SUCCESS;
+    always_align = (t->system_area_options >> 8) & 3;
+
+    img_blocks = t->curblock;
+    imgsize = ((off_t) img_blocks) * (off_t) 2048;
+    if (((t->system_area_options & 3) || always_align)
+        && (off_t) (t->partition_heads_per_cyl * t->partition_secs_per_head
+                    * 1024) * (off_t) 512 < imgsize) {
+        /* Choose small values which can represent the image size */
+        /* First try 32 sectors per head */
+        ret = try_sph(imgsize, 32, &(t->partition_heads_per_cyl), 0);
+        if (ret == 1) {
+            t->partition_secs_per_head = 32;
+        } else {
+            /* Did not work with 32. Try 63 */
+            t->partition_secs_per_head = 63;
+            ret = try_sph(imgsize, 63, &(t->partition_heads_per_cyl), 0);
+            if (ret != 1)
+                t->partition_heads_per_cyl = 255;
+        }
+        cylsize = t->partition_heads_per_cyl * t->partition_secs_per_head *512;
+        frac = imgsize % cylsize;
+        sprintf(msg, "Automatically adjusted MBR geometry to %d/%d/%d",
+                      (int) (imgsize / cylsize + !!frac),
+                      t->partition_heads_per_cyl, t->partition_secs_per_head);
+        iso_msgs_submit(0, msg, 0, "NOTE", 0);
+    }
+
+    if (always_align >= 2)
+        return ISO_SUCCESS;
+
+    cylsize = 0;
+    if (t->catalog != NULL &&
+               (t->catalog->bootimages[0]->isolinux_options & 0x0a) == 0x02) {
+        /* Check for isolinux image with magic number of 3.72 and produce
+           an MBR from our built-in template. (Deprecated since 31 Mar 2010)
+        */
+        if (img_blocks >= 0x40000000)
+            return ISO_SUCCESS;
+        cylsize = 64 * 32 * 512;
+    } else if ((t->system_area_options & 2) || always_align) {
+        /* Patch externally provided system area as isohybrid MBR */
+        if (t->catalog == NULL || t->system_area_data == NULL) {
+            /* isohybrid makes only sense together with ISOLINUX boot image
+               and externally provided System Area.
+            */
+            return ISO_ISOLINUX_CANT_PATCH;
+        }
+        cylsize = t->partition_heads_per_cyl * t->partition_secs_per_head
+                  * 512;
+    } 
+    if (cylsize == 0)
+        return ISO_SUCCESS;
+    if (((double) imgsize) / (double) cylsize > 1024.0) {
+        iso_msgs_submit(0,
+                  "Image size exceeds 1024 cylinders. Cannot align partition.",
+                  0, "WARNING", 0);
+        return ISO_SUCCESS;
+    }
+
+    frac = imgsize % cylsize;
+    imgsize += (frac > 0 ? cylsize - frac : 0);
+
+    frac = imgsize - ((off_t) img_blocks) * (off_t) 2048;
+    if (frac == 0)
+        return ISO_SUCCESS;
+    if (frac % 2048) {
+        sprintf(msg,
+             "Cylinder size %d not divisible by 2048. Cannot align partition.",
+             (int) cylsize);
+        iso_msgs_submit(0, msg, 0, "WARNING", 0);
+    } else {
+        t->tail_blocks += frac / 2048;
+    }
     return ISO_SUCCESS;
 }

libisofs/system_area.h

@@ -46,4 +46,21 @@ int make_isohybrid_mbr(int bin_lba, int *img_blocks, char *mbr, int flag);
  */
 int iso_write_system_area(Ecma119Image *t, uint8_t *buf);
 
+/**
+ * Adjust t->tail_blocks to the eventual alignment needs of isohybrid booting.
+ */
+int iso_align_isohybrid(Ecma119Image *t, int flag);
+
+
+/** 
+ * Read the necessary ELF information from the first MIPS boot file.
+ * See doc/boot_sectors.txt "DEC Boot Block" for "MIPS Little Endian".
+ */
+int iso_read_mipsel_elf(Ecma119Image *t, int flag);
+
+
+/* Compute size and position of appended partitions.
+*/
+int iso_compute_append_partitions(Ecma119Image *t, int flag);
+
 #endif /* SYSTEM_AREA_H_ */

libisofs/tree.c

@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
+ * Copyright (c) 2011 Thomas Schmitt
  * 
  * This file is part of the libisofs project; you can redistribute it and/or 
  * modify it under the terms of the GNU General Public License version 2 
@@ -993,3 +994,194 @@ char *iso_tree_get_node_path(IsoNode *node)
         return strdup(path);
     }
 }
+
+/* ------------------------- tree cloning ------------------------------ */
+
+static
+int iso_tree_copy_node_attr(IsoNode *old_node, IsoNode *new_node, int flag)
+{
+    int ret;
+
+    new_node->mode = old_node->mode;
+    new_node->uid = old_node->uid;
+    new_node->gid = old_node->gid;
+    new_node->atime = old_node->atime;
+    new_node->mtime = old_node->mtime;
+    new_node->ctime = old_node->ctime;
+    new_node->hidden = old_node->hidden;
+    ret = iso_node_clone_xinfo(old_node, new_node, 0);
+    if (ret < 0)
+        return ret;
+    return ISO_SUCCESS;
+}
+
+/*
+  @param flag bit0= merge directory with *new_node
+*/
+static
+int iso_tree_clone_dir(IsoDir *old_dir,
+                       IsoDir *new_parent, char *new_name, IsoNode **new_node,
+                       int flag)
+{
+    IsoDir *new_dir = NULL;
+    IsoNode *sub_node = NULL, *new_sub_node = NULL;
+    IsoDirIter *iter = NULL;
+    int ret;
+
+    if (flag & 1) {
+        new_dir = (IsoDir *) *new_node;
+    } else {
+        *new_node = NULL;
+        ret = iso_tree_add_new_dir(new_parent, new_name, &new_dir);
+        if (ret < 0)
+           return ret;
+    }
+    /* Avoid traversal of target directory to allow cloning of old_dir to a
+       subordinate of old_dir.
+    */
+    iso_node_take((IsoNode *) new_dir);
+
+    ret = iso_dir_get_children(old_dir, &iter);
+    if (ret < 0)
+        goto ex;
+    while(1) {
+        ret = iso_dir_iter_next(iter, &sub_node);
+        if (ret == 0)
+    break;
+        ret = iso_tree_clone(sub_node, new_dir, sub_node->name, &new_sub_node,
+                             flag & 1);
+        if (ret < 0)
+            goto ex;
+    }
+
+    /* Now graft in the new tree resp. graft back the merged tree */
+    ret = iso_dir_add_node(new_parent, (IsoNode *) new_dir, 0);
+    if (ret < 0)
+        goto ex;
+
+    if (!(flag & 1))
+        *new_node = (IsoNode *) new_dir;
+    ret = ISO_SUCCESS;
+ex:;
+    if (iter != NULL)
+        iso_dir_iter_free(iter);
+    if (ret < 0 && new_dir != NULL) {
+	if (flag & 1) {
+            /* graft back the merged tree (eventually with half copy) */
+            iso_dir_add_node(new_parent, (IsoNode *) new_dir, 0);
+        } else {
+            iso_node_remove_tree((IsoNode *) new_dir, NULL);
+            *new_node = NULL;
+        }
+    }
+    return ret;
+}
+
+static
+int iso_tree_clone_file(IsoFile *old_file,
+                        IsoDir *new_parent, char *new_name, IsoNode **new_node,
+                        int flag)
+{
+    IsoStream *new_stream = NULL;
+    IsoFile *new_file = NULL;
+    int ret;
+
+    *new_node = NULL;
+
+    ret = iso_stream_clone(old_file->stream, &new_stream, 0);
+    if (ret < 0)
+        return ret;
+
+    ret = iso_tree_add_new_file(new_parent, new_name, new_stream, &new_file);
+    if (ret < 0)
+        goto ex;
+    new_stream = NULL; /* now owned by new_file */
+    new_file->sort_weight = old_file->sort_weight;
+    *new_node = (IsoNode *) new_file;
+    ret = ISO_SUCCESS;
+ex:;
+    if (new_stream != NULL)
+        iso_stream_unref(new_stream);
+    return ret;
+}
+
+static
+int iso_tree_clone_symlink(IsoSymlink *node,
+                        IsoDir *new_parent, char *new_name, IsoNode **new_node,
+                        int flag)
+{
+    IsoSymlink *new_sym;
+    int ret;
+
+    *new_node = NULL;
+
+    ret = iso_tree_add_new_symlink(new_parent, new_name, node->dest, &new_sym);
+    if (ret < 0)
+        return ret;
+    new_sym->fs_id = node->fs_id;
+    new_sym->st_dev = node->st_dev;
+    new_sym->st_ino = node->st_ino;
+    *new_node = (IsoNode *) new_sym;
+    return ISO_SUCCESS;
+}
+
+static
+int iso_tree_clone_special(IsoSpecial *node,
+                        IsoDir *new_parent, char *new_name, IsoNode **new_node,
+                        int flag)
+{
+    IsoSpecial *new_spec;
+    IsoNode *iso_node;
+    int ret;
+
+    iso_node = (IsoNode *) node;
+    ret = iso_tree_add_new_special(new_parent, new_name, iso_node->mode,
+                                   node->dev, &new_spec);
+    if (ret < 0)
+        return ret;
+    new_spec->fs_id = node->fs_id;
+    new_spec->st_dev = node->st_dev;
+    new_spec->st_ino = node->st_ino;
+    *new_node = (IsoNode *) new_spec;
+    return ISO_SUCCESS;
+}
+
+/* API */
+int iso_tree_clone(IsoNode *node,
+                   IsoDir *new_parent, char *new_name, IsoNode **new_node,
+                   int flag)
+{
+    int ret = ISO_SUCCESS;
+
+    if (iso_dir_get_node(new_parent, new_name, new_node) == 1) {
+        if (! (node->type == LIBISO_DIR && (*new_node)->type == LIBISO_DIR &&
+               (flag & 1))) {
+            *new_node = NULL;
+            return ISO_NODE_NAME_NOT_UNIQUE;
+        }
+    } else
+        flag &= ~1;
+
+    if (node->type == LIBISO_DIR) {
+        ret = iso_tree_clone_dir((IsoDir *) node, new_parent, new_name,
+                                 new_node, flag & 1);
+    } else if (node->type == LIBISO_FILE) {
+        ret = iso_tree_clone_file((IsoFile *) node, new_parent, new_name, 
+                                  new_node, 0);
+    } else if (node->type == LIBISO_SYMLINK) {
+        ret = iso_tree_clone_symlink((IsoSymlink *) node, new_parent, new_name,
+                                  new_node, 0);
+    } else if (node->type == LIBISO_SPECIAL) {
+        ret = iso_tree_clone_special((IsoSpecial *) node, new_parent, new_name,
+                                    new_node, 0);
+    } else if (node->type == LIBISO_BOOT) {
+        ret = ISO_SUCCESS; /* API says they are silently ignored */
+    }
+    if (ret < 0)
+        return ret;
+    if (flag & 1)
+        return 2; /* merged two directories, *new_node is not new */
+    ret = iso_tree_copy_node_attr(node, *new_node, 0);
+    return ret;
+}
+

libisofs/util.c

@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2007 Vreixo Formoso
  * Copyright (c) 2007 Mario Danic
- * Copyright (c) 2009 Thomas Schmitt
+ * Copyright (c) 2009 - 2011 Thomas Schmitt
  * 
  * This file is part of the libisofs project; you can redistribute it and/or 
  * modify it under the terms of the GNU General Public License version 2 
@@ -773,6 +773,8 @@ char *iso_r_dirid(const char *src, int size, int relaxed)
         len = size;
     }
     dest = malloc(len + 1);
+    if (dest == NULL)
+        return NULL;
     for (i = 0; i < len; i++) {
         char c= src[i];
         if (relaxed == 2) {
@@ -1036,6 +1038,8 @@ uint16_t *ucsdup(const uint16_t *str)
     size_t len = ucslen(str);
     
     ret = malloc(2 * (len + 1));
+    if (ret == NULL)
+        return NULL;
     if (ret != NULL) {
         memcpy(ret, str, 2 * (len + 1));
     }
@@ -1294,12 +1298,41 @@ void iso_datetime_17(unsigned char *buf, time_t t, int always_gmt)
 }
 
 #ifndef HAVE_TIMEGM
+
+/* putenv is SVr4, POSIX.1-2001, 4.3BSD , setenv is 4.3BSD, POSIX.1-2001.
+   So putenv is more widely available.
+   Also, setenv spoils eventual putenv expectation of applications because
+   putenv installs the original string which then may be altered from
+   its owner. setenv installs a copy that may not be altered.
+   Both are slow.
+   Thus first try with a naive implementation that assumes no leap seconds.
+   If it fails a test with gmtime() then use the slow function with mktime().
+*/
+#define Libisofs_use_putenV yes
+
 static
-time_t timegm(struct tm *tm)
+time_t env_timegm(struct tm *tm)
 {
     time_t ret;
     char *tz;
 
+#ifdef Libisofs_use_putenV
+
+    static char unset_name[] = {"TZ"};
+
+    tz = getenv("TZ");
+    putenv("TZ=");
+    tzset();
+    ret = mktime(tm);
+    if (tz != NULL) {
+        /* tz is a pointer to the value part in a string of form "TZ="value */
+        putenv(tz - 3);
+    } else
+        putenv(unset_name); /* not daring to submit constant */
+    tzset();
+
+#else /* Libisofs_use_putenV */
+
     tz = getenv("TZ");
     setenv("TZ", "", 1);
     tzset();
@@ -1309,9 +1342,92 @@ time_t timegm(struct tm *tm)
     else
         unsetenv("TZ");
     tzset();
+
+#endif /* ! Libisofs_use_putenV */
+
     return ret;
 }
-#endif
+
+static
+int ts_is_leapyear(int tm_year) /* years since 1900 */
+{
+  return ((tm_year % 4) == 0 && ((tm_year % 100) != 0 ||
+                                 (tm_year % 400) == 100));
+}
+
+/* Fast implementation without leap seconds.
+   Inspired by but not copied from code by Kungliga Tekniska Hgskolan
+   (Royal Institute of Technology, Stockholm, Sweden),
+   which was modified by Andrew Tridgell for Samba4.
+   I claim own copyright 2011 Thomas Schmitt <scdbackup@gmx.net>.
+*/ 
+static
+time_t ts_timegm(struct tm *tm)
+{
+    time_t ret;
+    static int month_length_normal[12] =
+                {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    static int month_length_leap[12] =
+                {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+    int *month_length_pt;
+    int years, i;
+
+    ret = 0;
+
+    years = tm->tm_year - 70; /* Years since 1970 */
+    if (years < 0)
+        return ret;
+    for (i = 0; i < years; i++) {
+        ret += 365 * 86400;
+        if (ts_is_leapyear(70 + i))
+            ret += 86400;
+    }
+    if (ts_is_leapyear(tm->tm_year))
+        month_length_pt = month_length_leap;
+    else
+        month_length_pt = month_length_normal;
+    for (i = 0; i < tm->tm_mon; i++)
+        ret += month_length_pt[i] * 86400;
+    ret += (tm->tm_mday - 1) * 86400;
+    ret += tm->tm_hour * 3600;
+    ret += tm->tm_min * 60;
+    ret += tm->tm_sec;
+    return ret;
+}
+
+static
+time_t timegm(struct tm *tm)
+{
+    time_t raw_t, ret;
+    struct tm *test_tm, input_tm_copy;
+
+    /* Beware of ill effects if tm is result of gmtime() or alike */
+    memcpy(&input_tm_copy, tm, sizeof(struct tm));
+
+    /* Try without leapseconds (which are rarely implemented, as it seems) */
+    raw_t = ts_timegm(tm);
+    if (raw_t == 0)
+        return raw_t;
+
+    /* Check whether this translates back to the input values */
+    test_tm = gmtime(&raw_t);
+    if (input_tm_copy.tm_sec == test_tm->tm_sec &&
+        input_tm_copy.tm_min == test_tm->tm_min &&
+        input_tm_copy.tm_hour == test_tm->tm_hour &&
+        input_tm_copy.tm_mday == test_tm->tm_mday &&
+        input_tm_copy.tm_mon == test_tm->tm_mon &&
+        input_tm_copy.tm_year == test_tm->tm_year) {
+        ret = raw_t;
+    } else {
+        /* Mismatch. Use slow method around mktime() */
+        ret = env_timegm(&input_tm_copy);
+    }
+    return ret;
+}
+
+
+#endif /* ! HAVE_TIMEGM */
+
 
 time_t iso_datetime_read_7(const uint8_t *buf)
 {
@@ -1323,6 +1439,7 @@ time_t iso_datetime_read_7(const uint8_t *buf)
     tm.tm_hour = buf[3];
     tm.tm_min = buf[4];
     tm.tm_sec = buf[5];
+
     return timegm(&tm) - ((int8_t)buf[6]) * 60 * 15;
 }
 
@@ -1460,6 +1577,8 @@ char *ucs2str(const char *buf, size_t len)
     
     /* ensure enought space */
     out = calloc(outbytes, 1);
+    if (out == NULL)
+        return NULL;
 
     /* convert to local charset */
     conv_ret = iso_iconv_open(&conv, iso_get_local_charset(0), "UCS-2BE", 0);
@@ -1721,10 +1840,24 @@ unexpected_type:;
         iso_msg_submit(-1, ISO_MD5_TAG_UNEXPECTED, 0, NULL);
         ret = 0;
         goto ex;
-    } else if(pos != lba) {
+    } else if (pos != lba) {
+        if (*tag_type == 2) { /* Superblock tag */
+            if (lba < 32) {
+                /* Check whether this is a copied superblock */
+                range_start -= (off_t) pos - (off_t) lba;
+                if (range_start != ctx_start_lba) {
+
+                    /* >>> check for matching MD5 ? */;
+
+                    ret = ISO_MD5_TAG_MISPLACED;
+                } else
+                    ret = ISO_MD5_TAG_COPIED;
+                goto ex;
+            }
+        }
         ret = ISO_MD5_TAG_MISPLACED;
         goto ex;
-    } else if(range_start != ctx_start_lba) {
+    } else if (range_start != ctx_start_lba) {
         ret = ISO_MD5_TAG_MISPLACED;
     }
     ret = iso_md5_clone(ctx, &cloned_ctx);

libisofs/util.h

@@ -11,7 +11,14 @@
 #ifndef LIBISO_UTIL_H_
 #define LIBISO_UTIL_H_
 
+#ifdef HAVE_STDINT_H
 #include <stdint.h>
+#else
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+#endif
+
 #include <time.h>
 
 #ifndef MAX
@@ -505,12 +512,26 @@ int iso_util_tag_magic(int tag_type, char **tag_magic, int *len, int flag);
  */
 int checksum_cx_xinfo_func(void *data, int flag);
 
+/* The iso_node_xinfo_cloner function which gets associated to 
+ * checksum_cx_xinfo_func by iso_init() resp. iso_init_with_flag() via 
+ * iso_node_xinfo_make_clonable()
+ */
+int checksum_cx_xinfo_cloner(void *old_data, void **new_data, int flag);
+
+
 /* Function to identify and manage md5 sums of unspecified providence stored
  * directly in this xinfo. This is supposed to override any other recorded
  * MD5 of the node unless data get copied and checksummed during that copying.
  */
 int checksum_md5_xinfo_func(void *data, int flag);
 
+/* The iso_node_xinfo_cloner function which gets associated to 
+ * checksum_md5_xinfo_func by iso_init() resp. iso_init_with_flag() via 
+ * iso_node_xinfo_make_clonable()
+ */
+int checksum_md5_xinfo_cloner(void *old_data, void **new_data, int flag);
+
+
 /* ------------------------------------------------------------------------- */