Updated change log

AUTHORS

@@ -1,5 +1,3 @@
-Developers:
-
 Mario Danic 
 Thomas Schmitt
-Lorenzo Taylor
+

CONTRIBUTORS

@@ -3,3 +3,4 @@ Philippe Rouquier
 Gabriel Craciunescu
 George Danchev
 Jean-Francois Wauthy
+Lorenzo Taylor

COPYRIGHT

@@ -1,13 +1,12 @@
 Derek Foreman <derek@signalmarketing.com> and Ben Jansens <xor@orodu.net>
 Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
 Mario Danic <mario.danic@gmail.com>, Thomas Schmitt <scdbackup@gmx.net>
-Copyright (C) 2006-2007 Mario Danic, Thomas Schmitt
+Copyright (C) 2006-2011 Mario Danic, Thomas Schmitt
 
 
     This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
+    it under the terms of the GNU General Public License version 2 or later
+    as published by the Free Software Foundation.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of

ChangeLog

@@ -1 +1,327 @@
-nothing here now
+libburn-1.1.8.tar.gz Mon Nov 21 2011
+===============================================================================
+* Bug fix: Misinterpreted mode page 2A if block descriptors are present
+* Enabled recognition of QEMU DVD-ROM 0.12
+* Avoiding to intermediately close and open drive device file
+* New API call burn_drive_re_assess()
+
+libburn-1.1.6.tar.gz Tue Sep 27 2011
+===============================================================================
+* Bug fix: stdio sizes > 4 TB - 32 kB caused integer rollover
+* Worked around a collision with Linux udev which lets links vanish
+
+libburn-1.1.4.tar.gz Sun Aug 07 2011
+===============================================================================
+* Bug fix: Some drives return -150 as NWA of blank CD, rather than 0.
+           libburn forwarded this misleading information to the application.
+* Bug fix: Some drives returned wrong CD sizes after having burned DVD-R
+* Bug fix: Empty ROM drive was mistaken to hold an unsuitable disc
+* Bug fix: Avoiding to load speed descriptor list twice
+* New API call burn_lookup_device_link()
+* New API call burn_disc_get_phys_format_info()
+* New cdrskin option --device_links
+
+Release 1.1.2 was skipped to get back in sync with libisoburn.
+
+libburn-1.1.0.pl01.tar.gz Mon Jun 20 2011
+===============================================================================
+* Bug fix: libburn-1.1.0 compiled only on Linux, FreeBSD, and Solaris
+
+libburn-1.1.0.tar.gz Sat Jun 18 2011
+===============================================================================
+* Bug fix: burn_disc_format() on DVD-RW issued wrong block size with type 00h
+* New API call burn_disc_next_track_is_damaged()
+* New API call burn_disc_close_damaged()
+* Dropped suffix .plXY from tarball name
+
+Release 1.0.8 was skipped to get back in sync with libisofs and libisoburn.
+
+libburn-1.0.6.pl00.tar.gz Sat Apr 9 2011
+===============================================================================
+* Burning DVD-R DAO with 2 kB size granularity rather than 32 kB
+* New API call burn_allow_drive_role_4()
+
+libburn-1.0.4.pl00.tar.gz Thu Mar 3 2011
+===============================================================================
+* Bug fix: Read-only file descriptors were classified as write-only pseudo
+           drives
+
+libburn-1.0.2.pl00.tar.gz Wed Feb 23 2011
+===============================================================================
+* Removed compilation obstacles on Solaris 9.
+* Improved recognition of non-seekable stdio pseudo-drives.
+
+libburn-1.0.0.pl00.tar.gz Sun Jan 16 2011
+===============================================================================
+* Allowed umask to create stdio-drive files with rw-permissions for all
+* cdrskin now refuses to burn if the foreseeable size exceeds media capacity
+
+libburn-0.9.0.pl00.tar.gz Wed Dec 08 2010
+===============================================================================
+* Regression fix: SCSI reply data logging was disabled in release 0.8.6
+
+libburn-0.8.8.pl00.tar.gz Wed Oct 20 2010
+===============================================================================
+* New API call burn_offst_source_new()
+* New API call burn_disc_get_bd_spare_info()
+
+libburn-0.8.6.pl00.tar.gz Fri Sep 17 2010
+===============================================================================
+* Lifted test reservation on DVD-R DL media.
+* Hiding all non-API symbols from the linker by use of --version-script
+* Now with history of release notes in ./ChangeLog file.
+
+libburn-0.8.4.pl00.tar.gz Wed Jun 30 2010
+===============================================================================
+* General POSIX system adapters ignore SIGWINCH and SIGURG if defined
+* Allowed 64 kB max output buffer size on all OSes
+
+libburn-0.8.2.pl00.tar.gz Fri Jun 11 2010
+===============================================================================
+* New system adapter for Solaris uscsi (tested on snv134, kernel 5.11)
+* Bug fix: CD TOC was not read if the first track did not start at LBA 0
+* Bug fix: CD-ROM media got attributed random lead-in and lead-out adresses
+* Bug fix: SIGSEGV of experimental libcdio system adapter if drive list is
+  empty
+
+libburn-0.8.0.pl00.tar.gz Fri Apr 09 2010
+===============================================================================
+* libburn now works with ahci driver on FreeBSD 8-STABLE.
+
+libburn-0.7.8.pl00.tar.gz Wed Mar 10 2010
+===============================================================================
+* Bug fix: On FreeBSD, piped input was falsely attributed a small fixed size.
+* Built-in abort handling is more suitable for FreeBSD now.
+cdrskin novelties:
+* Bug fix: Option fs=0 led to SIGSEGV. Regression introduced by version 0.7.4
+  in december 2009.
+* Abort handling is more suitable for FreeBSD now.
+
+libburn-0.7.6.pl00.tar.gz Sat Jan 23 2010
+===============================================================================
+* Bug fix: System adapter for generic X/Open was missing in libburn release
+  tarball
+* Bug fix: with non-Linux adapters there were 0 readable bytes on block devices
+* Made FreeBSD system adapter safe from mutal burn spoiling and drive deadlock
+* Enabled FreeBSD system adapter for Debian kfreebsd
+* Experimental SCSI transport adapter via GNU libcdio 0.83git
+cdrskin novelties:
+* none
+
+libburn-0.7.4.pl01.tar.gz Sat Dec 26 2009
+===============================================================================
+* Bug fix: Added missing system adapter for generic X/Open to libburn release
+  tarball
+
+Libburn 0.7.4.pl00 Mon Dec 07 2009
+===============================================================================
+* Bug fix: SIGSEGV from NULL pointer with media product id inquiry on LG
+  GH22LS30
+* Bug fix: DVD DAO track size was rounded up much too generously
+* Workaround for Pioneer DVR-216D which got stuck on DVD-R burns. 
+  (already fixed in 0.7.2.pl01)
+* Workaround for Pioneer DVR-216D refusal to eject.
+  (already fixed in 0.7.2.pl01)
+* Configure options --enable-dvd-obs-64k, --enable-track-src-odirect
+* New API calls burn_write_opts_set_dvd_obs(), 
+  burn_write_opts_set_stdio_fsync()
+* New API call burn_set_scsi_logging()
+* New API calls burn_fifo_get_statistics(), burn_fifo_next_interval(),
+  burn_fifo_fill()
+* Re-implemented ECMA-130 P-parity, Q-parity and scrambling for BURN_WRITE_RAW
+cdrskin novelties:
+* cdrskin option -V for logging of SCSI commands
+* New cdrskin options dvd_obs= and stdio_fsync=
+* New compile_cdrskin.sh option -dvd_obs_64k
+
+libburn-0.7.2.pl01.tar.gz Fri Nov 13 2009
+===============================================================================
+* Workaround for Pioneer DVR-216D which got stuck on DVD-R burns.
+* Workaround for Pioneer DVR-216D refusal to eject.
+
+Libburn 0.7.2.pl00 Mon Oct 12 2009
+===============================================================================
+* Bug fix: CD TAO sessions with multiple tracks did not work in -dummy mode
+* New API calls burn_get_media_product_id() , burn_guess_manufacturer() ,
+  burn_guess_cd_manufacturer()
+* New API call burn_disc_get_cd_info()
+* New API call burn_track_set_cdxa_conv()
+cdrskin novelties:
+* Better interpretation of options -mode2, -xa, -xa1, -xa2
+* New option --xa1-ignore
+* New -atip report lines "Product Id:" and "Producer:"
+
+libburn-0.7.0.pl00.tar.gz Thu Aug 27 2009
+===============================================================================
+* New API calls burn_drive_get_all_profiles(), burn_obtain_profile_name() allow
+  to inquire and process the list of supported media types. cdrskin lists all
+  supported profiles with option -atip -v
+* New API call burn_drive_snooze() allows to calm down a drive when no i/o is
+  expected for a while.
+* Bug fix: Some SCSI commands stalled on U3 memory sticks which appear as a hub
+  with a memory stick and a CD-ROM drive containing a small CD. These commands
+  make not much sense with a CD-ROM and are now avoided for this media 
+  situation.
+
+libburn-0.6.8.pl00.tar.gz Tue Jul 14 2009
+===============================================================================
+* Bug fix: Old MMC-1 drives were rejected because of mode page 2Ah length.
+* cdrskin -scanbus now works with high SCSI bus numbers.
+
+libburn-0.6.6.pl00.tar.gz Fri May 8 2009
+===============================================================================
+* Bug fix: Improper abort handling with broken pipe during outputto a stdio:
+  pseudo-drive.
+* Bug fix: Device scan stalled on FreeBSD with non-burner USB device
+
+libburn-0.6.4.pl00.tar.gz Fri Mar 13 2009
+===============================================================================
+* New operating system adapter "dummy" for stdio on general X/Open systems
+* New API function burn_drive_set_stream_recording() allows to write the 
+  crucial start blocks of a filesystem with slow BD-RE Defect Management and to
+  write the bulk of data with full nominal speed.
+
+libburn-0.6.2.pl00.tar.gz Fri Feb 20 2009
+===============================================================================
+* Improvements with build system for FreeBSD
+
+libburn-0.6.0.pl01.tar.gz Wed Jan 07 2009
+===============================================================================
+* Bug fix: BD-R were not correctly finalized
+
+libburn-0.6.0.pl00.tar.gz Sun Jan 04 2009
+===============================================================================
+* Formatting and writing of BD-R media
+* New API function burn_get_read_capacity()
+
+libburn-0.5.8.pl00.tar.gz Mon Dec 08 2008
+===============================================================================
+* Bug fix: A session without leadout entry on CD caused a SIGSEGV by NULL
+* Improvements about BD-RE formatting
+
+libburn-0.5.6.pl00.tar.gz Wed Nov 12 2008
+===============================================================================
+* Bug fix: libburn fifo thread was not aborted when burn run was aborted which
+  could lead to use of freed memory.
+
+libburn-0.5.4.pl00.tar.gz Mon Oct 6 2008
+===============================================================================
+* Bug fix: On Linux 2.4 /dev/sr0 was accepted as enumerable address but then
+  failed to work.
+
+libburn-0.5.2.pl00.tar.gz Wed Aug 20 2008
+===============================================================================
+* Larger set of possibly acceptable drive device file names
+
+libburn-0.5.0.pl00.tar.gz Thu Jul 17 2008
+===============================================================================
+* Bug fix: cdrskin option drive_scsi_dev_family=scd lead to buffer overflow
+* Ability to use /dev/scd as fallback if /dev/sr does not exist
+* New API call burn_fifo_peek_data()
+
+libburn-0.4.8.pl00.tar.gz Sat May 17 2008
+===============================================================================
+* Bug fix: Random access addressing for DVD-RAM and BD-RE did not work.
+* cdrskin: Affected were options write_start_address= and 
+  -- grow_overwriteable_iso on DVD-RAM or BD-RE.
+* xorriso: Affected were sessions on DVD-RAM or BD-RE after the first one.
+
+libburn-0.4.6.pl00.tar.gz Sun May 11 2008
+===============================================================================
+* Support for BD-RE media is now official
+* New burn_write_opts_set_stream_recording() can speed up DVD-RAM and BD-RE
+* New cdrskin option --list_formats
+* New cdrskin blank types for expert formatting of DVD-RAM and BD-RE
+* New cdrskin blank type blank=as_needed for automatic handling of media
+
+libburn-0.4.4.tar.gz Thu April 10 2008
+===============================================================================
+* Support for DVD+R/DL media is now official
+
+libburn-0.4.2.tar.gz Sun Feb 3 2008
+===============================================================================
+* Long term commitment to ABI libburn.so.4.
+* ABI compatibility is guaranteed for any older feature set released since
+  libburn-0.3.2 about one year ago.
+* libburn provides means for compile time and runtime checking of its version.
+* Compile time check in cdrskin for proper version of libburn include file.
+  Required is at least 0.4.2.
+* Runtime check in cdrskin prevents dynamic linking with outdated version of
+  libburn.so.4. Required is at least the version seen in the include file at
+  compile time.
+
+libburn-0.4.0.tar.gz Mon Oct 29 2007
+===============================================================================
+* New option direct_write_amount=
+* New option --grow_overwriteable_iso
+* New option --allow_emulated_drives dev=stdio:<path>
+* More cdrecord options supported: -format, -inq, -load, -lock, -immed, -waiti
+* New option fallback_program=
+* A lot of libburn API additions.
+
+libburn-0.3.8.tar.gz Tue Jul 31 2007
+===============================================================================
+* Now able to cope with the peculiarities of Linux 2.4 USB
+* Refusal to perform -dummy runs on media which cannot simulate burning
+* New option modesty_on_drive= may help with hda -> hdb burns
+* New option minbuf= , cdrecord compatible frontend of modesty_on_drive=
+* New option --adjust_speed_to_drive
+* Precautions against using the burner drive as track source
+* Note: ABI has not been broken.
+
+libburn-0.3.6.tar.gz Thu Apr 26 2007
+===============================================================================
+* On Linux kernel 2.6, /dev/sr* gets used rather than /dev/sg*.
+* DVD+R now get finalized (if not -multi is given)
+
+libburn-0.3.4.tar.gz Mon Mar 12 2007
+===============================================================================
+* Multi-session recording on DVD+R, including -toc, -msinfo
+* Options --tell_media_space , assert_write_lba=
+* Bug fix of rare multi track fifo stall
+
+libburn-0.3.2.tar.gz Feb 11 2007
+===============================================================================
+* Burnfree enabled by default
+* Multi-session recording on sequential DVD-R[W], including -toc, -msinfo
+* DVD-R[W] Disk-at-once recording
+
+libburn-0.3.0.1.tar.gz Tue Jan 30 2007
+===============================================================================
+* Improved recognition of unsuitable media types
+* Replaced ban of chmod u+s by loud warning
+* detailed man page for cdrskin
+* Burning of DVD+RW and DVD-RAM media as single-track TAO-like initial session
+* Formatting and then burning to DVD-RW like to DVD+RW
+* New option -msifile=path from cdrkit/wodim
+* 0.3.0.1 release notes *
+* Bug fix enabling tracks >= 1.3 GB from disk file
+
+libburn-0.2.6.3.tar.gz Fri Dec 29 2006
+===============================================================================
+* 0.2.6 release notes (Wed Nov 22 2006) 
+* After a lot of time with dedication to this project, we proudly present you
+  libburn 0.2.6. It is the first version of cdrskin and libburn after they have
+  been split from genisofs and libisofs. Main new features are write mode TAO 
+  and support for multi session.
+* 0.2.6.1 release notes (Fri Nov 24 2006) 
+* Point release to fix misleading version numbers in messages and documentation
+* 0.2.6.2 release notes (Sat Dec 16 2006) 
+* cdrskin man page backported from development version 0.2.7.
+* 0.2.6.3 release notes (Fri Dec 29 2006) 
+* Point release to fix build system problems people have experienced with the
+  past release.
+
+libburn-0.2.3.snapshot02.tar.gz Thu Nov 02 2006
+===============================================================================
+* Stabilized snapshot including release 0.2.4.pl01 of cdrskin
+* cdrskin 0.2.4 release notes 
+* Compatibility with cdrecord has been improved in respect to drive addresses,
+  audio extraction from .wav, -scanbus, -toc, drive buffer fill indicator.
+* Note: The previous snapshot01 with the same source base is handicapped by a
+  broken ./configure setup. It works well on Intel compatible CPUs but is
+  supposed to be unusable on big-endian architectures.
+
+libburn-0.2.2.tar.gz Wed Sep 20 2006
+===============================================================================
+Initial release of libburnia's libburn combined with cdrskin.

Makefile.am

@@ -1,13 +1,21 @@
-pkgconfigdir=$(libdir)/pkgconfig
+
+# ts A90315 : LIBBURNIA_PKGCONFDIR is defined OS specific in acinclude.m4
+# was: pkgconfigdir=$(libdir)/pkgconfig
+pkgconfigdir=$(LIBBURNIA_PKGCONFDIR)
+
 libincludedir=$(includedir)/libburn
 
 lib_LTLIBRARIES = libburn/libburn.la 
+ACLOCAL_AMFLAGS = -I ./
 
 ## ========================================================================= ##
 
 # Build libraries
 libburn_libburn_la_LDFLAGS = \
 	-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
+# This causes undesired .o names
+# configure.ac appends -D options to variable CFLAG
+### libburn_libburn_la_CFLAGS = $(LIBBURN_DVD_OBS_64K)
 libburn_libburn_la_LIBADD = $(LIBBURN_ARCH_LIBS) $(THREAD_LIBS)
 libburn_libburn_la_SOURCES = \
 	libburn/async.c \
@@ -21,13 +29,13 @@ libburn_libburn_la_SOURCES = \
 	libburn/debug.h \
 	libburn/drive.c \
 	libburn/drive.h \
+	libburn/ecma130ab.c \
+	libburn/ecma130ab.h \
 	libburn/error.h \
 	libburn/file.c \
 	libburn/file.h \
 	libburn/init.c \
 	libburn/init.h \
-	libburn/lec.c \
-	libburn/lec.h \
 	libburn/libburn.h \
 	libburn/libdax_audioxtr.h \
 	libburn/libdax_audioxtr.c \
@@ -68,11 +76,15 @@ libburn_libburn_la_SOURCES = \
 libinclude_HEADERS = \
 	libburn/libburn.h 
 
+install-exec-hook:
+	$(LIBBURNIA_LDCONFIG_CMD) "$(DESTDIR)$(libdir)" || echo 'NOTE: Explicite dynamic library configuration failed. If needed, configure manually for:' "$(DESTDIR)$(libdir)"
+
 ## ========================================================================= ##
 
 ## Build test applications
 noinst_PROGRAMS = \
 	test/libburner \
+	test/offst_source \
 	test/telltoc \
 	test/dewav \
 	test/fake_au \
@@ -82,29 +94,38 @@ noinst_PROGRAMS = \
 bin_PROGRAMS = \
 	cdrskin/cdrskin
 
+LIBBURN_EXTRALIBS = $(LIBBURN_ARCH_LIBS) $(THREAD_LIBS)
+
 test_libburner_CPPFLAGS = -Ilibburn
-test_libburner_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_libburner_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 test_libburner_SOURCES = test/libburner.c
+test_offst_source_CPPFLAGS = -Ilibburn
+test_offst_source_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
+test_offst_source_SOURCES = test/offst_source.c
 test_telltoc_CPPFLAGS = -Ilibburn
-test_telltoc_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_telltoc_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 test_telltoc_SOURCES = test/telltoc.c
 test_dewav_CPPFLAGS = -Ilibburn
-test_dewav_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_dewav_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 test_dewav_SOURCES = test/dewav.c
 test_fake_au_CPPFLAGS = 
 test_fake_au_LDADD =
 test_fake_au_SOURCES = test/fake_au.c
 test_poll_CPPFLAGS = -Ilibburn
-test_poll_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_poll_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 test_poll_SOURCES = test/poll.c
 test_structest_CPPFLAGS = -Ilibburn
-test_structest_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+test_structest_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 test_structest_SOURCES = test/structest.c
 
-##  cdrskin construction site - ts A60816 - A70312
+##  cdrskin construction site - ts A60816 - B10808
 cdrskin_cdrskin_CPPFLAGS = -Ilibburn
-cdrskin_cdrskin_CFLAGS = -DCdrskin_libburn_0_3_5
-cdrskin_cdrskin_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+cdrskin_cdrskin_CFLAGS = -DCdrskin_libburn_1_1_8
+
+# cdrskin_cdrskin_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
+# ts A80123, change proposed by Simon Huggins to cause dynamic libburn linking
+cdrskin_cdrskin_LDADD = libburn/libburn.la $(LIBBURN_EXTRALIBS)
+
 cdrskin_cdrskin_SOURCES = cdrskin/cdrskin.c cdrskin/cdrfifo.c cdrskin/cdrfifo.h cdrskin/cdrskin_timestamp.h
 ##
 ## Open questions: how to compute $timestamp and express -DX="$timestamp"
@@ -130,7 +151,10 @@ doc/html: doc/doxygen.conf
 doc-upload: doc/html
 	scp -r $</* $(webhost):$(webpath)
 
-all: doc
+## ts B00729
+## Not by default any more.
+## It is unclear who is supposed to create file ./doc/doc.lock
+# all: doc
 
 install-data-local: 
 	if [ -f ./doc/doc.lock ]; then \
@@ -173,6 +197,8 @@ EXTRA_DIST = \
 	version.h.in \
 	doc/comments \
 	doc/doxygen.conf.in \
+	doc/cookbook.txt \
+	doc/mediainfo.txt \
 	README \
 	AUTHORS \
 	CONTRIBUTORS \
@@ -186,10 +212,17 @@ EXTRA_DIST = \
 	cdrskin/wiki_plain.txt \
 	cdrskin/cleanup.h \
 	cdrskin/cleanup.c \
+	libburn/libburn.ver \
+	libburn/os-dummy.h \
 	libburn/os-freebsd.h \
 	libburn/os-linux.h \
+	libburn/os-libcdio.h \
+	libburn/os-solaris.h \
+	libburn/sg-dummy.c \
 	libburn/sg-freebsd.c \
 	libburn/sg-linux.c \
+	libburn/sg-libcdio.c \
+	libburn/sg-solaris.c \
 	COPYING \
 	NEWS \
 	ChangeLog \

README

@@ -1,95 +1,182 @@
 ------------------------------------------------------------------------------
-                              libburnia.pykix.org
+                              libburnia-project.org
 ------------------------------------------------------------------------------
 This all is under GPL.
 (See GPL reference, our clarification and commitment at the end of this text)
 ------------------------------------------------------------------------------
-libburnia.pykix.org
+libburn-project.org
 By Mario Danic <mario.danic@gmail.com> and Thomas Schmitt <scdbackup@gmx.net>
-Copyright (C) 2006-2007 Mario Danic, Thomas Schmitt
-
-Still containing parts of
-Libburn. By Derek Foreman <derek@signalmarketing.com> and
-            Ben Jansens <xor@orodu.net>
+Copyright (C) 2006-2011 Mario Danic, Thomas Schmitt
+Still containing parts of Libburn. By Derek Foreman <derek@signalmarketing.com>
+and Ben Jansens <xor@orodu.net>
 Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
-These parts are to be replaced by own code of above libburnia.pykix.org
-copyright holders and then libburnia.pykix.org is to be their sole copyright.
-This is done to achieve the right to issue the clarification and the
-commitment as written at the end of this text.
-The rights and merits of the Libburn-copyright holders Derek Foreman and
-Ben Jansens will be duely respected. 
 
-This libburnia.pykix.org toplevel README (C) 2006-2007 Thomas Schmitt 
+     http://files.libburnia-project.org/releases/libburn-1.1.8.tar.gz
+
 ------------------------------------------------------------------------------
 
                            Build and Installation
 
-Our build system is based on autotools. For preparing the build of a SVN 
-snapshot you will need autotools of at least version 1.7. 
-Check out from SVN by
-   svn co http://libburnia-svn.pykix.org/libburn/trunk libburn_pykix
-go into directory libburn_pykix and apply autotools by
-   ./bootstrap
+                                From tarball
 
-Alternatively you may unpack a release tarball for which you do not need
-autotools installed.
+Obtain libburn-1.1.8.tar.gz, take it to a directory of your choice and do:
 
-To build a libburnia.pykix.org subproject it should be sufficient to go
-into its toplevel directory (here: "libburn_pykix") and execute
-   ./configure
+   tar xzf libburn-1.1.8.tar.gz
+   cd libburn-1.1.8
+   ./configure --prefix=/usr
    make
 
-To make the libraries accessible for running resp. developing applications 
+To make libburn accessible for running resp. application development,
+and to install the cdrecord compatibility binary cdrskin, do
+(as Superuser):
+
+   make install
+
+This procedure installs libburn.so.4 and cdrskin depending on it.
+For a standalone cdrskin binary, see cdrskin/README.
+
+A behavioral conflict is known between any burn software and demons like hald
+which probe CD drives. This can spoil burn runs for CD-R or CD-RW.
+You may have to keep your hald away from the drive. See for example
+   http://www.freebsd.org/gnome/docs/halfaq.html
+
+
+                                  From SVN
+
+Our build system is based on autotools. For preparing the build of a SVN 
+snapshot you will need autotools of at least version 1.7. 
+Do in a directory of your choice:
+
+   svn co http://svn.libburnia-project.org/libburn/trunk libburn-svn
+   cd libburn-svn
+   ./bootstrap
+   ./configure --prefix=/usr
+   make
+   make install
+
+Warning: The trunk might contain experimental features which might not
+         persist until next release. 
+
+
+                        Special ./configure options
+
+make install on GNU/Linux 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
+
+In some situations Linux may deliver a better write performance to drives if
+the track input is read with O_DIRECT (see man 2 open). The API call
+burn_os_open_track_src() and the input readers of cdrskin and libburn fifo
+can be told to use this peculiar read mode by:
+   --enable-track-src-odirect
+
+But often libburn call burn_write_opts_set_dvd_obs(opts, 64*1024) will yield
+even better performance in such a situation. 64k can be made default at
+configure time by:
+    --enable-dvd-obs-64k
+This may be combined with above --enable-track-src-odirect .
+
+Alternatively the transport of SCSI commands can be done via libcdio-0.83.
+You may install it and re-run libburn's ./configure with option
+    --enable-libcdio
+
+By use of a version script, the libburn.so library exposes no other function
+names but those of the API definition in libburn/libburn.h.
+If -Wl,--version-script=... makes problems with the local compiler, then
+disable this encapsulation feature by
+    --disable-versioned-libs
+
+Make sure to re-compile all source files after running ./configure
+   make clean ; make
    make install
 
 
-The other half of the project, libisofs, is hosted in the libburnia SVN, too:
-   svn co http://libburnia-svn.pykix.org/libisofs/trunk libisofs_pykix
-See README file there.
+Linux only:
 
+libburn tries to avoid a collision with udev's drive examination by waiting
+0.1 seconds before opening the device file for a longer time, after udev
+might have been alarmed by drive scanning activities.
+The waiting time can be set at ./configure time with microsecond granularity.
+E.g. 2 seconds:
+  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=2000000"
+  ./configure ...options...
+Waiting can be disabled by zero waiting time:
+  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=0"
+Alternatively, libburn can try to be nice by opening the device file,
+closing it immediately, waiting, and only then opening it for real:
+  CFLAGS="$CFLAGS -DLibburn_udev_extra_open_cyclE -DLibburn_udev_wait_useC=500000"
+
+------------------------------------------------------------------------------
+
+An important part of the project, libisofs, is hosted in a bzr repository at
+launchpad.net :
+   bzr branch lp:libisofs
+
+Another part the project, libisoburn, is hosted in the libburnia SVN, too:
+   svn co http://svn.libburnia-project.org/libisoburn/trunk libisoburn
+
+See README files there.
 
 ------------------------------------------------------------------------------
 
 
-                        Overview of libburnia.pykix.org 
+                        Overview of libburnia-project.org
 
-libburnia.pykix.org is an open-source software project for reading, mastering
+libburnia-project.org is an open-source software project for reading, mastering
 and writing optical discs.
-For now this means only CD media and all single layer DVD media except DVD+R.
+For now this means CD media, all DVD media, all BD media.
 
 The project comprises of several more or less interdependent parts which
 together strive to be a usable foundation for application development.
 These are libraries, language bindings, and middleware binaries which emulate
 classical (and valuable) Linux tools.
+Currently it is supported on GNU/Linux with kernels >= 2.4,
+on FreeBSD with ATAPI/CAM enabled in the kernel (see man atapicam),
+and on OpenSolaris (tested with kernel 5.11).
+On other X/Open compliant systems there will only be pseudo drives, but no
+direct MMC operation on real CD/DVD/BD drives.
 
-Our scope is currently Linux 2.4 and 2.6 only. For ports to other systems
-we would need : login on a development machine resp. a live OS on CD or DVD,
-advise from a system person about the equivalent of Linux sg or FreeBSD CAM,
-volunteers for testing of realistic use cases.
+For full ports to other systems we would need : login on a development machine
+resp. a live OS on CD or DVD, advise from a system person about the equivalent
+of Linux sg or FreeBSD CAM, volunteers for testing of realistic use cases.
 
-We have a workable code base for burning CD and most single layer DVD.
+We have a well tested code base for burning data and audio CDs, DVDs and BDs.
 The burn API is quite comprehensively documented and can be used to build a
 presentable application.
-We have a functional binary which emulates parts of cdrecord in order to
-prove that usability, and in order to allow you to explore libburnia's scope
-by help of existing cdrecord frontends.
+We have a functional application which emulates the core use cases of cdrecord
+in order to prove that usability, and in order to allow you to explore
+libburn's scope by help of existing cdrecord frontends.
+
+ISO 9660 filesystems with Rock Ridge and Joliet extensions can be created
+and manipulated quite freely. This capability together with our burn capability
+makes possible a single binary application which covers all steps of image
+composition, updating and writing. Quite unique in the Linux world.
 
 The project components (list subject to growth, hopefully):
 
 - libburn  is the library by which preformatted data get onto optical media.
            It uses either /dev/sgN (e.g. on kernel 2.4 with ide-scsi) or
-           /dev/hdX (e.g. on kernel 2.6).
+           /dev/srM or /dev/hdX (e.g. on kernel 2.6).
            libburn is the foundation of our cdrecord emulation. Its code is
            independent of cdrecord. Its DVD capabilities are learned from
            studying the code of dvd+rw-tools and MMC-5 specs. No code but only
            the pure SCSI knowledge has been taken from dvd+rw-tools, though.
 
 - libisofs is the library to pack up hard disk files and directories into a
-           ISO 9660 disk image. This may then be brought to media via libburn.
-           libisofs is to be the foundation of our upcoming mkisofs emulation.
+           ISO 9660 disk image. This may then be brought to CD via libburn.
+           An own ISO 9660 extension stores ACLs, xattr, and MD5 of file
+           content.
+
+- libisoburn is an add-on to libburn and libisofs which coordinates both and
+           also allows to grow ISO-9660 filesystem images on multi-session
+           media as well as on overwriteable media via the same API.
+           All media peculiarities are handled automatically.
+           It also contains the methods of command oriented application
+           xorriso and offers them via a C language API.
 
 - cdrskin  is a limited cdrecord compatibility wrapper for libburn.
-           Cdrecord is a powerful GPL'ed burn program included in Joerg
+           cdrecord is a powerful GPL'ed burn program included in Joerg
            Schilling's cdrtools. cdrskin strives to be a second source for
            the services traditionally provided by cdrecord. Additionally it
            provides libburn's DVD capabilities, where only -sao is compatible
@@ -97,14 +184,46 @@ The project components (list subject to growth, hopefully):
            cdrskin does not contain any bytes copied from cdrecord's sources.
            Many bytes have been copied from the message output of cdrecord
            runs, though.
-           See cdrskin/README and man cdrskin/cdrskin.1 for more.
+           See cdrskin/README for more.
 
-- test     is a collection of application gestures and examples given by the
-           authors of the library features. The main API example for libburn
-           is test/libburner.c .
+- xorriso  is an application of all three libraries which creates, loads,
+           manipulates and writes ISO 9660 filesystem images with
+           Rock Ridge extensions. Manipulation is not only adding or
+           overwriting of files but also deleting, renaming, attribute
+           changing, incremental backups, activating boot images, and
+           extracting of files from ISO images to disk. There is also a
+           sparse emulation of cdrecord and a more laborate one of mkisofs.
+           All features of xorriso are also available via a C language API
+           of libisoburn.
+           A static compilation of xorriso and the libraries is dedicated
+           to the GNU Operating System. See xorriso/README_gnu_xorriso .
+
+- "test"   is a collection of application gestures and examples given by the
+           authors of the library features. The burn API example of libburn
+           is named test/libburner.c . The API for media information inquiry is
+           demonstrated in test/telltoc.c .
            Explore these examples if you look for inspiration.
 
-We plan to be a responsive upstream. Bear with us. We are still practicing.
+We strive to be a responsive upstream.
+
+Our libraries are committed to maintain older feature sets in newer versions.
+This applies to source code headers (API) as well as to linkable objects (ABI).
+The only exception from this rule is about non-release versions x.y.*[13579]
+which are allowed to introduce new features, change those new features in
+any way and even may revoke such new features before the next release of
+x.y.*[02468]. As soon as it is released, a feature is promised to persist.
+
+SONAMES:
+libburn.so.4    (since 0.3.4, March    2007),
+libisofs.so.6   (since 0.6.2, February 2008),
+libisoburn.so.1 (since 0.1.0, February 2008).
+
+Applications must use 64 bit off_t. E.g. by defining
+#define _LARGEFILE_SOURCE
+#define _FILE_OFFSET_BITS 64
+or take special precautions to interface with the libraries by 64 bit integers
+where the .h files prescribe off_t. To reduce libburn's off_t size to 32 bit
+will keep it from processing tracks of more than 2 GB size.
 
 
 ------------------------------------------------------------------------------
@@ -127,13 +246,13 @@ Project history as far as known to me:
   It has meanwhile moved to use vanilla libburn.pykix.org , though.
   Version 0.1.4 constitutes the first release of this kind.
 
-- In Juli 2006 our team mate Mario Danic announced a revival of libburn
+- In July 2006 our team mate Mario Danic announced a revival of libburn
   which by about nearly everybody else was perceived as unfriendly fork.
   Derek Foreman four days later posted a message which expressed his
   discontent.
   The situation first caused me to publically regret it and then - after i
   got the opportunity to move in with cdrskin - gave me true reason to
-  personally apologize to Derek Foreman, Ben Jansens and the contibutors at 
+  personally apologize to Derek Foreman, Ben Jansens and the contributors at 
   icculus.org/burn. Posted to both projects:
     http://lists.freedesktop.org/archives/libburn/2006-August/000446.html
     http://mailman-mail1.webfaction.com/pipermail/libburn-hackers/2006-August/000024.html
@@ -197,12 +316,362 @@ Project history as far as known to me:
   DVD media. Code for double layer DVD+/-R is implemented but awaits a tester
   yet.
 
+- 23th April 2007 version 0.3.6 follows the unanimous opinion of Linux kernel
+  people that one should not use /dev/sg on kernel 2.6.
+
+- 31st July 2007 version 0.3.8 marks the first anniversary of libburn revival.
+  We look back on improved stability, a substantially extended list of media
+  and write modes, and better protection against typical user mishaps.
+
+- 24th October 2007 version 0.4.0 is the foundation of new library libisoburn
+  and an upcomming integrated application for manipulating and writing
+  ISO 9660 + Rock Ridge images. cdrskin-0.4.0 got capabilities like growisofs
+  by these enhancements: growing of overwriteable media and disk files.
+  Taking again a bow towards Andy Polyakov.
+
+- 26th Januar 2008 version 0.4.2 rectifies the version numbering so that we
+  reliably release libburn.so.4 as should have been done since libburn-0.3.2.
+  cdrskin now is by default linked dynamically and does a runtime check
+  to ensure not to be started with a libburn which is older than itself.
+
+- 3rd Feb 2008 libisofs-0.2.x (.so.5) has been deprecated.
+
+- 14th Feb 2008 libisofs-0.6.2 permanently replaces the old libisofs-0.2.x. 
+  It is the first release of new libisofs.so.6 which will guarantee future
+  API/ABI compatibility for its whole feature set.
+
+- 15th Feb 2008 libisoburn-0.1.0 (.so.1) coordinates libisofs and libburn for
+  the purpose of ISO image reading and writing. It emulates multi-session on
+  overwriteable media. Application xorriso makes use of all three libraries.
+
+- 8th Apr 2008 libburn-0.4.4 has proven to be capable of burning to DVD+R/DL
+  and read performance on disk file pseudo-drives has been improved.
+
+- 27th Apr 2008 libisofs-0.6.4 can now read data file content from images
+  and can map pieces of disk files onto image files. Image directory iteration
+  has been enhanced. Input data streams and extended information have been
+  exposed in the API to allow future development.
+
+- 29th Apr 2008 libisoburn-0.1.4 was made more efficient with reading of
+  image tree nodes. It now depends on libisofs-0.6.4 and libburn-0.4.4.
+  xorriso makes use of new libisofs features by performing incremental
+  updates of directory trees and by cutting oversized data files into
+  pieces. A primitive single session emulation of cdrecord and mkisofs is
+  provided.
+
+- 10th May 2008 libburn-0.4.6 supports formatting and writing of BD-RE,
+  full nominal speed for DVD-RAM and BD-RE. cdrskin has a unified blank
+  type with automatic media state recognition.
+
+- 17th May 2008 an old bug with DVD-RAM and now with BD-RE is fixed by
+  libburn-0.4.8 to allow libisoburn emulation of multisession on those media.
+
+- 19th May 2008 libisoburn-0.1.6 brings better table-of-content emulation
+  on overwriteble media and disk files.
+
+- 1st Jun 2008 libisofs-0.6.6 fixes some problems around device files.
+
+- 3rd Jun 2008 libisoburn-0.1.8 fixes a bug with overwriteable media.
+
+- 23rd Jun 2008 libisoburn-0.2.0 introduces extraction of files from
+  ISO images.
+
+- 16th Jul 2008 libburn-0.5.0 handles systems with no /dev/sr* but only
+  /dev/scd*.
+
+- 19th Jul 2008 libisoburn/xorriso-0.2.2 can do multi-session in mkisofs
+  and cdrecord style. xorriso now can serve underneath growisofs.
+
+- 20th Aug 2008 libburn-0.5.2 revokes the necessity that a drive must be
+  enumerable in order to be adressable. Enumeration is enhanced by examining
+  /proc/sys/dev/cdrom/info.
+  
+- 24th Aug 2008 libisoburn/xorriso-0.2.4 introduces a media readability check
+  with data retrieval option.
+
+- 18th Sep 2008 libisofs-0.6.8 supports ISO 9660 Level 3 which allows very
+  large data files in the image.
+
+- 20th Sep 2008 libisoburn/xorriso-0.2.6 takes into respect the new Level 3
+  capabilities of libisofs. 
+
+- 6th Oct 2008 libburn-0.5.4 adjusts the changes of 0.5.2 to the needs of
+  Linux kernel 2.4 and introduces human readable SCSI error messages.
+
+- 6th Oct 2008 libisofs-0.6.10 fixes two bugs which prevented adding and
+  manipulation of ISOLINUX boot images.
+
+- 15th Oct 2008 libisoburn/xorriso-0.2.8 can activate and maintain an
+  ISOLINUX boot image by an EL Torito boot record.
+
+- 12th Nov 2008 libburn-0.5.6 fixes usage of freed memory by the fifo thread
+  of an aborted burn run.
+
+- 26th Nov 2008 libisofs-0.6.12 can produce a ISOLINUX isohybrid MBR on the fly
+  and allows to produce ISO images which resemble old mkisofs images.
+
+- 2nd Dec 2008 libisoburn-0.3.0. xorriso now is ready for exotic character
+  sets, for legacy FreeBSD systems which expect an outdated Rock Ridge
+  signature, and for producing ISO images with MBR which boot from hard disk
+  or USB stick. Three minor bugs were fixed.
+
+- 7th Dec 2008 libburn-0.5.8 prevents a SIGSEGV with wierd CD table-of-content
+  and improves BD-RE formatting.
+
+- 9th Dec 2008 Our project received a donation from Thomas Weber.
+
+- 2nd Jan 2009 libburn-0.6.0 allows to format BD-R and to write to either
+  formatted or unformatted BD-R.
+
+- 6th Jan 2009 libisoburn-0.3.2. xorriso can produce and execute commands for
+  mounting older sessions from all kinds of media. Pseudo-drives outside the
+  /dev/ tree can be addressed without prefix "stdio:". 
+
+- 20th Feb 2009 libburn-0.6.2 source release now compiles out of the box
+  on FreeBSD.
+
+- 28 Feb 2009 libisofs-0.6.14 can record ACLs and Extended Attributes xattr
+  in its ISO images. 
+
+- 01 Mar 2009 libisoburn-0.3.4. xorriso makes use of the ACL and xattr
+  capabilities provided by libisofs for xorriso backup features.
+
+- 11 Mar 2009 libisofs-0.6.16 of libisofs fixes two bugs which on Solaris
+  prevented to navigate the ISO images by ".." and to recognize the Rock Ridge
+  extensions of ISO images. The ban to build libisofs on operating systems
+  other than Linux and FreeBSD has been lifted.
+
+- 13 Mar 2009 libburn-0.6.4 got a dummy adapter for SCSI/MMC command transport.
+  It will show no drives and thus libburn will only be able to perform
+  operations on "stdio:" pseudo drives. Nevertheless this allowed to lift the
+  ban to build libburn on operating systems other than Linux and FreeBSD.
+
+- 16 Mar 2009 libisoburn-0.3.6: xorriso uses RRIP version 1.10 as default 
+  in order to be mountable where mkisofs images are mountable.
+
+- 17 Apr 2009 libisofs-0.6.18 introduces content filtering of data files.
+  Built-in filters allow compression to formats gzip and zisofs. External
+  filter processes allow arbitrary data conversions like encryption.
+
+- 19 Apr 2009 libisoburn-0.3.8 makes use of the new libisofs capability to
+  perform content filtering of data files.
+
+- 08 May 2009 libburn-0.6.6 fixes a bug with aborting on broken output pipe
+  and a bug with device scan on FreeBSD.
+
+- 31 May 2009 libisofs-0.6.20 can record hard link relations in ISO images
+  and offers support with restoring them to disk. Current Linux kernels will
+  mount images with such hard links but will attribute a unique inode number
+  to each file.
+
+- 28 Jun 2009 libisoburn-0.4.0: xorriso can record and restore hard link
+  relations of files. Performance of data reading has been improved. Option
+  -find now supports logical operators with its tests.
+
+- 14 Jul 2009 libburn-0.6.8 fixes bugs and shortcommings with old MMC-1 drives
+  and with large SCSI bus numbers as handed out by Linux for USB drives.
+
+- 20 Jul 2009 libisoburn-0.4.0.pl01 fixes a regression in xorriso which caused
+  data loss in older sessions if xorriso was used underneath growisofs.
+  Affected are releases since libisoburn-0.3.2 in january 2009.
+
+- 25 Aug 2009 libisofs-0.6.22 can record MD5 checksums for the whole session
+  and for each single data file. Checksum tags allow to verify superblock and
+  directory tree before importing them.
+
+- 27 Aug 2009 libburn-0.7.0 allows to calm down a drive and to inquire its
+  supported profiles. It works around some pitfalls with U3 enhanced memory
+  sticks which emulate a CD-ROM.
+
+- 27 Aug 2009 libisoburn-0.4.0.pl00 can record MD5 checksums by which one may
+  verify the session or single data files in the image. When comparing image
+  files with files in the local filesystem, the MD5 sums avoid the need for
+  reading file content from the image.
+
+- 22 Sep 2009 libisoburn-0.4.0.pl01 fixes a bug in xorriso option -cut_out.
+
+- 08 Oct 2009 libisofs-0.6.24 fixes a bug which could cause the loss of blanks
+  in file names when a new session got added to an ISO image. With names
+  shorter than 251 characters this happened only to trailing blanks.
+
+- 08 Oct 2009 libisoburn-0.4.0.pl02 fixes bugs with xorriso option -for_backup,
+  with xorrisofs -help, and with xorrecord -help.
+
+- 12 Oct 2009 libburn-0.7.2 fixes a bug with CD TAO multi-track dummy sessions.
+  It can retrieve media product info and can process track input which was
+  prepared for CD-ROM XA Mode 2 Form 1. cdrskin now performs option -minfo.
+
+- 28 Oct 2009 libisoburn-0.4.4 fixes a bug with cdrecord emulation and
+  introduces new information options about media type and ISO image id strings.
+  On Linux it helps with mounting two sessions of the same media
+  simultaneously.
+
+- 12 Nov 2009 libburn-0.7.2.pl01 works around problems with Pioneer DVR-216D.
+  DVD-R runs made the drive stuck. Ejecting the tray did not work properly.
+
+- 06 Dec 2009 libburn-0.7.4 works around problems with newer DVD burners,
+  provides throughput enhancements with hampered busses on Linux, and new
+  API calls to log SCSI commands and to control the libburn fifo.
+
+- 09 Dec 2009 libisoburn-0.4.6 allows performance tuning of output to DVD
+  drives or disk files.
+
+- 26 Dec 2009 libburn-0.7.4.pl01 fixes the release tarball which was lacking
+  the files of the generic system adapter for X/Open.
+
+- 29 Dec 2009 Our project received a donation for purchasing a fine small
+  computer which shall serve as OS farm for development and support.
+
+- 20 Jan 2010 Version 0.6.26 of libisofs fixes minor bugs and shall enhance
+  portability.
+
+- 22 Jan 2010 libburn-0.7.6 has an improved system adapter for FreeBSD,
+  fixes bugs about the generic X/Open system adapter, and allows to use
+  libcdio >= 0.83 as SCSI transport facility.
+
+- 10 Feb 2010 libisofs-0.6.28 fixes a regression about bootable images which
+  was introduced by version 0.6.22 in August 2009.
+
+- 23 Feb 2010 libisoburn-0.5.0 marks the transition of the xorriso standalone
+  version to an official GNU project. The name changed to "GNU xorriso" and its
+  license is now GPLv3+.
+  The licenses of libburnia libraries and applications are not affected by
+  this change. 
+
+- 10 Mar 2010 libburn-0.7.8 fixes bugs and improves the built-in abort handler
+  on FreeBSD.
+
+- 30 Mar 2010 Release 0.5.2 of libisoburn provides xorriso documentation in
+  GNU Texinfo format with embedded extra data to derive a full man page.
+
+- 09 Apr 2010 libburn-0.8.0 now works with ahci driver on FreeBSD 8-STABLE.
+
+- 03 May 2010 Version 0.6.32 of libisofs is able to create ISO images with
+  multiple boot images. All boot catalog parameters described in El-Torito
+  specs can be set and inquired. This allows to use GRUB boot images for EFI. 
+
+- 04 May 2010 Release 0.5.6.pl00 of libisoburn makes use of the new libisofs
+  capabilities about boot images.
+
+- 11 Jun 2010 libburn-0.8.2 now works on Solaris. 
+
+- 14 Jun 2010 By release 0.5.8.pl00 of libisoburn, xorriso becomes a public C
+  language API of libisoburn. The emulations of mkisofs and cdrecord have
+  been enhanced. 
+
+- Tue Jun 29 2010 Version 0.6.34 of libisofs provides new features about
+  hiding file names from directory trees.
+
+- Wed Jun 30 2010 libburn-0.8.4 removes some restrictions on operating
+  systems other than Linux and FreeBSD.
+
+- Fri Jul 02 2010 Release 0.6.0.pl00 of libisoburn adds more options to the
+  mkisofs emulation of xorriso. It also fixes minor bugs and shortcommings.
+
+- Wed Sep 15 2010 Version 0.6.36 of libisofs can produce ISO images which
+  bear a partiton 1 with non-zero start address. They can be mounted from
+  USB stick via the main device file (e.g. /dev/sdb) as well as via the
+  partition device file (e.g. /dev/sdb1).
+
+- Fri Sep 17 2010 libburn-0.8.6 lifts the test reservation on DVD-R DL media.
+
+- Sat Sep 18 2010 Release 0.6.2.pl00 of libisoburn introduces a partition
+  with non-zero offset for ISO 9660 images on USB sticks, improves mkisofs
+  emulation, and fixes a regression which existed since version 0.4.2.
+
+- Wed Oct 20 2010 libburn-0.8.8 can report the used amount of BD spare blocks.
+
+- Sat Oct 23 2010 Version 0.6.38 of libisofs can use libjte to produce jigdo
+  files along with the ISO image. Further filesystem images may be appended
+  as MBR partitions 1 to 4. The capability was added to produce boot blocks
+  for computers with MIPS CPU.
+
+- Tue Oct 26 2010 Release 0.6.4.pl00 of libisoburn and xorriso makes use of
+  the new libisofs capabilities.
+
+- Wed Dec 08 2010 libburn-0.9.0 fixes a regression with SCSI command logging.
+
+- Fri Dec 10 2010 Version 0.6.40 of libisofs makes the prediction of the
+  emerging image size less expensive and is able to make images bootable
+  for SUN SPARC systems.
+
+- Sun Dec 12 2010 Release 0.6.6.pl00 of libisoburn and xorriso can read ISO
+  images which were copied to a different start address than they were prepared
+  for.
+
+- Mon Jan 17 2011 we go for release 1.0.0. This does not indicate a
+  technological overhaul but shall emphasize the maturity of the software.
+  libisofs-1.0.0 fixes a bug about the length of ECMA-119 directory names and
+  is ready to allow untranslated ECMA-119 names (violating the specs).
+  libburn-1.0.0.pl00 allows umask to create stdio-drive files with
+  rw-permissions for all. cdrskin now refuses to burn if the foreseeable size
+  exceeds media capacity
+  libisoburn-1.0.0.pl00 allows to create an ISO 9660:1999 directory tree,
+  improved the emulation fidelity of command -as mkisofs, lowered the default
+  abort threshold for xorriso batch mode, and increased that threshold for
+  xorriso dialog mode.
+
+- Wed Feb 23 2011 release 1.0.2:
+  libisofs fixes several bugs and introduces the capability to copy files
+  inside the ISO filesystem.
+  libburn removed a compilation obstacle on Solaris 9 and improved recognition
+  of stdio pseudo-drives.
+  libisoburn and xorriso fix bugs and make use of the new libisofs capability.
+  xorriso improves its mkisofs emulation.
+
+- Thu Mar 10 2011 release 1.0.4:
+  Several bugs were fixed in the libraries and in the mkisofs emulation of
+  xorriso. This emulation xorrisofs has now an own man page and info document.
+
+- Sat Apr 09 2011 release 1.0.6:
+  libburn refined its representation of emulated drives. The size alignment
+  of DVD DAO is now 2 kB rather than 32 kB. libisofs produces Joliet names of
+  up to 103 characters. xorriso fixes two bugs and makes use of the library
+  improvements.
+
+- Thu Apr 14 2011 release libisoburn-1.0.8:
+  A bug in the mkisofs emulation of xorriso could cause options to be ignored.
+  The problem was freshly introduced with libisoburn-1.0.6. 
+
+- Fri May 13 2011 release libisofs-1.0.8:
+  Fixes a few rarely occurring bugs that have been found during the last month.
+
+- Sat Jun 18 2011 release 1.1.0:
+  The consumption of stack memory was reduced. Statical program analysis found
+  some rarely occuring memory leaks. Several small bugs were fixed.
+  The suffix .plXY was dropped from tarball names of libburn and libisoburn.
+
+- Mon Jun 20 2011 patch release libburn-1.1.0.pl01:
+  libburn-1.1.0 compiled only on Linux, FreeBSD, and Solaris, but not on
+  other X/Open compliant systems.
+
+- Fri Jul 08 2011 release libisofs-1.1.2 and libisoburn-1.1.2:
+  A severe regression was fixed in libisoburn and xorriso, which was introduced
+  with version 1.0.6. It caused ISO 9660 images to be unreadable if they were
+  written to a write-only random-access file. E.g. by: xorrisofs ... >image.iso
+  
+- Mon Aug 08 2011 release 1.1.4:
+  Several bugs were fixed in libburn. The most severe of them prevented xorriso
+  on some drives from burning mountable ISO 9660 images to CD media.
+  New means to list drives by their udev symbolic links help to deal with
+  the non-persistent drive addresses on modern GNU/Linux.
+
+- Tue Sep 27 2011 release 1.1.6:
+  libisoburn now comes with a test suite. See releng/README. Bugs were fixed
+  in several rarely used features. Processing of ACL and extattr was enabled
+  on FreeBSD. Workarounds try to cope with vanishing udev links on GNU/Linux.
+
+- Mon Nov 21 2011 release libburn-1.1.8 and libisoburn-1.1.8:
+  libburn avoids to close and open drive device files while operating on them.
+  xorriso emulation mode xorrecord now has an own manual. libburn and xorriso
+  were prepared to operate on qemu virtio-blk-pci devices.
+
 
 ------------------------------------------------------------------------------
 
     This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation. To be exact: version 2 of that License.
+    it under the terms of the GNU General Public License version 2 or later
+    as published by the Free Software Foundation.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -220,16 +689,16 @@ other copyrighted code has been replaced by ours and by copyright-free
 contributions of our friends:
 ------------------------------------------------------------------------------
 
-We, the copyright holders, agree on the interpretation that
-dynamical linking of our libraries constitutes "use of" and
-not "derivation from" our work in the sense of GPL, provided
-those libraries are compiled from our unaltered code.
+We, the copyright holders, agree on the interpretation that dynamical linking
+of our libraries constitutes "use of" and not "derivation from" our work in
+the sense of GPL, provided those libraries are compiled from our unaltered
+code or from altered code published under GPL.
 
-Thus you may link our libraries dynamically with applications
-which are not under GPL. You may distribute our libraries and
-application tools in binary form, if you fulfill the usual
-condition of GPL to offer a copy of the source code -altered
-or unaltered- under GPL.
+So we will not raise legal protest if you link our libraries dynamically with
+applications which are not under GPL, or if you distribute our libraries
+and application tools in binary form, as long as you fulfill the usual
+condition of GPL to offer a copy of their source code -altered or unaltered-
+under GPL.
 
 We ask you politely to use our work in open source spirit
 and with the due reference to the entire open source community.
@@ -246,4 +715,5 @@ means to qualify for GPL.
 For now we are firmly committed to maintain one single license: GPL.
 
 signed: Mario Danic, Thomas Schmitt
+Agreement joined later by: Vreixo Formoso
 

acinclude.m4

@@ -1,22 +1,111 @@
+AC_DEFUN([LIBBURNIA_SET_FLAGS],
+[
+case $target_os in
+freebsd*)
+        LDFLAGS="$LDFLAGS -L/usr/local/lib"
+        CPPFLAGS="$CPPFLAGS -I/usr/local/include"
+        ;;
+esac
+])
+
+
 AC_DEFUN([TARGET_SHIZZLE],
 [
   ARCH=""
+  LIBBURNIA_PKGCONFDIR="$libdir"/pkgconfig
 
   AC_MSG_CHECKING([target operating system])
 
-  case $target in
-    *-*-linux*)
+  LIBBURNIA_LDCONFIG_CMD="echo 'No ldconfig run performed. If needed, configure manually for:'"
+  
+  case $target_os in
+    linux*)
       ARCH=linux
       LIBBURN_ARCH_LIBS=
+      LIBBURNIA_LDCONFIG_CMD=ldconfig
       ;;
-    *-*-freebsd*)
+    freebsd*)
+      ARCH=freebsd
+      LIBBURN_ARCH_LIBS=-lcam
+      LIBBURNIA_PKGCONFDIR=$(echo "$libdir" | sed 's/\/lib$/\/libdata/')/pkgconfig
+      ;;
+    kfreebsd*-gnu)
       ARCH=freebsd
       LIBBURN_ARCH_LIBS=-lcam
       ;;
     *)
-      AC_ERROR([You are attempting to compile for an unsupported platform])
+      ARCH=
+      LIBBURN_ARCH_LIBS=
+#      AC_ERROR([You are attempting to compile for an unsupported platform])
       ;;
   esac
 
   AC_MSG_RESULT([$ARCH])
 ])
+
+
+dnl LIBBURN_ASSERT_VERS_LIBS is by Thomas Schmitt, libburnia project
+dnl It tests whether -Wl,--version-script=... works with the compiler
+AC_DEFUN([LIBBURN_ASSERT_VERS_LIBS],
+[
+    libburnia_save_LDFLAGS="$LDFLAGS"
+    LDFLAGS="$LDFLAGS -Wl,--version-script=libburn/libburn.ver"
+    AC_TRY_LINK([#include <stdio.h>], [printf("Hello\n");],
+                [vers_libs_test="yes"], [vers_libs_test="no"])
+    if test x$vers_libs_test = xno
+    then
+        LDFLAGS="$libburnia_save_LDFLAGS"
+    fi
+])
+  
+
+dnl LIBBURNIA_SET_PKGCONFIG determines the install directory for the *.pc file.
+dnl Important: Must be performed _after_ TARGET_SHIZZLE
+dnl 
+AC_DEFUN([LIBBURNIA_SET_PKGCONFIG],
+[
+### for testing --enable-libdir-pkgconfig on Linux
+### LIBBURNIA_PKGCONFDIR="$libdir"data/pkgconfig
+
+if test "x$LIBBURNIA_PKGCONFDIR" = "x$libdir"/pkgconfig
+then
+  dummy=dummy
+else
+  AC_ARG_ENABLE(libdir-pkgconfig,
+  [  --enable-libdir-pkgconfig  Install to $libdir/pkgconfig on any OS, default=no],
+   , enable_libdir_pkgconfig="no")
+  AC_MSG_CHECKING([for --enable-libdir-pkgconfig])
+  if test "x$enable_libdir_pkgconfig" = xyes
+  then
+    LIBBURNIA_PKGCONFDIR="$libdir"/pkgconfig
+  fi
+  AC_MSG_RESULT([$enable_libdir_pkgconfig])
+fi
+
+libburnia_pkgconfig_override="no"
+AC_ARG_ENABLE(pkgconfig-path,
+[  --enable-pkgconfig-path=DIR  Absolute path of directory for libisofs-*.pc],
+libburnia_pkgconfig_override="yes" , enable_pkgconfig_path="none")
+AC_MSG_CHECKING([for overridden pkgconfig directory path])
+if test "x$enable_pkgconfig_path" = xno
+then
+  libburnia_pkgconfig_override="no"
+fi
+if test "x$enable_pkgconfig_path" = x -o "x$enable_pkgconfig_path" = xyes
+then
+  libburnia_pkgconfig_override="invalid argument"
+fi
+if test "x$libburnia_pkgconfig_override" = xyes
+then
+  LIBBURNIA_PKGCONFDIR="$enable_pkgconfig_path"
+  AC_MSG_RESULT([$LIBBURNIA_PKGCONFDIR])
+else
+  AC_MSG_RESULT([$libburnia_pkgconfig_override])
+fi
+AC_SUBST(LIBBURNIA_PKGCONFDIR)
+
+dnl For debugging only
+### AC_MSG_RESULT([LIBBURNIA_PKGCONFDIR = $LIBBURNIA_PKGCONFDIR])
+
+])
+

bootstrap

@@ -1,6 +1,6 @@
 #!/bin/sh -x
 
-aclocal
+aclocal -I .
 libtoolize --copy --force
 autoconf
 

cdrskin/README

@@ -1,86 +1,43 @@
 ------------------------------------------------------------------------------
-        libburnia.pykix.org    scdbackup.sourceforge.net/cdrskin_eng.html
+     libburnia-project.org     scdbackup.sourceforge.net/cdrskin_eng.html
 ------------------------------------------------------------------------------
-Installation instructions at about line 60. First the legal stuff:
-------------------------------------------------------------------------------
-This all is under GPL.
-(See GPL reference, our clarification and commitment at the end of this text)
-------------------------------------------------------------------------------
-Based on and sub project of:
-libburnia.pykix.org
-By Mario Danic <mario.danic@gmail.com> and Thomas Schmitt <scdbackup@gmx.net>
-Copyright (C) 2006-2007 Mario Danic, Thomas Schmitt
-
-libburnia.pykix.org is inspired by and in other components still containing
-parts of
-Libburn. By Derek Foreman <derek@signalmarketing.com> and
-            Ben Jansens <xor@orodu.net>
-Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
-See toplevel README for an overview of the current copyright situation in
-libburnia.pykix.org.
-
-------------------------------------------------------------------------------
-My thanks to the above authors (except myself, of course) for making the
-following possible.
-
 cdrskin. By Thomas Schmitt <scdbackup@gmx.net>
-Integrated sub project of libburnia.pykix.org but also published via:
+Integrated sub project of libburnia-project.org but also published via:
 http://scdbackup.sourceforge.net/cdrskin_eng.html
-http://scdbackup.sourceforge.net/cdrskin-0.3.5.tar.gz
-Copyright (C) 2006-2007 Thomas Schmitt
+http://scdbackup.sourceforge.net/cdrskin-1.1.8.tar.gz
 
+Copyright (C) 2006-2011 Thomas Schmitt, provided under GPL version 2 or later.
 ------------------------------------------------------------------------------
 
-On top of libburn there is implemented cdrskin 0.3.5, a limited cdrecord
-compatibility wrapper which allows to use some libburn features from
-the command line.
-Interested users of cdrecord are invited to participate in the development
-of cdrskin. Contact: scdbackup@gmx.net or libburn-hackers@pykix.org .
-We will keep copyright narrow but will of course acknowledge valuable
-contributions in a due way.
 
+cdrskin is a limited cdrecord compatibility wrapper which allows to use
+most of the libburn features from the command line.
 
-Important :
-This software is provided as is. There is no warranty implied and no
-protection against possible damages. You use this on your own risk.
-Don't blame me or other authors of libburn if anything goes wrong.
+Currently it is supported on GNU/Linux with kernels >= 2.4,
+on FreeBSD and on OpenSolaris.
+IDE drives under Linux 2.4. need kernel module ide-scsi.
+ATA and SATA drives under FreeBSD need kernel module atapicam.
+On other X/Open compliant systems there will only be emulated drives, but no
+direct MMC operation on real CD/DVD/BD drives.
 
-I used it on my own risk with :
-SuSE 7.2, kernel 2.4.4,  ide-scsi emulation, LITE-ON LTR48125S CD burner, 2002
-SuSE 9.0, kernel 2.4.21, ide-scsi emulation, LG GSA-4082B CD/DVD burner, 2004
-                                             NEC ND-4570A CD/DVD burner, 2006
-RIP-14.4, kernel 2.6.14, no ide-scsi,        with all above burners
-
-It fails to compile or run on SuSE 6.4 (kernel 2.2.14).
-It does not find the IDE CD burner on SuSE 7.2 without ide-scsi.
-Other people sucessfully tested cdrskin on several kernel 2.6 based x86 Linux
-systems, including 64 bit systems. (Further reports are welcome.)
+By using this software you agree to the disclaimer at the end of this text
+"This software is provided as is. There is no warranty implied and ..."
 
 
                    Compilation, First Glimpse, Installation
 
-Obtain cdrskin-0.3.5.tar.gz, take it to a directory of your choice and do:
+Obtain cdrskin-1.1.8.tar.gz, take it to a directory of your choice and do:
 
-    tar xzf cdrskin-0.3.5.tar.gz
-    cd cdrskin-0.3.5
+    tar xzf cdrskin-1.1.8.tar.gz
+    cd cdrskin-1.1.8
 
-Or obtain a libburnia.pykix.org SVN snapshot,
-go into the toplevel directory of the snapshot (e.g.  cd libburn_pykix ),
-and execute the autotools script ./bootstrap . Use autools version >= 1.7 .
+Within that directory execute:
 
-Within that toplevel directory of either cdrskin-0.3.5 or libburn then execute:
-
-    ./configure
+    ./configure --prefix=/usr
     make
 
-(Note: there are next-level directories "libburn" and "cdrskin". Those
-would be the wrong ones. Meant is the highest directory of tarball resp. 
-SVN download. Among others containing files "AUTHORS", "configure", 
-"Makefile.am", as well as directories "libburn" and "cdrskin".)
-
-This will already produce a cdrskin binary. But it might be necessary to
-install libburn in order to use this binary. Installation of libburn is
-beyond the scope of cdrskin. For this, see included libburn docs.
+This will already produce a cdrskin binary. But it will be necessary to
+install libburn in order to use this binary.
 
 In order to surely get a standalone binary, execute
 
@@ -92,11 +49,21 @@ Version identification and help texts available afterwards:
     cdrskin/cdrskin -help
     man cdrskin/cdrskin.1
 
+
 Install (eventually as superuser) cdrskin to a directory where it can be found:
+The command for global installation of both, libburn and cdrskin is
+    make install
+If the library libburn.so.4 is not found with a test run of cdrskin, then
+try whether command
+    ldconfig
+makes it accessible. With the statically linked binary this should not matter.
+
+With that static binary you may as well do the few necessary actions manually.
 If cdrskin was already installed by a previous version, or by "make install"
 in the course of this installation, then find out where:
     which cdrskin 
-Copy your standalone binary to exactly the address which you get as reply 
+Copy your standalone binary to exactly the address which you get as reply.
+E.g.:
 
     cp cdrskin/cdrskin /usr/bin/cdrskin
 
@@ -107,12 +74,16 @@ It is not necessary for the standalone cdrskin binary to have libburn
 installed, since it incorporates the necessary libburn parts at compile time.
 It will not collide with an installed version of libburn either.
 But libpthread must be installed on the system and glibc has to match. (See
-below for a way to create a statically linked binary.)
+below for a way to create a totally static linked binary.)
 
 To install the man page, you may do: echo $MANPATH and choose one of the
 listed directories to copy the man-page under its ./man1 directory. Like:
     cp cdrskin/cdrskin.1 /usr/share/man/man1/cdrskin.1
 
+Note: The content of the cdrskin tarball is essentially the complete libburn
+      of the same version number. You may thus perform above steps in a local
+      SVN copy of libburn or in a unpacked libburn tarball as well.
+
 
                                     Usage
 
@@ -126,19 +97,39 @@ The superuser should be able to see any usable drive and then set the
 permissions as needed. If this hangs then there is a drive with
 unexpected problems (locked, busy, broken, whatever). You might have to
 guess the address of your (non-broken) burner by other means, then.
-On Linux 2.4 this would be some /dev/sgN and on 2.6. some /dev/hdX.
+On Linux 2.4 this would be some /dev/sgN and on 2.6. some /dev/srM or /dev/hdX.
 
 The output of  cdrskin --devices  might look like
 
-    0  dev='/dev/sg0'  rwrwr- :  '_NEC'  'DVD_RW ND-4570A'
-    1  dev='/dev/sg1'  rwrw-- :  'HL-DT-ST'  'DVDRAM GSA-4082B'
+    0  dev='/dev/sr0'  rwrwr- :  '_NEC'  'DVD_RW ND-4570A'
+    1  dev='/dev/sr1'  rwrw-- :  'HL-DT-ST'  'DVDRAM GSA-4082B'
 
-So full and insecure enabling of both for everybody would look like
+On Linux, full and insecure enabling of both for everybody would look like
+    chmod a+rw /dev/sr0 /dev/hda
+This is equivalent to the traditional setup chmod a+x,u+s cdrecord.
 
-    chmod a+rw /dev/sg0 /dev/sg1
+On FreeBSD, device permissions are to be set in /etc/devfs.rules.
+On Solaris, pfexec privileges may be restricted to "basic,sys_devices".
+See below "System Dependend Drive Permission Examples".
 
 I strongly discourage to run cdrskin with setuid root or via sudo !
 It is not checked for the necessary degree of hacker safety.
+Better consider to grant the necessary permissions to group "floppy"
+and to add users to it.
+
+
+A behavioral conflict is known between any burn software and demons like hald
+which probe CD drives. This can spoil burn runs for CD-R or CD-RW.
+You may have to keep your hald away from the drive. See for example
+   http://www.freebsd.org/gnome/docs/halfaq.html
+
+
+Helpful with Linux kernel 2.4 is a special SCSI feature:
+It is possible to address a scsi(-emulated) drive via associated device files
+which are not listed by option --devices but point to the same SCSI addresses
+as listed device files. This addressing via e.g. /dev/sr0 or /dev/scd1 is
+compatible with generic read programs like dd and with write program growisofs.
+For finding /dev/sg1 from /dev/sr0, the program needs rw-access to both files.
 
 
                                 Usage examples 
@@ -152,17 +143,17 @@ Get an overview of cdrecord style addresses of available devices
     cdrskin --devices
 
 Adresses reported with dev=ATA need prefix "ATA:". Address examples:
-    dev=0,1,0  dev=ATA:1,0,0  dev=/dev/sg1  dev=/dev/hdc
+    dev=0,1,0  dev=ATA:1,0,0  dev=/dev/sg1  dev=/dev/hdc  dev=/dev/sr0
 See also "Drive Addressing" below.
 
 Obtain some info about the drive
     cdrskin dev=0,1,0 -checkdrive 
 
 Obtain some info about the drive and the inserted media
-    cdrskin dev=0,1,0 -atip -v
+    cdrskin dev=0,1,0 -atip -v -minfo
 
-Make used CD-RW or used unformatted DVD-RW writeable again
-    cdrskin -v dev=0,1,0 blank=fast -eject 
+Prepare CD-RW or DVD-RW for re-use, DVD-RAM or BD-RE for first use
+    cdrskin -v dev=/dev/sg1 blank=as_needed -eject
 
 Format DVD-RW to avoid need for blanking before re-use
     cdrskin -v dev=0,1,0 blank=format_overwrite
@@ -174,18 +165,18 @@ Burn image file  my_image.iso  to media
     cdrskin -v dev=0,1,0 speed=12 fs=8m driveropts=burnfree padsize=300k \
             -eject  my_image.iso 
 
-Write multi-session to the same CD , DVD-R[W] or DVD+R
+Write multi-session to the same CD , DVD-R[W] or DVD+R[/DL]
     cdrskin dev=/dev/hdc padsize=300k -multi 1.iso
-    cdrskin dev=/dev/hdc padsize=300k -multi -tao 2.iso
-    cdrskin dev=/dev/hdc padsize=300k -multi -tao 3.iso
-    cdrskin dev=/dev/hdc padsize=300k -tao 4.iso
+    cdrskin dev=/dev/hdc padsize=300k -multi 2.iso
+    cdrskin dev=/dev/hdc padsize=300k -multi 3.iso
+    cdrskin dev=/dev/hdc padsize=300k 4.iso
 
 Get multi-session info for option -C of program mkisofs:
     c_values=$(cdrskin dev=/dev/hdc -msinfo 2>/dev/null)
     mkisofs ... -C "$c_values" ...
 
 Burn a compressed afio archive to media on-the-fly
-    find . | afio -oZ - | cdrskin -v dev=0,1,0 fs=32m speed=8 -tao \
+    find . | afio -oZ - | cdrskin -v dev=0,1,0 fs=32m speed=8 \
                                   driveropts=burnfree padsize=300k - 
 
 Burn 6 audio tracks from files with different formats to CD (not to any DVD).
@@ -201,44 +192,30 @@ See below "Audio CD" for specifications.
            -audio -swab track0[1-5].cd /path/to/track6.wav
 
 
-           Usage example with  http://scdbackup.sourceforge.net
-
-Address may be a cdrecord-style  "scsibus,target,lun"  as listed with
-cdrskin -scanbus (and hopefully as listed with cdrecord -scanbus) :
-
-    export SCDBACKUP_SCSI_ADR="0,1,0"
-
-or a device file address as listed by --devices with an accessible drive :
-
-    export SCDBACKUP_SCSI_ADR="/dev/sg1"
-
-Set usage of cdrskin with appropriate options rather than cdrecord :
-
-    export SCDBACKUP_CDRECORD="cdrskin -v -v"
-
-Run a backup :
-
-    scdbackup_home
-
-
                                 Restrictions
 
-Many cdrecord options are still unsupported.
+Several advanced CD related options of cdrecord are still unsupported.
+See output of command
+    cdrskin --list_ignored_options
 If you have use cases for them, please report your wishes and expectations.
 
-DVD support is restricted to single layer DVD for now. Double layer media
-are implemented but untested.
-
+On the other hand, the capability of multi-session and of writing streams
+of unpredicted lenght surpass the current DVD capabilities of cdrecord.
 
 
                            Inspiration and Standard
 
+cdrskin combines the command line interface standard set by cdrecord with
+libburn, which is a control software for optical drives according to standard
+MMC-5. For particular CD legacy commands, standards MMC-3 and MMC-1 apply.
+
 For the original meaning of cdrecord options see :
     man cdrecord 
     (http://cdrecord.berlios.de/old/private/man/cdrecord-2.0.html)
 Do not bother Joerg Schilling with any cdrskin problems.
 (Be cursed if you install cdrskin as "cdrecord" without clearly forwarding
- this "don't bother Joerg" demand.)   
+ this "don't bother Joerg" demand.)
+
 cdrskin does not contain any bytes copied from cdrecord's sources. Many bytes
 have been copied from the message output of cdrecord runs, though. I am
 thankful to Joerg Schilling for every single one of them.
@@ -249,94 +226,6 @@ Many thanks to Andy Polyakov for his dvd+rw-tools
 which provide me with examples and pointers into MMC specs for DVD writing.
 
 
-                              Drive Addressing
-
-Drives get addressed either via their cdrecord-style addresses as listed
-with option -scanbus (see below "Pseudo-SCSI Adresses") or via the paths
-of device files.
-Not only device files listed by --devices may be used but also device files
-which via their major,minor numbers point to the same device driver as
-a listed device file. 
-
-Helpful with Linux kernel 2.4 is a special SCSI feature:
-It is possible to address a scsi(-emulated) drive via associated device files
-which are not listed by option --devices but point to the same SCSI addresses
-as listed device files. This addressing via e.g. /dev/sr0 or /dev/scd1 is
-compatible with generic read programs like dd and with write program growisofs.
-
-                             Pseudo-SCSI Adresses
-
-cdrecord and cdrskin share the syntax of SCSI addresses but not necessarily
-the meaning of the components. A cdrecord-style address for cdrskin
-  [prefix:]scsibus,target,lun
-can be interpreted in two different modes.
-
-Standard mode tries to be compatible to original cdrecord. This should be true
-with (emulated) SCSI where the /dev/sgN with is looked up with matching
-scsibus,target,lun as given by the operating system.
-With dev=ATA: or dev=ATAPI: the translation to /dev/hdX is purely literal
-but matches the cdrecord addresses on all systems tested so far:
-  X = 'a' + 2 * scsibus + target
-where target only may have the values 0 or 1.
-
-In this mode, option -scanbus will list only SCSI devices unless option
-dev=ATA or dev=ATAPI are given, which will suppress SCSI devices and only
-show IDE drives (i.e. /dev/hdX without ide-scsi emulation).
-
-
-In mode  --old_pseudo_scsi_adr  there is a scsibus,target,lun representation
-which has nothing to do with SCSI and thus is not compatible to cdrecord.
-Each number triple corresponds either to a device file address or to a
-libburn drive number.
-Component "scsibus" indicates the translation method. Defined busses are:
-  0  target is the libburn drivenumber as listed with --devices
-  1  associated to device file /dev/sgN , target chooses N
-  2  associated to device file /dev/hdX , target 0='a', 1='b' ..., 25='z' 
-
-So "1,1,0" is /dev/sg1, "2,3,0" is /dev/hdd, "0,2,0" is libburn drive #2 at
-some unspecified device file. 
-This scheme shall help to keep cdrecord-style addresses stable and exchangeable
-between users without excluding drives with unexpected device addresses.
-The numbering on bus 0 is prone to arbitrary changes caused by changes in
-drive accessability.
-Further busses may emerge as libburn evolves. "prefix" and "lun" may get
-a meaning. To stay upward compatible, use addresses as printed by -scanbus.
-
-                  User Defined Device Address Translation
-
-Some programs or users have their own ideas about the address of their burner.
-K3b 0.10 for example derives cdrecord addresses by own examination of the
-devices and not by calling cdrecord -scanbus.
-Standard mode will hopefully be fully compatible with their ideas.
-
-Old frontends which do not know dev=ATA or dev=ATAPI and which do ask their
-"cdrecord" via -scanbus may be well served with option  --old_pseudo_scsi_adr .
-
-To direct any remaining stubborn callers to the appropriate drives, cdrskin
-allows to define device address aliases. Like
-  cdrskin dev_translation=+1,0,0+/dev/sg1 \
-          dev_translation=+ATA:1,0,0+/dev/sg1 \
-          dev_translation=-"cd+dvd"-0,1,0 \
-          ...
-Any of the addresses dev=1,0,0, dev=ATA:1,0,0, dev=cd+dvd will be mapped to
-/dev/sg1 resp. to 0,1,0.
-The first character after "dev_translation=" defines the character which
-separates the two parts of the translation pair. (Above: "+" and "-".)
-
-In K3b 0.10 it is possible to employ alternative writer programs by setting
-their full path (e.g. /usr/bin/cdrskin) in menu
-  Settings:Configure K3b...:Programs:Search Path 
-and to make them default in menu
-  Settings:Configure K3b...:Programs:Programs:
-A suitable setting for "cdrecord" in menu 
-  Settings:Configure K3b...:Programs:User Parameters
-would then probably be
-  -v dev_translation=+1,0,0+/dev/sg1
-You will learn from button "Show Debugging Output" after a failed burn run
-what cdrecord command was used with what address "dev=...". This address "..."
-will be the right one to replace "1,0,0" in above example.
-
-
                                  Startup Files
 
 If not --no_rc is the first argument then cdrskin attempts on startup to read
@@ -352,8 +241,6 @@ A first character '#' marks a comment, empty lines are ignored.
 Example content of a startup file:
 # This is the default device
 dev=0,1,0
-# To accomodate to eventual remnant cdrskin-0.2.2 addresses
-dev_translation=+1,0,0+0,1,0
 
 # Some more options
 fifo_start_at=0
@@ -386,39 +273,48 @@ I myself am not into audio. So libburn-hackers@pykix.org might be the
 best address for suggestions, requests and bug reports.
 
 
-                             DVD+RW and DVD-RAM
+                          DVD+RW , DVD-RAM , BD-RE
 
-DVD+RW and DVD-RAM media get treated as blank media regardless wether they
+These random access media get treated as blank media regardless wether they
 hold data or not. Options -audio and -multi are not allowed. Only one track
 is allowed. -toc does not return information about the media content.
-Speed is counted in DVD units (i.e. 1x = 1,385,000 bytes/second). Currently
-there is no difference between -sao and -tao. If ever, then -tao will be the
-mode which preserves the current behavior.
+Speed is counted in DVD units (i.e. 1x = 1,385,000 bytes/second) or BD units
+(1x = 4,495,625 bytes/second). Currently there is no difference between -sao
+and -tao. If ever, then -tao will be the mode which preserves the current
+behavior.
 
-For these media, -msinfo alone would not be enough to perform appending of an
-ISO filesystem. The filesystem driver will need a hint to find the start of the
-most recent session. For example put an ISO filesystem at address 1 GB:
-  mkisofs -C 0,524288 ... | \
-  cdrskin dev=/dev/sr0 -v fs=32m -eject speed=4 write_start_address=524288s -
-The superuser may then do:
-  mount -t iso9660 -o ro,sbsector=524288 /dev/sr0 /mnt
-Note: On my linux-2.4.21-215 mount works only with sbsector <= 337920 (660 MB).
-To extend a filesystem already existing at address 0
-  mkisofs -C 0,524288 -M /dev/sr0 ... | cdrskin dev=/dev/sr0 ...
-Record the number 524288 for usage as first number with -C at the next
-extension:
-  mkisofs -C 524288,1000000 ... | cdrskin write_start_address=1000000s ...
+BD-RE media need formatting before first use. cdrskin option "blank=as_needed"
+recognizes unformatted BD-RE and applies a lengthy formatting run.
 
-Program growisofs can append to an ISO filesystem on DVD+RW by additionally
-manipulating the first session. cdrskin does not want to get involved so deep
-into the format of the burned data. Be advised to use growisofs for the
-task of maintaining extendable ISO-Filesystems on DVD+RW. 
+During write operations DVD-RAM and BD-RE automatically apply Defect
+Management. This usually slows them down to half nominal speed. If drive
+and media produce flawless results anyway, then one can try to reach full
+nominal speed by option "stream_recording=on".
+In this case bad blocks are not detected during write and not even previously
+known bad blocks are avoided. So you have to make your own readability tests
+and go back to half speed as soon as the first read errors show up.
+Instead of "on" one may also set a start address for stream recording.
+Like "stream_recording=100m". This will write slowly to the first 100 MB of
+the media and accelerate when writing to higher addresses.
+
+Option --grow_overwriteable_iso allows -multi (although unneeded), enables
+-msinfo and -toc, and makes blank=fast an invalidator for ISO filesystems
+on overwriteable media.
+
+Initial session (equivalent to growisofs -Z): 
+  mkisofs ... | cdrskin --grow_overwriteable_iso blank=fast ...
+
+Add-on session (equivalent to growisofs -M):
+  cparms=$(cdrskin dev=/dev/sr0 --grow_overwriteable_iso -msinfo)
+  mkisofs -C "$cparms" -M /dev/sr0 ... | \
+    cdrskin dev=/dev/sr0 --grow_overwriteable_iso ... -
 
 
-                               DVD-RW and DVD-R
+                            DVD-RW , DVD-R , DVD-R DL
 
 DVD-RW are usable if formatted to state "Restricted Overwrite" or if in state
-"Sequential Recording". DVD-R are always in sequential state.
+"Sequential Recording". DVD-R are always in sequential state. DVD-R DL are
+always sequential and incapable of multi-session.
 
 "Sequential" is the state of unused media and of media previously blanked
 or written by cdrecord. dvd+rw-format -blank can also achieve this state.
@@ -428,7 +324,7 @@ of multi-session like CD-R[W]. (But not capable of -audio recording.)
 This means they need option -multi to stay appendable, need to be blanked
 to be writeable from start, return useable info with -toc and -msinfo,
 eventually perform appending automatically.
-Without "Incremental Streaming" offered by the drive, only write mode DAO is
+Without Incremental Streaming offered by the drive, only write mode DAO is
 available with sequential DVD-R[W]. It only works with blank media, allows only
 one single track, no -multi, and demands a fixely predicted track size.
 (growisofs uses it with DVD-R[W] if option -dvd-compat is given.)
@@ -437,7 +333,7 @@ Overwriteable DVD-RW behave much like DVD+RW. "Restricted" refers only to the
 granularity of random access and block size which have always to be aligned to
 full 32 kB. Sequential DVD-RW are converted into overwriteable DVD-RW by
   cdrskin dev=... -v blank=format_overwrite
-(Command  dvd+rw-format -force  can achieve "Restricted Overwrite", too.)
+(Command  dvd+rw-format -force  can achieve Restricted Overwrite, too.)
 
 Formatting or first use of freshly formatted DVD-RW can produce unusual noises
 from the drive and last several minutes. Depending on mutual compatibility of
@@ -447,7 +343,7 @@ too on blanking by cdrecord, dvd+rw-format or cdrskin. Perils of DVD-RW.
 There are three DVD-RW formatting variants with cdrskin currently:
 
 blank=format_overwrite  uses "DVD-RW Quick" formatting (MMC-type 15h)
-and writes a first session of 128 MB. This leads to media which are expandable
+and writes a first session of 128 MiB. This leads to media which are expandable
 and random addressable by cdrskin.
 
 blank=format_overwrite_quickest  uses "DVD-RW Quick" formatting (type 15h) too,
@@ -470,15 +366,63 @@ Incremental Streaming afterwards. So blank=fast will do full blanking.
 blank=deformat_sequential_quickest   is faster but might yield DAO-only media.
 
 
-                                  DVD+R 
+                           DVD+R , DVD+R DL , BD-R
 
 From the view of cdrskin they behave much like DVD-R. Each track gets wrapped
 into an own session, though.
 
+DVD+R DL appear as extra large DVD+R. cdrskin does not allow to set the address
+of the layer break where a reading drive might show some delay while switching
+between both media layers.
+
+BD-R are sold unformatted blank. If used without initial formatting then the
+drive is supposed to format them to maximum payload size with no Defect
+Management (see also above with BD-RE).
+If Defect Management is desired then BD-R need to be formatted before the
+first attempt to write a session to them.
+blank=format_if_needed    will detect the situation and eventually apply
+                          default sized Defect Management formatting.
+blank=format_defectmgt_*  will apply non-default parameters to formatting.
+
+
+                              Emulated Drives
+
+cdrskin can use filesystem objects as emulated drives. Regular files or block
+devices appear similar to DVD-RAM. Other file types resemble blank DVD-R.
+Necessary precondition is option --allow_emulated_drives which is not accepted
+if cdrskin took another user identity because of the setuid bit of its access
+permissions.
+Addresses of emulated drives begin with prefix "stdio:". E.g.
+  dev=stdio:/tmp/my_pseudo_drive
+
+For safety reasons the superuser is only allowed to use /dev/null as emulated
+drive. See man page section FILES for a way to lift that ban.
+
+
 ------------------------------------------------------------------------------
 
                         Special compilation variations
 
+All following options of ./configure and cdrskin/compile_cdrskin.sh are
+combinable. After runs of ./configure do as next:
+    make clean ; make
+
+In some situations Linux may deliver a better write performance to drives if
+the track input is read with O_DIRECT (see man 2 open). The API call
+burn_os_open_track_src() and the input readers of cdrskin and libburn fifo
+can be told to use this peculiar read mode by:
+    --enable-track-src-odirect
+
+But often cdrskin option dvd_obs=64k will yield even better performance in
+such a situation. 64k can be made default at compile time by 
+    cdrskin/compile_cdrskin.sh -dvd_obs_64k
+It can also be enabled at configure time by
+    ./configure ... --enable-dvd-obs-64k ...
+
+Alternatively the transport of SCSI commands can be done via libcdio-0.83.
+You may install it and re-run libburn's ./configure with option
+    --enable-libcdio
+
 You may get a (super fat) statically linked binary by :
     cdrskin/compile_cdrskin.sh -static
 if your system supports static linking, at all. This will not help with kernels
@@ -494,12 +438,130 @@ It will not read startup files, will abort on option  dev_translation= ,
 will not have a fifo buffer, and will not be able to put out help texts or
 debugging messages.
 
+
+Linux only:
+
+libburn tries to avoid a collision with udev's drive examination by waiting
+0.1 seconds before opening the device file for a longer time, after udev
+might have been alarmed by drive scanning activities.
+The waiting time can be set at ./configure time with microsecond granularity.
+E.g. 2 seconds:
+  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=2000000"
+  ./configure ...options...
+Waiting can be disabled by zero waiting time:
+  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=0"
+Alternatively, libburn can try to be nice by opening the device file,
+closing it immediately, waiting, and only then opening it for real:
+  CFLAGS="$CFLAGS -DLibburn_udev_extra_open_cyclE -DLibburn_udev_wait_useC=500000"
+
+------------------------------------------------------------------------------
+
+                  System Dependend Drive Permission Examples
+
+Accessing the optical drives requires privileges which usually are granted
+only to the superuser. Linux, FreeBSD and Solaris offer quite different
+approaches for avoiding the need for unrestricted privileges.
+
+First check whether some friendly system setting already allows you to
+access the drives as normal user:
+  cdrskin --devices
+Those drives of which you see address and type strings are already usable.
+
+If there remain drives invisible which the superuser can see by the same
+command, then the following examples might help:
+
+--------------------- 
+On all three systems:
+--------------------- 
+Add the authorized users of CD drives to group "floppy" in /etc/group.
+If missing: create this group.
+Changes to /etc/group often only affect new login sessions. So log out and in
+before making the first tests.
+
+---------
+On Linux:
+---------
+Allow rw-access to the drives
+  chgrp floppy /dev/sr0 /dev/sr1
+  chmod g+rw   /dev/sr0 /dev/sr1
+It might be necessary to perform chgrp and chmod after each reboot or to
+edit distro dependent device configuration files for permanent settings.
+
+-----------
+On FreeBSD:
+-----------
+Edit /etc/devfs.rules and make sure to have these lines
+  [localrules=10]
+  add path 'acd*' mode 0664 group floppy
+  add path 'cd*' mode 0664 group floppy
+  add path 'pass*' mode 0664 group floppy
+  add path 'xpt*' mode 0664 group floppy
+  [localrules=5]
+  add path 'pass*' mode 0664 group floppy
+  add path 'cd*' mode 0664 group floppy
+  add path 'xpt*' mode 0664 group floppy
+  add path 'acd*' mode 0664 group floppy
+
+Edit /etc/rc.conf and add the following line if missing
+  devfs_system_ruleset="localrules"
+
+This gets into effect by reboot or by command
+  /etc/rc.d/devfs start
+
+-----------
+On Solaris:
+-----------
+Run cdrskin by
+  pfexec cdrskin ...arguments...
+
+The following settings will make pfexec keep original UID and EUID and prevent
+most superuser powers. Be aware that you still can manipulate all device files
+if you have the file permissions for that.
+Full root privileges for cdrskin can then be aquired only by command su.
+
+Edit /etc/security/exec_attr and add this line to the other "Media Backup"
+lines:
+  Media Backup:solaris:cmd:::/usr/local/bin/cdrskin:privs=basic,sys_devices
+Edit /etc/user_attr and add profile "Media Backup" to the user's line:
+  thomas::::profiles=Media Backup,Primary Administrator;roles=root
+See also man privileges, man exec_attr, man user_attr.
+
+Then allow the group r-access to the drives
+  pfexec chgrp floppy /dev/rdsk/c3t0d0s2 /dev/rdsk/c4t0d0s2
+  pfexec chmod g+r    /dev/rdsk/c3t0d0s2 /dev/rdsk/c4t0d0s2
+The last two commands have to be executed after each boot. I do not know
+the relevant device configuration files yet.
+
+
+------------------------------------------------------------------------------
+                      Project aspects and legal stuff
+------------------------------------------------------------------------------
+
+Important Disclaimer :
+
+This software is provided as is. There is no warranty implied and no
+protection against possible damages. You use this on your own risk.
+Don't blame me or other authors of libburn if anything goes wrong.
+
+Actually, in case of severe trouble, nearly always the drive and the media
+are the cause. Any mistake of the burn program is supposed to be caught
+by the drive's firmware and to lead to mere misburns.
+The worst mishaps which hit the author imposed the need to reboot the
+system because of drives gnawing endlessly on ill media. Permanent hardware
+damage did not occur in 3.5 years of development. But one never knows ...
+
+------------------------------------------------------------------------------
+
+Interested users are invited to participate in the development of cdrskin.
+Contact: scdbackup@gmx.net or libburn-hackers@pykix.org .
+We will keep copyright narrow but will of course acknowledge valuable
+contributions in a due way.
+
 ------------------------------------------------------------------------------
 
     This program is free software; you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation; either version 2 of the License, or
-    (at your option) any later version.
+    it under the terms of the GNU General Public License version 2 or later
+    as published by the Free Software Foundation.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -511,33 +573,17 @@ debugging messages.
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 ------------------------------------------------------------------------------
-cdrskin is currently copyright Thomas Schmitt only.
-It adopts the following commitment by the toplevel copyright holders:
-------------------------------------------------------------------------------
+Based on and sub project of:
+libburnia-project.org
+By Mario Danic <mario.danic@gmail.com> and Thomas Schmitt <scdbackup@gmx.net>
+Copyright (C) 2006-2011 Mario Danic, Thomas Schmitt
 
-We, the copyright holders, agree on the interpretation that
-dynamical linking of our libraries constitutes "use of" and
-not "derivation from" our work in the sense of GPL, provided
-those libraries are compiled from our unaltered code.
+libburnia-project.org is inspired by and in other components still containing
+parts of
+Libburn. By Derek Foreman <derek@signalmarketing.com> and
+            Ben Jansens <xor@orodu.net>
+Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
+See toplevel README for an overview of the current copyright situation in
+libburnia-project.org.
 
-Thus you may link our libraries dynamically with applications
-which are not under GPL. You may distribute our libraries and
-application tools in binary form, if you fulfill the usual
-condition of GPL to offer a copy of the source code -altered
-or unaltered- under GPL.
 
-We ask you politely to use our work in open source spirit
-and with the due reference to the entire open source community.
-
-If there should really arise the case where above clarification
-does not suffice to fulfill a clear and neat request in open source
-spirit that would otherwise be declined for mere formal reasons,
-only in that case we will duely consider to issue a special license
-covering only that special case.
-It is the open source idea of responsible freedom which will be
-decisive and you will have to prove that you exhausted all own
-means to qualify for GPL.
-
-For now we are firmly committed to maintain one single license: GPL.
-
-signed for cdrskin: Thomas Schmitt

cdrskin/add_ts_changes_to_libburn_1_1_8

@@ -38,8 +38,9 @@ original="./libburn_svn_release.tgz"
 # My changes are in $changes , mainly in $changes/cdrskin
 changes="./libburn-release"
 
-skin_release="0.3.4"
-patch_level=".pl00"
+skin_release="1.1.8"
+patch_level=""
+# patch_level=".pl00"
 skin_rev="$skin_release""$patch_level"
 
 # The result directory and the name of the result tarballs
@@ -58,7 +59,8 @@ compile_result="cdrskin/cdrskin"
 man_to_html_cmd="./cdrskin/convert_man_to_html.sh"
 man_page_html="cdrskin/man_1_cdrskin.html"
 
-bintarget_dynamic="cdrskin_${skin_rev}-x86-suse9_0"
+# bintarget_dynamic="cdrskin_${skin_rev}-x86-suse9_0"
+bintarget_dynamic="cdrskin_${skin_rev}-amd64-suse10_2"
 bintarget_static="$bintarget_dynamic"-static
 
 if test -d "$changes"
@@ -103,9 +105,9 @@ cdrskin_target="$target"/cdrskin
 libburn_target="$target"/libburn
 
 # Create version timestamp
-timestamp="$(date -u '+%Y.%m.%d.%H%M%S')"
-echo "$timestamp"
-echo '#define Cdrskin_timestamP "'"$timestamp"'"' >"$cdrskin_dir"/cdrskin_timestamp.h
+# timestamp="$(date -u '+%Y.%m.%d.%H%M%S')"
+# echo "$timestamp"
+# echo '#define Cdrskin_timestamP "'"$timestamp"'"' >"$cdrskin_dir"/cdrskin_timestamp.h
 
 # Add the cdrskin files
 if test -e "$cdrskin_target"
@@ -114,7 +116,9 @@ then
 fi
 cp -a "$cdrskin_dir" "$cdrskin_target"
 
-# Remove copied binaries
+# Remove copied vim.swp and binaries
+rm "$cdrskin_target"/.*.swp
+rm "$cdrskin_target"/.*.swo
 rm "$cdrskin_target"/*.o
 rm "$cdrskin_target"/cdrfifo
 rm "$cdrskin_target"/cdrskin
@@ -137,7 +141,7 @@ do
 done
 
 # Remove GIFs of cdrskin_eng.html
-rm "$cdrskin_target"/doener_*.gif
+rm "$cdrskin_target"/doener_*.gif "$cdrskin_target"/doener_*.png
 
 # Remove automatically generated HTML man page
 rm "$cdrskin_target"/man_1_cdrskin.html
@@ -153,6 +157,10 @@ do
   fi
 done
 
+# Remove libcevap
+rm -rf "$target"/libcevap
+
+
 # Remove unwanted SVN stuff (TODO: avoid downloading it)
 for i in "$target"/.svn "$target"/*/.svn
 do

cdrskin/add_ts_changes_to_libburn_1_1_9

@@ -24,9 +24,9 @@ set -x
 # The top level directory in the SVN snapshot is named
 intermediate="./libburn_pykix"
 
-# libburn source used:  http://libburnia.pykix.org
+# libburn source used:  http://libburnia-project.org
 # Downloaded by:
-#  $ svn co http://libburnia-svn.pykix.org/libburn/tags/... $intermediate
+#  $ svn co http://libburnia-project.org/libburn/tags/... $intermediate
 # packed up in a tarball just to save it from inadverted changes by
 #  $ tar czf libburn_svn.tgz $intermediate
 original="./libburn_svn.tgz"
@@ -38,7 +38,7 @@ original="./libburn_svn.tgz"
 # My changes are in $changes , mainly in $changes/cdrskin
 changes="./libburn-develop"
 
-skin_release="0.3.5"
+skin_release="1.1.9"
 patch_level=""
 skin_rev="$skin_release""$patch_level"
 
@@ -58,7 +58,7 @@ compile_result="cdrskin/cdrskin"
 man_to_html_cmd="./cdrskin/convert_man_to_html.sh"
 man_page_html="cdrskin/man_1_cdrskin.html"
 
-bintarget_dynamic="cdrskin_${skin_rev}-x86-suse9_0"
+bintarget_dynamic="cdrskin_${skin_rev}-amd64-suse10_2"
 bintarget_static="$bintarget_dynamic"-static
 
 if test -d "$changes"
@@ -114,7 +114,9 @@ then
 fi
 cp -a "$cdrskin_dir" "$cdrskin_target"
 
-# Remove copied binaries
+# Remove copied vim.swp and binaries
+rm "$cdrskin_target"/.*.swp
+rm "$cdrskin_target"/.*.swo
 rm "$cdrskin_target"/*.o
 rm "$cdrskin_target"/cdrfifo
 rm "$cdrskin_target"/cdrskin
@@ -137,11 +139,14 @@ do
 done
 
 # Remove GIFs of cdrskin_eng.html
-rm "$cdrskin_target"/doener_*.gif
+rm "$cdrskin_target"/doener_*.gif "$cdrskin_target"/doener_*.png
 
 # Remove automatically generated HTML man page
 rm "$cdrskin_target"/man_1_cdrskin.html
 
+# Remove libcevap
+rm -rf "$target"/libcevap
+
 # Remove all add_ts_changes_to_libburn besides this one
 for i in "$cdrskin_target"/add_ts_changes_to_libburn*
 do
@@ -214,13 +219,15 @@ tar czf "$cdrskin_tarball" "$target"
  cd "$compile_dir" || exit 1
  ./configure
  make
- "$compile_cmd" -O2 -do_strip
+ "$compile_cmd" -libburn_svn -O2 -do_strip
  cp "$compile_result" "../$bintarget_dynamic"
  if test -n "$compile_static_opts"
  then
-   "$compile_cmd" $compile_static_opts -O2 -do_strip
+   "$compile_cmd" $compile_static_opts -libburn_svn -O2 -do_strip
    cp "$compile_result" "../$bintarget_static"
  fi
+#  "$compile_cmd" -libburn_svn -O2 -do_diet -do_strip
+#  cp "$compile_result" "../$bintarget_dynamic"_diet
  "$man_to_html_cmd"
  mv "$man_page_html" ..
 )

cdrskin/cdrfifo.c

@@ -25,11 +25,16 @@
 #include <sys/time.h>
 #include <sys/select.h>
 
+#ifndef Cdrfifo_standalonE
+/* <<< until release of 0.7.4 : for Libburn_has_open_trac_srC */
+#include "../libburn/libburn.h"
+#endif
+
 #include "cdrfifo.h"
 
 
 /* Macro for creation of arrays of objects (or single objects) */
-#define TSOB_FELD(typ,anz) (typ *) malloc((anz)*sizeof(typ));
+#define TSOB_FELD(typ,anz) (typ *) calloc(anz, sizeof(typ));
 
 
 #define Cdrfifo_buffer_chunK 2048
@@ -79,6 +84,7 @@ struct CdrfifO {
 
  /* eventual ISO-9660 image size obtained from first 64k of input */
  double iso_fs_size; 
+ char *iso_fs_descr; /* eventually block 16 to 31 of input */
 
  /* (sequential) fd chaining */
  /* fds: 0=source, 1=dest  */
@@ -119,7 +125,7 @@ struct CdrfifO {
                    struct burn_source object.
     @param chunk_size Size of buffer block for a single transaction (0=default)
     @param buffer_size Size of fifo buffer
-    @param flag Unused yet
+    @param flag bit0= Debugging verbosity
     @return 1 on success, <=0 on failure
 */
 int Cdrfifo_new(struct CdrfifO **ff, int source_fd, int dest_fd,
@@ -162,6 +168,7 @@ int Cdrfifo_new(struct CdrfifO **ff, int source_fd, int dest_fd,
  o->empty_counter= 0.0;
  o->full_counter= 0.0;
  o->iso_fs_size= -1.0;
+ o->iso_fs_descr= NULL;
  for(i= 0; i<Cdrfifo_ffd_maX; i++) {
    o->follow_up_fds[i][0]= o->follow_up_fds[i][1]= -1;
    o->follow_up_eop[i]= o->follow_up_sod[i]= -1;
@@ -172,7 +179,13 @@ int Cdrfifo_new(struct CdrfifO **ff, int source_fd, int dest_fd,
  o->follow_up_fd_idx= -1;
  o->next= o->prev= NULL;
  o->chain_idx= 0;
+
+#ifdef Libburn_has_open_trac_srC
+ o->buffer= burn_os_alloc_buffer((size_t) buffer_size, 0);
+#else
  o->buffer= TSOB_FELD(char,buffer_size);
+#endif /* ! Libburn_has_open_trac_srC */
+
  if(o->buffer==NULL)
    goto failed;
  return(1);
@@ -190,10 +203,11 @@ int Cdrfifo_close(struct CdrfifO *o, int flag)
  if(o->dest_fd!=-1)
    close(o->dest_fd);
  o->dest_fd= -1;
- for(i=0; i<o->follow_up_fd_counter; i++)
+ for(i=0; i<o->follow_up_fd_counter; i++) {
    if(o->follow_up_fds[i][1]!=-1)
      close(o->follow_up_fds[i][1]);
    o->follow_up_fds[i][1]= -1;
+ }
  return(1);
 }
 
@@ -222,8 +236,16 @@ int Cdrfifo_destroy(struct CdrfifO **ff, int flag)
 
  /* eventual closing of source fds is the job of the calling application */
 
+ if(o->iso_fs_descr!=NULL)
+   free((char *) o->iso_fs_descr);
+
  if(o->buffer!=NULL)
+#ifdef Libburn_has_open_trac_srC
+   burn_os_free_buffer(o->buffer, o->buffer_size, 0);
+#else
    free((char *) o->buffer);
+#endif /* Libburn_has_open_trac_srC */
+
  free((char *) o);
  (*ff)= NULL;
  return(1);
@@ -400,6 +422,14 @@ int Cdrfifo_get_iso_fs_size(struct CdrfifO *o, double *size_in_bytes, int flag)
 }
 
 
+int Cdrfifo_adopt_iso_fs_descr(struct CdrfifO *o, char **pt, int flag)
+{
+ *pt= o->iso_fs_descr;
+ o->iso_fs_descr= NULL;
+ return(*pt!=NULL);
+}
+
+
 /** Get counters which are mentioned by cdrecord at the end of burning.
     It still has to be examined wether they mean what i believe they do.
 */
@@ -604,7 +634,7 @@ return: <0 = error , 0 = idle , 1 = did some work
 */
 {
  double buffer_space;
- int can_read,can_write,ret,did_work= 0,idx,sod,eop_is_near,eop_idx;
+ int can_read,can_write= 0,ret,did_work= 0,idx,sod, eop_idx;
 
  buffer_space= Cdrfifo_tell_buffer_space(o,0);
  if(o->dest_fd>=0) if(FD_ISSET((o->dest_fd),wts)) {
@@ -614,7 +644,7 @@ return: <0 = error , 0 = idle , 1 = did some work
    if(o->read_idx+can_write > o->buffer_size)
      can_write= o->buffer_size - o->read_idx;
    if(o->follow_up_fd_idx>=0) {
-     eop_is_near= Cdrfifo_eop_adjust(o,&can_write,&eop_idx,0);
+     Cdrfifo_eop_adjust(o,&can_write,&eop_idx,0);
      if(can_write<=0)
        goto after_write;
    }
@@ -647,6 +677,46 @@ return: <0 = error , 0 = idle , 1 = did some work
 after_write:;
  if(o->source_fd>=0) if(FD_ISSET((o->source_fd),rds)) {
    can_read= o->buffer_size - o->write_idx;
+
+#ifdef Libburn_has_open_trac_srC
+
+   /* ts A91115
+      This chunksize must be aligned to filesystem blocksize.
+    */
+#define Cdrfifo_o_direct_chunK 32768
+
+   if(o->write_idx < o->read_idx && o->write_idx + can_read > o->read_idx)
+     can_read= o->read_idx - o->write_idx;
+   if(o->fd_in_limit>=0.0)
+     if(can_read > o->fd_in_limit - o->fd_in_counter)
+       can_read= o->fd_in_limit - o->fd_in_counter;
+   /* Make sure to read with properly aligned size */
+   if(can_read > Cdrfifo_o_direct_chunK)
+     can_read= Cdrfifo_o_direct_chunK;
+   else if(can_read < Cdrfifo_o_direct_chunK)
+     can_read= -1;
+   ret= 0;
+   if(can_read>0)
+     ret= read(o->source_fd,o->buffer+o->write_idx,can_read);
+   if(can_read < 0) {
+     /* waiting for a full Cdrfifo_o_direct_chunK to fit */
+     if(can_write <= 0 && o->dest_fd >= 0) {
+        fd_set rds,wts,exs;
+        struct timeval wt;
+
+        FD_ZERO(&rds);
+        FD_ZERO(&wts);
+        FD_ZERO(&exs);
+        FD_SET((o->dest_fd),&wts);
+        wt.tv_sec=  0;
+        wt.tv_usec= 10000;
+        select(o->dest_fd + 1,&rds, &wts, &exs, &wt);
+
+     }
+   } else
+
+#else /* Libburn_has_open_trac_srC */
+
    if(can_read>o->chunk_size)
      can_read= o->chunk_size;
    if(o->write_idx<o->read_idx && o->write_idx+can_read > o->read_idx)
@@ -657,6 +727,9 @@ after_write:;
    ret= 0;
    if(can_read>0)
      ret= read(o->source_fd,o->buffer+o->write_idx,can_read);
+
+#endif /* ! Libburn_has_open_trac_srC */
+
    if(ret==-1) {
 
      /* >>> handle input error */;
@@ -882,19 +955,24 @@ int Cdrfifo_fill(struct CdrfifO *o, int size, int flag)
  }
 
 #ifndef Cdrfifo_standalonE
- { int Scan_for_iso_size(unsigned char data[2048], double *size_in_bytes,
+ if(fill>=32*2048) {
+   int Scan_for_iso_size(unsigned char data[2048], double *size_in_bytes,
                          int flag);
-   int i;
+   int bs= 16*2048;
    double size;
 
-   /* try to obtain an ISO-9660 file system size */
-   for(i= 0; i<32*2048 && i+2048<=fill; i+=2048) {
-     ret= Scan_for_iso_size((unsigned char *) (o->buffer+i), &size, 0);
-     if(ret<=0)
-   continue;
+   /* memorize blocks 16 to 31 */
+   if(o->iso_fs_descr!=NULL)
+     free((char *) o->iso_fs_descr);
+   o->iso_fs_descr= TSOB_FELD(char,bs);
+   if(o->iso_fs_descr==NULL)
+     return(-1);
+   memcpy(o->iso_fs_descr,o->buffer+bs,bs);
+
+   /* try to obtain ISO-9660 file system size from block 16 */
+   ret= Scan_for_iso_size((unsigned char *) (o->buffer+bs), &size, 0);
+   if(ret>0)
      o->iso_fs_size= size;
-   break;
-   }
  }
 #endif
 
@@ -961,9 +1039,9 @@ int Test_mixed_bs(char **paths, int path_count,
  bit0= debugging verbousity
 */
 {
- int fd_in[100],fd_out[100],ret,pipe_fds[100][2],real_out[100];
+ int fd_in[100],fd_out[100],ret,pipe_fds[100][2];
  int i,iv,stall_counter= 0,cycle_counter= 0.0;
- char buf[10240], target_path[80];
+ char target_path[80];
  double in_counter, out_counter, prev_in= -1.0, prev_out= -1.0;
  struct CdrfifO *ff_in= NULL, *ff_out= NULL;
 
@@ -1031,9 +1109,8 @@ int Test_multi(int fs_size, double speed_limit, double interval, int flag)
  bit0= debugging verbousity
 */
 {
- int fd_in[4],fd_out[4],ret,pipe_fds[4][2],real_out[4],pipe_idx;
+ int fd_in[4],fd_out[4],ret,pipe_fds[4][2];
  int i,iv;
- char buf[10240];
  struct CdrfifO *ff1= NULL,*ff2= NULL;
 
  /* open four pairs of fds */

cdrskin/cdrfifo.h

@@ -33,7 +33,7 @@ struct CdrfifO;
                    struct burn_source object.
     @param chunk_size Size of buffer block for a single transaction (0=default)
     @param buffer_size Size of fifo buffer
-    @param flag unused yet
+    @param flag bit0= Debugging verbosity
     @return 1 on success, <=0 on failure
 */
 int Cdrfifo_new(struct CdrfifO **ff, int source_fd, int dest_fd,
@@ -123,6 +123,16 @@ int Cdrfifo_get_cdr_counters(struct CdrfifO *o,
 int Cdrfifo_get_iso_fs_size(struct CdrfifO *o, double *size_in_bytes,int flag);
 
 
+/** Take over the eventually memorized blocks 16 to 31 of input (2 kB each).
+    The fifo forgets the blocks by this call. I.e. a second one will return 0.
+    After this call it is the responsibility of the caller to dispose the
+    retrieved memory via call free().
+    @param pt Will be filled either with NULL or a pointer to 32 kB of data
+    @return 0=nothing is buffered, 1=pt points to valid freeable data
+*/
+int Cdrfifo_adopt_iso_fs_descr(struct CdrfifO *o, char **pt, int flag);
+
+
 /** Check for pending data at the fifo's source file descriptor and wether the
     fifo is ready to take them. Simultaneously check the buffer for existing
     data and the destination fd for readiness to accept some. If so, a small

cdrskin/cdrskin_eng.html

@@ -2,7 +2,7 @@
 
 <HEAD>
 <META NAME="description" CONTENT="cdrskin, a limited cdrecord compatibility wrapper for libburn">
-<META NAME="keywords" CONTENT="cdrskin, libburn, libburnia, burn, CD, DVD, linux, recording, burning, CD-R, CD-RW, DVD-R, DVD-RW, DVD+RW, DVD+R, cdrecord, compatible, scdbackup">
+<META NAME="keywords" CONTENT="cdrskin, libburn, libburnia, burn, CD, DVD, BD, linux, recording, burning, CD-R, CD-RW, DVD-R, DVD-R DL, DVD-RW, DVD+RW, DVD+R, DVD+R DL, DVD-RAM, BD-RE, BD-R, cdrecord, compatible, scdbackup">
 <META NAME="robots" CONTENT="follow">
 <TITLE>cdrskin homepage english</TITLE>
 </HEAD>
@@ -12,40 +12,49 @@
 
 <CENTER>
 <A HREF="http://en.wikipedia.org/wiki/D%C3%B6ner_kebab">
-<IMG SRC="doener_150x200_tr_octx.gif" BORDER=0
+<IMG SRC="doener_150x200_tr_octx.png" BORDER=0
      ALT="cdrskin logo: Doener mit Scharf">
 </A>
 <P><H2> Homepage of </H2>
 <H1> cdrskin </H1>
-<!-- <FONT SIZE=+0><A HREF="cdrskin_ger.html">deutsch (german)</A></FONT> -->
 
 <H2>Limited cdrecord compatibility wrapper for libburn</H2>
 </CENTER>
 
 <P>
 <H2>Purpose:</H2>
-Burns preformatted data to CD and single layer DVD media:<BR>
-CD-R, DVD-R, DVD+R, CD-RW, DVD-RW, DVD-RAM, DVD+RW
+Burns preformatted data to CD, DVD, and BD media:<BR>
+CD-R, DVD-R, DVD-R DL, DVD+R, DVD+R DL, BD-R, CD-RW,
+DVD-RW, DVD-RAM, DVD+RW, BD-RE
 </P>
 <P>
 
 <HR>
 
+<A HREF="#download">Direct hop to download links -></A>
+
 <P>
 <H2>Hardware requirements:</H2>
-A CD/DVD recorder suitable for 
-<A HREF="http://libburnia.pykix.org">libburnia.pykix.org</A> <BR>
-(SCSI , ATA , USB , or SATA writers compliant to standard MMC-3 for CD
-and to MMC-5 for DVD).
+About any CD, DVD, or BD recorder produced in the recent ten years.
+<BR>
+<A HREF="http://libburnia-project.org">libburn</A>
+supports recorders which are compliant to standards MMC-1 for CD and
+MMC-5 for DVD or BD. Linux, FreeBSD, and Solaris allow to access drives
+connected via SCSI, PATA (aka IDE, ATA), USB, or SATA.
 <BR>
 </P>
 
 <P>
 <H2>Software requirements :</H2>
 <DL>
-<DT>Linux kernel 2.4 or higher</DT>
+<DT>Linux with kernel 2.4 or higher (and libc, of course) :</DT>
 <DD>With kernel 2.4 an ATA drive has to be under ide-scsi emulation.</DD>
 <DD>With kernel 2.6 the drive should not be under ide-scsi.</DD>
+<DT>or FreeBSD (with libc, of course) :</DT>
+<DD>ATA and SATA drives need atapicam running.</DD>
+<DD>libcam has to be installed.</DD>
+<DT>or Solaris (with libc, of course) :</DT>
+<DD>Tested on kernel 5.11, hopefully suitable for older ones too.</DD>
 <DT>libpthread</DT>
 <DD>is supposed to be a standard system component.</DD>
 </DL>
@@ -56,14 +65,18 @@ and to MMC-5 for DVD).
 GPL software included:<BR>
 </H2>
 <DL>
-<DT>libburn-0.3.4</DT>
-<DD>(by Derek Foreman, Ben Jansens, and team of libburnia.pykix.org)</DD>
-<DD>transfers data to CD</DD>
+<DT>libburn-1.1.8</DT>
+<DD>(founded by Derek Foreman and Ben Jansens,
+developed and maintained since August 2006 by
+Thomas Schmitt from team of libburnia-project.org)
+</DD>
+<DD>transfers data to CD, DVD, BD</DD>
 </DL>
 </P>
 
 <P>
-This program system has been tested on Intel/AMD Linux systems only.<BR>
+This program system has been tested on Intel/AMD with Linux, FreeBSD,
+and OpenSolaris based operating systems.<BR>
 Ports to other usable systems are appreciated. Reports are welcome.
 </P>
 
@@ -81,37 +94,33 @@ Ports to other usable systems are appreciated. Reports are welcome.
 <P>
 <H2>Commands:</H2>
 <DL>
-<DT>The goal is to provide some of cdrecord's options in a compatible way.
-This has been achieved quite sufficiently for the needs of backup tool
-<A HREF="http://scdbackup.sourceforge.net/main_eng.html">scdbackup</A>
-and for data CD projects of <A HREF="http://www.k3b.org">K3b</A> 
-(see <A HREF="#examples">examples</A>).
-Suitability for audio CD frontends has been improved much and is now being
-evaluated.<BR>
-Most DVD types are written in pseudo -tao modes which are very different
-from the write mode DAO used by cdrecord(-ProDVD). With DVD-R[W] cdrskin
-can use this write mode, too.<BR>
-Further enhancements depend on people who can describe and discuss their
-wishes as well as on the development of libburn.</DT>
+<DT>The most common options of cdrecord for data and audio on CD media
+are provided in a compatible way.<BR>
+On all DVD media, cdrskin is able to perform any recording job
+which is possible with cdrecord.
+Other than with cdrecord, option -multi is supported with many DVD types and
+BD-R. Write mode -tao works with anything but quickly blanked DVD-RW and
+DVD-R DL, which both support no -multi.
+</DT>
 <BR><BR>
 <DT>Get an overview of drives and their addresses</DT>
 <DD>#<KBD>&nbsp;cdrskin -scanbus</KBD></DD>
 <DD>#<KBD>&nbsp;cdrskin dev=ATA -scanbus</KBD></DD>
 <DD>#<KBD>&nbsp;cdrskin --devices</KBD></DD>
-<DT>Being superuser avoids permission problems with /dev/sgN resp. /dev/hdX .
+<DT>Being superuser avoids permission problems with /dev/srN resp. /dev/hdX .
 </DT>
-<DT>Ordinary users should then get granted rw access to the /dev files
-as listed by option --devices.</DT>
+<DT>Ordinary users should then get granted access to the /dev files
+as listed by option --devices. Linux and FreeBSD demand rw-permission.
+On Solaris it is r-permission and privileges "basic,sys_devices".</DT>
 <DT>&nbsp;</DT>
 
 <DT>Get info about a particular drive or loaded media:</DT>
 <DD>$<KBD>&nbsp;cdrskin dev=0,1,0 -checkdrive</KBD></DD>
 <DD>$<KBD>&nbsp;cdrskin dev=ATA:1,0,0 -v -atip</KBD></DD>
-<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -toc</KBD></DD>
+<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -minfo</KBD></DD>
 
-<DT>Make used CD-RW or used unformatted DVD-RW writable again:</DT>
-<DD>$<KBD>&nbsp;cdrskin -v dev=/dev/sg1 blank=fast -eject</KBD></DD>
-<DD>$<KBD>&nbsp;cdrskin -v dev=/dev/dvd blank=all -eject</KBD></DD>
+<DT>Prepare CD-RW or DVD-RW for re-use, DVD-RAM or BD-RE for first use:</DT>
+<DD>$<KBD>&nbsp;cdrskin -v dev=/dev/sg1 blank=as_needed -eject</KBD></DD>
 
 <DT>Format DVD-RW to avoid need for blanking before re-use:</DT>
 <DD>$<KBD>&nbsp;cdrskin -v dev=/dev/sr0 blank=format_overwrite</KBD></DD>
@@ -122,31 +131,35 @@ as listed by option --devices.</DT>
 <DT>Write ISO-9660 filesystem image as only one to blank or formatted media:
 </DT>
 <DD>$<KBD>&nbsp;cdrskin -v dev=/dev/hdc speed=12 fs=8m \</KBD></DD>
-<DD><KBD>&nbsp;&nbsp;-sao -eject padsize=300k my_image.iso</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;blank=as_needed -eject padsize=300k my_image.iso</KBD></DD>
 
-<DT>Write compressed afio archive on-the-fly:</DT>
+<DT>Write compressed afio archive on-the-fly
+(not DVD-R DL or minimally blanked DVD-RW):</DT>
 <DD>$<KBD>&nbsp;find . | afio -oZ - | \</KBD></DD>
 <DD><KBD>&nbsp;&nbsp;cdrskin -v dev=0,1,0 fs=32m speed=8 \</KBD></DD>
-<DD><KBD>&nbsp;&nbsp;-tao padsize=300k -</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;blank=as_needed padsize=300k -</KBD></DD>
 
-<DT>Write several sessions to the same CD, DVD-R[W] or DVD+R:</DT>
-<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -v padsize=300k -multi -tao 1.iso</KBD>
+<DT>Write several sessions to the same CD, DVD-R[W] or DVD+R[/DL]:</DT>
+<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -v padsize=300k -multi 1.iso</KBD>
 </DD>
-<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -v padsize=300k -multi -tao 2.iso</KBD>
+<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -v padsize=300k -multi 2.iso</KBD>
 </DD>
-<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -v padsize=300k -multi -tao 3.iso</KBD>
+<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -v padsize=300k -multi 3.iso</KBD>
 </DD>
-<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -v padsize=300k -tao 4.iso</KBD></DD>
+<DD>$<KBD>&nbsp;cdrskin dev=/dev/hdc -v padsize=300k 4.iso</KBD></DD>
 
 <DT>Get multi-session info for option -C of program mkisofs:</DT>
 <DD>$<KBD>&nbsp;c_values=$(cdrskin dev=/dev/sr0 -msinfo 2>/dev/null)</KBD></DD>
 <DD>$<KBD>&nbsp;mkisofs ... -C "$c_values" ...</KBD></DD>
 
-<DT>Inquire free space on media for a -tao -multi run:</DT>
-<DD>$<KBD>&nbsp;x=$(cdrskin dev=/dev/sr0 -tao -multi \</KBD></DD>
+<DT>Inquire free space on media for a -multi run:</DT>
+<DD>$<KBD>&nbsp;x=$(cdrskin dev=/dev/sr0 -multi \</KBD></DD>
 <DD><KBD>&nbsp;&nbsp;--tell_media_space 2>/dev/null)</KBD></DD>
 <DD>$<KBD>&nbsp;echo "Available: $x blocks of 2048 data bytes"</KBD></DD>
 
+<DT>Accelerate BD-RE writing to full nominal speed after the first 250 MB</DT>
+<DD>$<KBD>&nbsp;cdrskin ... stream_recording=250m ...</KBD>
+
 <DT>Write audio tracks to CD:</DT>
 <DD>$<KBD>&nbsp;cdrskin -v dev=ATA:1,0,0 speed=48 -sao \</KBD></DD>
 <DD><KBD>&nbsp;&nbsp;track1.wav track2.au -audio -swab track3.raw</KBD></DD>
@@ -160,7 +173,6 @@ as listed by option --devices.</DT>
 <DT>Read the detailed manual page:</DT>
 <DD>$<KBD>&nbsp;<A HREF="man_1_cdrskin.html">man cdrskin</A></KBD></DD>
 </DL>
-
 <DL>
 <DT>Read about the standard for which cdrskin is striving:</DT>
 <DD>$<KBD>&nbsp;
@@ -171,36 +183,58 @@ man cdrecord</A></KBD></DD>
  this "don't bother Joerg" demand.)
 </DD>
 </DL>
+<DL>
+<DT>Learn to know a more versatile way to burn ISO 9660 formatted data</DT>
+<DD>
+Standalone ISO 9660 multi-session CD/DVD/BD tool
+<A HREF="http://scdbackup.sourceforge.net/xorriso_eng.html">xorriso</A>.
+</DD>
+</DL>
+
 </P>
 
 <HR>
 
+<A NAME="download"></A>
+
 <P>
 <DL>
 <DT>Download as source code (see README):</DT>
-<DD><A HREF="cdrskin-0.3.4.pl00.tar.gz">cdrskin-0.3.4.pl00.tar.gz</A>
-(590 KB).
+<DD><A HREF="cdrskin-1.1.8.tar.gz">cdrskin-1.1.8.tar.gz</A>
+(870 KB).
+</DD>
+<DD><A HREF="cdrskin-1.1.8.tar.gz.sig">cdrskin-1.1.8.tar.gz.sig</A></DD>
+<DD>
+(detached GPG signature for verification by
+<KBD>gpg --verify cdrskin-1.1.8.tar.gz.sig cdrskin-1.1.8.tar.gz</KBD>
+<BR>
+after <KBD>gpg --keyserver keys.gnupg.net --recv-keys ABC0A854</KBD>).
 </DD>
 <DD>
-The "stable" cdrskin tarballs are source code identical with "stable" 
-libburn releases or with "stabilized" libburn SVN snapshots. They get
-produced via a different procedure, though.<BR>
+The cdrskin tarballs are source code identical with libburn releases
+of the same version number.
+They get produced via a different procedure, though.<BR>
 cdrskin is part of libburn - full libburn is provided with cdrskin releases.
 </DD>
+
+<!-- This is not offered any more since spring 2008
 <DD>&nbsp;</DD>
 <DT>Download as single x86 binaries (untar and move to /usr/bin/cdrskin):</DT>
-<DD><A HREF="cdrskin_0.3.4.pl00-x86-suse9_0.tar.gz">
-cdrskin_0.3.4.pl00-x86-suse9_0.tar.gz</A>, (85 KB),
+<DD><A HREF="cdrskin_0.4.2.pl00-x86-suse9_0.tar.gz">
+cdrskin_0.4.2.pl00-x86-suse9_0.tar.gz</A>, (110 KB),
 <DL>
 <DD>runs on SuSE 9.0 (2.4.21) , RIP-14.4 (2.6.14) ,
  Gentoo (2.6.15 x86_64 Athlon).</DD>
 </DL>
-<DD><A HREF="cdrskin_0.3.4.pl00-x86-suse9_0-static.tar.gz">
-cdrskin_0.3.4.pl00-x86-suse9_0-static.tar.gz</A>, (285 KB), -static compiled,
+<DD><A HREF="cdrskin_0.4.2.pl00-x86-suse9_0-static.tar.gz">
+cdrskin_0.4.2.pl00-x86-suse9_0-static.tar.gz</A>, (310 KB), -static compiled,
 <DL>
 <DD>runs on SuSE 7.2 (2.4.4), and on the systems above.</DD>
 </DL>
 </DD>
+-->
+
+
 </DL>
 <DL><DT>Documentation:</DT>
 <DD><A HREF="README_cdrskin">README</A> an introduction</DD>
@@ -223,47 +257,64 @@ cdrskin_0.3.4.pl00-x86-suse9_0-static.tar.gz</A>, (285 KB), -static compiled,
 <HR>
 
 <P>
-Enhancements towards previous stable version cdrskin-0.3.2:
+Enhancements towards previous stable version cdrskin-1.1.6:
 <UL>
-<LI>Multi-session burning to DVD+R</LI>
-<LI>New option --tell_media_space tells the maximum size for the next burn</LI>
-<LI>New option assert_write_lba=0 prevents inadverted writing to appendable
-media</LI>
-<LI>Bug fix: Multi-track runs with fifo could stall in rare cases</LI>
-</UL>
-
+<LI>
+Avoiding to intermediately close and open drive device file
+</LI>
+<LI>
+Enabled recognition of QEMU DVD-ROM 0.12
+</LI>
 <!--
- Bug fixes towards cdrskin-0.3.4.pl00:
-<UL>
-<LI>none yet</LI>
-</UL>
+<LI>none</LI>
 -->
+</UL>
 
-</P>
+Bug fixes towards cdrskin-1.1.6:
+<UL>
+<LI>
+Misinterpreted mode page 2A if block descriptors are present
+</LI>
+<!--
+<LI>none</LI>
+-->
+</UL>
 
 <HR>
 
 <P>
 <DL>
-<DT><H3>Development snapshot, version 0.3.5 :</H3></DT>
-<DD>Enhancements towards stable version 0.3.4.pl00:
+<DT><H3>Development snapshot, version 1.1.9 :</H3></DT>
+<DD>Enhancements towards current stable version 1.1.8:
 <UL>
-<LI>Usage of /dev/srN rather than /dev/sgN on Linux >= 2.6</LI>
-<LI>Option drive_scsi_dev_family=sr|scd|sg to select explicitely</LI>
-<LI>Option -isosize is supported now</LI>
+<LI>none yet</LI>
+<!--
+<LI>none yet</LI>
+-->
+
 </UL>
 </DD>
+
+<DD>Bug fixes towards cdrskin-1.1.8:
+<UL>
+<LI>none yet</LI>
+<!--
+<LI>none yet</LI>
+-->
+</UL>
+</DD>
+
 <DD>&nbsp;</DD>
-<DD><A HREF="README_cdrskin_devel">README 0.3.5</A>
-<DD><A HREF="cdrskin__help_devel">cdrskin_0.3.5 --help</A></DD>
-<DD><A HREF="cdrskin_help_devel">cdrskin_0.3.5 -help</A></DD>
-<DD><A HREF="man_1_cdrskin_devel.html">man cdrskin (as of 0.3.5)</A></DD>
+<DD><A HREF="README_cdrskin_devel">README 1.1.9</A>
+<DD><A HREF="cdrskin__help_devel">cdrskin-1.1.9 --help</A></DD>
+<DD><A HREF="cdrskin_help_devel">cdrskin-1.1.9 -help</A></DD>
+<DD><A HREF="man_1_cdrskin_devel.html">man cdrskin (as of 1.1.9)</A></DD>
 <DD>&nbsp;</DD>
 <DT>Maintainers of cdrskin unstable packages please use SVN of
-<A HREF="http://libburnia.pykix.org"> libburnia.pykix.org</A></DT>
-<DD>Download: <KBD><B>svn co http://libburnia-svn.pykix.org/libburn/trunk libburn_pykix</B>
+<A HREF="http://libburnia-project.org"> libburnia-project.org</A></DT>
+<DD>Download: <KBD><B>svn co http://svn.libburnia-project.org/libburn/trunk libburn</B>
 </KBD></DD>
-<DD>Build: <KBD><B>cd libburn_pykix ; ./bootstrap ; ./configure ; make</B>
+<DD>Build: <KBD><B>cd libburn ; ./bootstrap ; ./configure --prefix /usr ; make ; cdrskin/compile_cdrskin.sh</B>
 </KBD></DD>
 <DD>Build of SVN versions needs <A HREF="http://sources.redhat.com/autobook/">
 autotools</A> of at least version 1.7 installed.
@@ -271,22 +322,29 @@ But after the run of <KBD>./bootstrap</KBD>, only
 vanilla tools like make and gcc are needed.</DD>
 </DD>
 <DD>&nbsp;</DD>
-<DT>The following downloads are intended for adventurous end users or
+<DT>The following download is intended for adventurous end users or
 admins with full system souvereignty.</DT>
 <DD>Source (./bootstrap is already applied, build tested, for more see
 <A HREF="README_cdrskin_devel">upcoming README</A> ):
 </DD>
 <DD>
-<A HREF="cdrskin-0.3.5.tar.gz">cdrskin-0.3.5.tar.gz</A>
-(590 KB).
+<A HREF="cdrskin-1.1.9.tar.gz">cdrskin-1.1.9.tar.gz</A>
+(870 KB).
 </DD>
+
+<!-- This is not offered any more since spring 2008
+
+<DT>The following downloads are intended for adventurous end users or
+admins with full system souvereignty.</DT>
 <DD>Binary (untar and move to /usr/bin/cdrskin):</DD>
-<DD><A HREF="cdrskin_0.3.5-x86-suse9_0.tar.gz">
-cdrskin_0.3.5-x86-suse9_0.tar.gz</A>, (85 KB).
+<DD><A HREF="cdrskin_0.4.3-x86-suse9_0.tar.gz">
+cdrskin_0.4.3-x86-suse9_0.tar.gz</A>, (110 KB).
 </DD>
-<DD><A HREF="cdrskin_0.3.5-x86-suse9_0-static.tar.gz">
-cdrskin_0.3.5-x86-suse9_0-static.tar.gz</A>, (285 KB)
+<DD><A HREF="cdrskin_0.4.3-x86-suse9_0-static.tar.gz">
+cdrskin_0.4.3-x86-suse9_0-static.tar.gz</A>, (310 KB)
 </DD>
+-->
+
 </DL>
 </P>
 
@@ -304,7 +362,7 @@ Historic versions based on Derek's and Ben's
 <BR>
 Very special thanks to Andy Polyakov whose 
 <A HREF="http://fy.chalmers.se/~appro/linux/DVD+RW/tools">dvd+rw-tools</A>
-provide libburn with invaluable examples on how to deal with DVD media.
+provide libburn with invaluable examples on how to deal with DVD and BD media.
 </P>
 
 <HR>
@@ -312,14 +370,33 @@ provide libburn with invaluable examples on how to deal with DVD media.
 <A NAME="examples">
 <P>
 <DL>
-<DT>Example for a setup of device permissions. To be done by the superuser:</DT>
-<DT>(CD devices which offer no r-permission are invisible to normal users.)</DT>
-<DT>(CD devices which offer no w-permission are not useable.)</DT>
+<DT>Example for a setup of device permissions.</DT>
+<DT>
+Newer Linux distros enable rw-access for the desktop user automatically.
+So try as normal user whether all your drives are found.
+CD devices which offer no rw-permission will stay invisible.
+</DT>
+<DD>$ <KBD><B>cdrskin --devices</B></KBD></DD>
+<DT>If not all desired drives show up, become superuser and do again:</DT>
+</DT>
 <DD># <KBD><B>cdrskin --devices</B></KBD></DD>
 <DD><KBD>...</KBD></DD>
-<DD><KBD>0&nbsp; dev='/dev/sg0'&nbsp; rwrwr- :&nbsp; 'TEAC'  'CD-ROM CD-532S'</KBD></DD>
+<DD><KBD>0&nbsp; dev='/dev/sr0'&nbsp; rwr-r- :&nbsp; 'TEAC'  'CD-ROM CD-532S'</KBD></DD>
 <DD><KBD>1&nbsp; dev='/dev/hdc'&nbsp; rwrw-- :&nbsp; 'LITE-ON'  'LTR-48125S'</KBD></DD>
-<DD># <KBD><B>chmod a+rw /dev/sg0 /dev/hdc</B></KBD></DD>
+<DT>Most simple and most insecure is this equivalent
+of the usual cdrecord permissions u+s,a+x:</DT>
+<DD># <KBD><B>chmod a+rw /dev/sr0 /dev/hdc</B></KBD></DD>
+<DT>
+More secure is to put the permitted users into a group like
+"floppy", to assign /dev/sr0 /dev/hdc to this group,
+and to allow rw-access only to group members.
+</DT>
+<DD># <KBD><B>vi /etc/group</B></KBD></DD>
+<DD><KBD>...</KBD></DD>
+<DD><KBD>floppy:x:19:thomas,scdbackup</KBD></DD>
+<DD><KBD>...</KBD></DD>
+<DD># <KBD><B>chgrp floppy /dev/sr0 /dev/hdc</B></KBD></DD>
+<DD># <KBD><B>chmod g+rw /dev/sr0 /dev/hdc</B></KBD></DD>
 </DL>
 </P>
 
@@ -334,6 +411,8 @@ Example how to setup K3b to use cdrskin for burning data CD projects.
 is a GUI frontend which uses cdrecord for CD burning.)
 </P>
 
+<!--
+
 <HR>
 
 <A NAME="scdbackup">
@@ -356,7 +435,7 @@ is a GUI frontend which uses cdrecord for CD burning.)
 <DD>$ <KBD><B>export SCDBACKUP_USE_CDRSKIN=1</B></KBD></DD>
 <DD>$ <KBD><B>./CONFIGURE_CD</B></KBD></DD>
 <DD><KBD>...</KBD></DD>
-<DD><KBD>cdrskin 0.3.4 : limited cdrecord compatibility wrapper for libburn</KBD></DD>
+<DD><KBD>cdrskin 0.3.8 : limited cdrecord compatibility wrapper for libburn</KBD></DD>
 </DL>
 If your system is stricken with some ill CD device then this can stall
 and you will have to press <KBD>Ctrl+C</KBD> to abort.
@@ -388,6 +467,8 @@ and try again.
 </DL>
 </P>
 
+-->
+
 <HR>
 
 <A NAME="cdrecord">
@@ -397,10 +478,11 @@ First of all: this relationship is single sided, as cdrskin has to be aware of
 cdrecord but not vice versa.
 <BR>
 <BR>
-I am a long time user of cdrecord and it works fine for me. 
+I was a long time user of cdrecord and it worked fine for me. 
 Especially i do appreciate its write mode -tao which allows to pipe arbitrary
 data on CD and CD-RW via stdin. cdrecord is reliable, versatile and well
-maintained. So for me - there would be not problem with it.
+maintained. So for me - there would be no problem with using it for
+burning CDs.
 <BR>
 But the author of cdrecord and the Linux kernel people foster a very hostile 
 relationship. Ok, that's their business, not mine (or ours if you are with me).
@@ -433,7 +515,7 @@ I owe him much. For cdrecord, for mkisofs, for star. Chapeau.
 <BR><BR>
  -->
 <A HREF="http://en.wikipedia.org/wiki/D%C3%B6ner_kebab">
-<IMG SRC="doener_150x200_tr.gif" BORDER=0
+<IMG SRC="doener_150x200_tr.png" BORDER=0
      ALT="cdrskin logo: Doener mit Scharf"></A>
 <BR><BR>
 <FONT SIZE=+0>Enjoying free Open Source hosting by <A HREF="http://www.webframe.org">www.webframe.org</A><BR>
@@ -443,18 +525,34 @@ and by <A HREF="http://sourceforge.net">sourceforge.net</A><BR>
 <A href="http://sourceforge.net">
 <IMG src="sflogo-88-1.png" BORDER="0" ALT="SourceForge Logo"></A>
 <!-- on sourceforge use : <IMG src="http://sourceforge.net/sflogo.php?group_id=16010" width="88" height="31" border="0" alt="SourceForge Logo"></A> -->
+<P>
+Enjoying a FreeBSD shell account with the opportunity to
+build and install cdrskin at<BR>
+<A HREF="http://www.en.free-shells.com.ar">free-shells.com.ar</A>
+</P>
 </FONT></CENTER>
 <HR>
 <DL>
 <DT>Links to my other published software projects :
+<DD><A HREF="http://scdbackup.webframe.org/xorriso_eng.html">
+xorriso, a standalone ISO 9660 multi-session CD/DVD/BD burn tool.
+No mkisofs needed.
+<DL>
+<DD>
+<A HREF="http://scdbackup.sourceforge.net/xorriso_eng.html">
+(a second source of above)</A>
+</DD>
+</DL>
+</DD>
 <DD><A HREF=http://scdbackup.webframe.org/main_eng.html>
 scdbackup, multi volume CD backup</A>
 <DL><DD><A HREF=http://scdbackup.sourceforge.net/main_eng.html> 
-(a second source of above)</A></DL>
-<DD><A HREF=http://stic.webframe.org>Some Tools for Image Collectors</A>
-<DL><DD><A HREF=http://stic.sourceforge.net>(a second source of above)</A></DL>
+(a second source of above)</A></DD></DL></DD>
+<DD><A HREF=http://stic.sourceforge.net>Some Tools for Image Collectors</A>
+</DD>
 <DD><A HREF=http://scdbackup.webframe.org/pppoem>
 pppoem, a DSL throughput monitor (mainly for Linux kernel 2.4)</A>
+</DD>
 </DL>
 <BR><BR>
 Legal statement: This website does not serve any commercial purpose.<BR>

cdrskin/cdrskin_timestamp.h

@@ -1 +1 @@
-#define Cdrskin_timestamP "2007.04.18.103734"
+#define Cdrskin_timestamP "2011.11.20.100001"

cdrskin/cleanup.c

@@ -200,9 +200,10 @@ main()
  Cleanup_set_handlers(&demoapp,(Cleanup_app_handler_T) Demo_app_handler,0);
 
  if(1) { /* change to 0 in order to wait for external signals */
-   char *cpt= NULL,c;
+   char *cpt= NULL, c= ' ';
    printf("Intentionally provoking SIGSEGV ...\n");
    c= *cpt;
+   printf("Strange: The system ignored a SIGSEGV: c= %u\n", (unsigned int) c);
  } else {
    printf("killme: %d\n",getpid());
    sleep(3600);

cdrskin/compile_cdrskin.sh

@@ -1,24 +1,38 @@
 #!/bin/sh
 
 # compile_cdrskin.sh  
-# Copyright 2005 - 2006 Thomas Schmitt, scdbackup@gmx.net, GPL
+# Copyright 2005 - 2011 Thomas Schmitt, scdbackup@gmx.net, GPL
 # to be executed within  ./libburn-*  resp ./cdrskin-*
 
-debug_opts=
+debug_opts="-O2"
 def_opts=
 largefile_opts="-D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1"
-libvers="-DCdrskin_libburn_0_3_5"
-cleanup_src_or_obj="libburn/cleanup.o"
-libdax_msgs_o="libburn/libdax_msgs.o"
-libdax_audioxtr_o="libburn/libdax_audioxtr.o"
+fifo_opts=""
+libvers="-DCdrskin_libburn_1_1_8"
+
+# To be used if Makefile.am uses libburn_libburn_la_CFLAGS
+# burn="libburn/libburn_libburn_la-"
+burn="libburn/"
+
+cleanup_src_or_obj="$burn"cleanup.o
+libdax_msgs_o="$burn"libdax_msgs.o
+libdax_audioxtr_o="$burn"libdax_audioxtr.o
 do_strip=0
 static_opts=
-warn_opts="-Wall"
+warn_opts="-Wall -Wextra -Wno-unused-parameter"
+libcdio=
 fifo_source="cdrskin/cdrfifo.c"
 compile_cdrskin=1
 compile_cdrfifo=0
 compile_dewav=0
 
+libcam=
+os=$(uname -s)
+case $os in
+ *FreeBSD)
+  libcam="-lcam"
+esac
+
 for i in "$@"
 do
   if test "$i" = "-compile_cdrfifo"
@@ -27,34 +41,27 @@ do
   elif test "$i" = "-compile_dewav"
   then
     compile_dewav=1
-  elif test "$i" = "-cvs_A60220"
+  elif test "$i" = "-libburn_1_1_8"
   then
-    libvers="-DCdrskin_libburn_cvs_A60220_tS"
-    libdax_audioxtr_o=
-    libdax_msgs_o="libburn/message.o"
-    cleanup_src_or_obj="-DCleanup_has_no_libburn_os_H cdrskin/cleanup.c"
-  elif test "$i" = "-libburn_0_3_4"
-  then
-    libvers="-DCdrskin_libburn_0_3_4"
-    libdax_audioxtr_o="libburn/libdax_audioxtr.o"
-    libdax_msgs_o="libburn/libdax_msgs.o"
-    cleanup_src_or_obj="libburn/cleanup.o"
+    libvers="-DCdrskin_libburn_1_1_8"
+    libdax_audioxtr_o="$burn"libdax_audioxtr.o
+    libdax_msgs_o="$burn"libdax_msgs.o
+    cleanup_src_or_obj="$burn"cleanup.o
   elif test "$i" = "-libburn_svn"
   then
-    libvers="-DCdrskin_libburn_0_3_5"
-    libdax_audioxtr_o="libburn/libdax_audioxtr.o"
-    libdax_msgs_o="libburn/libdax_msgs.o"
-    cleanup_src_or_obj="libburn/cleanup.o"
+    libvers="-DCdrskin_libburn_1_1_9"
+    libdax_audioxtr_o="$burn"libdax_audioxtr.o
+    libdax_msgs_o="$burn"libdax_msgs.o
+    cleanup_src_or_obj="$burn"cleanup.o
   elif test "$i" = "-newapi" -o "$i" = "-experimental"
   then
     def_opts="$def_opts -DCdrskin_new_api_tesT"
-  elif test "$i" = "-oldfashioned"
-  then
-    def_opts="$def_opts -DCdrskin_oldfashioned_api_usE"
-    cleanup_src_or_obj="-DCleanup_has_no_libburn_os_H cdrskin/cleanup.c"
   elif test "$i" = "-no_largefile"
   then
     largefile_opts=	
+  elif test "$i" = "-dvd_obs_64k"
+  then
+    def_opts="$def_opts -DCdrskin_dvd_obs_default_64K"
   elif test "$i" = "-do_not_compile_cdrskin"
   then
     compile_cdrskin=0
@@ -66,29 +73,43 @@ do
   elif test "$i" = "-do_strip"
   then
     do_strip=1
+  elif test "$i" = "-use_libburn_fifo"
+  then
+    fifo_opts="-DCdrskin_use_libburn_fifO"
+  elif test "$i" = "-use_no_libburn_fifo"
+  then
+    fifo_opts=""
+  elif test "$i" = "-use_no_cdrfifo"
+  then
+    fifo_source=
+    fifo_opts="-DCdrskin_use_libburn_fifO -DCdrskin_no_cdrfifO"
+  elif test "$i" = "-use_libburn_cleanup"
+  then
+    fifo_source=
+    fifo_opts="-DCdrskin_use_libburn_cleanuP -DCdrskin_use_libburn_fifO -DCdrskin_no_cdrfifO"
+  elif test "$i" = "-use_libcdio"
+  then
+    libcdio="-lcdio"
   elif test "$i" = "-g"
   then
-    debug_opts="$debug_opts -g"
-  elif test "$i" = "-O2"
-  then
-    debug_opts="$debug_opts -O2"
+    debug_opts="-g"
   elif test "$i" = "-help" -o "$i" = "--help" -o "$i" = "-h"
   then
     echo "cdrskin/compile_cdrskin.sh : to be executed within top level directory"
     echo "Options:"
     echo "  -compile_cdrfifo  compile program cdrskin/cdrfifo."
     echo "  -compile_dewav    compile program test/dewav without libburn."
-    echo "  -cvs_A60220       set macro to match libburn-CVS of 20 Feb 2006."
-    echo "  -libburn_0_3_4    set macro to match libburn-0.3.4."
+    echo "  -libburn_1_1_8    set macro to match libburn-1.1.8"
     echo "  -libburn_svn      set macro to match current libburn-SVN."
-    echo "  -no_largefile     do not use 64 bit off_t (must match libburn)."
+    echo "  -dvd_obs_64k      64 KB default size for DVD/BD writing."
+    echo "  -use_libcdio      link with -lcdio because libburn uses it."
     echo "  -do_not_compile_cdrskin  omit compilation of cdrskin/cdrskin."
+    echo "  -use_no_libburn_fifo  use cdrfifo even for single track non-CD"
+    echo "  -use_no_cdrfifo   always use fifo of libburn and never cdrfifo"
     echo "  -experimental     use newly introduced libburn features."
-    echo "  -oldfashioned     use pre-0.2.2 libburn features only."
     echo "  -do_diet          produce capability reduced lean version."
     echo "  -do_strip         apply program strip to compiled programs."
-    echo "  -g                compile with cc option -g."
-    echo "  -O2               compile with cc option -O2."
+    echo "  -g                produce debuggable programm."
     echo "  -static           compile with cc option -static."
     exit 0
   elif test "$i" = "-static"
@@ -104,13 +125,14 @@ echo "Build timestamp   :  $timestamp"
 
 if test "$compile_cdrskin"
 then
-  echo "compiling program cdrskin/cdrskin.c $static_opts $debug_opts $libvers $def_opts $cleanup_src_or_obj"
+  echo "compiling program cdrskin/cdrskin.c $fifo_source $static_opts $debug_opts $libvers $fifo_opts $def_opts $cleanup_src_or_obj $libcdio $libcam"
   cc -I. \
     $warn_opts \
     $static_opts \
     $debug_opts \
     $libvers \
     $largefile_opts \
+    $fifo_opts \
     $def_opts \
     \
     -DCdrskin_build_timestamP='"'"$timestamp"'"' \
@@ -122,31 +144,34 @@ then
     \
     $cleanup_src_or_obj \
     \
-    libburn/async.o \
-    libburn/debug.o \
-    libburn/drive.o \
-    libburn/file.o \
-    libburn/init.o \
-    libburn/options.o \
-    libburn/source.o \
-    libburn/structure.o \
+    "$burn"async.o \
+    "$burn"debug.o \
+    "$burn"drive.o \
+    "$burn"file.o \
+    "$burn"init.o \
+    "$burn"options.o \
+    "$burn"source.o \
+    "$burn"structure.o \
     \
-    libburn/sg.o \
-    libburn/write.o \
+    "$burn"sg.o \
+    "$burn"write.o \
+    "$burn"read.o \
     $libdax_audioxtr_o \
     $libdax_msgs_o \
     \
-    libburn/mmc.o \
-    libburn/sbc.o \
-    libburn/spc.o \
-    libburn/util.o \
+    "$burn"mmc.o \
+    "$burn"sbc.o \
+    "$burn"spc.o \
+    "$burn"util.o \
     \
-    libburn/sector.o \
-    libburn/toc.o \
+    "$burn"sector.o \
+    "$burn"toc.o \
     \
-    libburn/crc.o \
-    libburn/lec.o \
+    "$burn"crc.o \
+    "$burn"ecma130ab.o \
     \
+    $libcdio \
+    $libcam \
     -lpthread
 
     ret=$?
@@ -188,8 +213,8 @@ then
      -DDewav_without_libburN \
      -o test/dewav \
      test/dewav.c \
-     libburn/libdax_audioxtr.o \
-     libburn/libdax_msgs.o \
+     "$burn"libdax_audioxtr.o \
+     "$burn"libdax_msgs.o \
      \
     -lpthread
 

cdrskin/convert_man_to_html.sh

@@ -16,7 +16,7 @@ manpage="cdrskin"
 raw_html=$(pwd)/"cdrskin/raw_man_1_cdrskin.html"
 htmlpage=$(pwd)/"cdrskin/man_1_cdrskin.html"
 
-if test -r "$manpage"
+if test -r "$man_dir"/"$manpage".1
 then
   dummy=dummy
 else
@@ -45,18 +45,21 @@ then
   -e 's/<b>Overview of features:<\/b>/\&nbsp;<BR><b>Overview of features:<\/b>/' \
   -e 's/<b>General information paragraphs:<\/b>/\&nbsp;<BR><b>General information paragraphs:<\/b>/' \
   -e 's/<b>Track recording model:<\/b>/\&nbsp;<BR><b>Track recording model:<\/b>/' \
-  -e 's/In general there are two types of tracks: data and audio./\&nbsp;<BR>In general there are two types of tracks: data and audio./' \
-  -e 's/While audio tracks just contain a given/\&nbsp;<BR>While audio tracks just contain a given/' \
+  -e 's/^In general there are two types of tracks: data and audio./\&nbsp;<BR>In general there are two types of tracks: data and audio./' \
+  -e 's/^While audio tracks just contain a given/\&nbsp;<BR>While audio tracks just contain a given/' \
   -e 's/<b>Write mode selection:<\/b>/\&nbsp;<BR><b>Write mode selection:<\/b>/' \
   -e 's/<b>Recordable CD Media:<\/b>/\&nbsp;<BR><b>Recordable CD Media:<\/b>/' \
   -e 's/<b>Overwriteable DVD Media:<\/b>/\&nbsp;<BR><b>Overwriteable DVD Media:<\/b>/' \
   -e 's/<b>Sequentially Recordable DVD Media:<\/b>/\&nbsp;<BR><b>Sequentially Recordable DVD Media:<\/b>/' \
-  -e 's/The write modes for DVD+R/\&nbsp;<BR>The write modes for DVD+R/' \
+  -e 's/^The write modes for DVD+R/\&nbsp;<BR>The write modes for DVD+R/' \
   -e 's/<b>Drive preparation and addressing:<\/b>/\&nbsp;<BR><b>Drive preparation and addressing:<\/b>/' \
-  -e 's/If you only got one CD capable drive/\&nbsp;<BR>If you only got one CD capable drive/' \
+  -e 's/^If you only got one CD capable drive/\&nbsp;<BR>If you only got one CD capable drive/' \
+  -e 's/<b>Emulated drives:<\/b>/\&nbsp;<BR><b>Emulated drives:<\/b>/' \
   -e 's/^Alphabetical list of options/\&nbsp;<BR>Alphabetical list of options/' \
-  -e 's/and for all others\.<\/td><\/table>/and for all others.<\/td><\/table>  <BR><HR><FONT SIZE=-1><CENTER>(HTML generated from '"$manpage"'.1 on '"$(date)"' by '$(basename "$0")' )<\/CENTER><\/FONT>/' \
+  -e 's/<\/body>/<BR><HR><FONT SIZE=-1><CENTER>(HTML generated from '"$manpage"'.1 on '"$(date)"' by '$(basename "$0")' )<\/CENTER><\/FONT><\/body>/' \
+  -e 's/See section FILES/See section <A HREF="#FILES">FILES<\/A>/' \
   -e 's/See section EXAMPLES/See section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
+  -e 's/&minus;/-/g' \
   <"$2" >"$htmlpage"
 
   set +x

cdrskin/wiki_plain.txt

@@ -1,30 +1,29 @@
 --------------------------------------------------------------------------
                        cdrskin Wiki - plain text copy
 --------------------------------------------------------------------------
-[[Image(source:/libburn/trunk/cdrskin/doener_150x200_tr.gif)]] [http://en.wikipedia.org/wiki/D%C3%B6ner_kebab Doener]
+[[Image(source:/libburn/trunk/cdrskin/doener_150x200_tr.png)]] [http://en.wikipedia.org/wiki/D%C3%B6ner_kebab Doener]
 
 '''cdrskin is the cdrecord compatibility middleware of libburn.'''
 
 Its paragon, cdrecord, is a powerful GPL'ed burn program included in Joerg
 Schilling's cdrtools. cdrskin strives to be a second source for the services
 traditionally provided by cdrecord. Currently it does CD-R and CD-RW this way.
-Overwriteable media DVD-RAM, DVD+RW and DVD-RW are handled differently than 
-with cdrecord-ProDVD in order to offer TAO-like single track recording.
-Sequential DVD-R[W] and DVD+R are handled like CD-R[W] with TAO and
-multi-session. Additionally cdrskin offers cdrecord-ProDVD-like mode DAO
+Overwriteable media DVD-RAM, DVD+RW, DVD-RW, and BD-RE are handled differently
+than with cdrecord-ProDVD in order to offer TAO-like single track recording.
+Sequential DVD-R[W], DVD+R, DVD+R DL, BD-R are handled like CD-R[W] with TAO
+and multi-session. Additionally cdrskin offers cdrecord-ProDVD-like mode DAO
 with DVD-R[W].
 
 cdrskin does not contain any bytes copied from cdrecord's sources.
 Many bytes have been copied from the message output of cdrecord
 runs, though. The most comprehensive technical overview of cdrskin
-can be found in [http://libburnia.pykix.org/browser/libburn/trunk/cdrskin/README?format=txt cdrskin/README].
+can be found in [http://libburnia-project.org/browser/libburn/trunk/cdrskin/README?format=txt cdrskin/README].
 
-About libburn API for burning CD: http://libburnia-api.pykix.org
+About libburn API for burning CD and DVD: http://api.libburnia-project.org
 
 --------------------------------------------------------------------------
 
-For dual layer DVD types and for appending sessions to ISO filesystems on
-DVD other than DVD-RW, DVD-R, DVD+R see the advise to use dvd+rw-tools at
+For yet unsupported media types see the advice to use dvd+rw-tools at
 the end of this text.
 
 --------------------------------------------------------------------------
@@ -67,7 +66,7 @@ and displays their detected properties.
 The drives are listed one per line, with fields:
 libburn-drive-number, sysadmin-device-file, permissions, vendor, type
 {{{
-0  dev='/dev/sg0'  rwrw-- :  'HL-DT-ST'  'DVDRAM GSA-4082B'
+0  dev='/dev/sr0'  rwrw-- :  'HL-DT-ST'  'DVDRAM GSA-4082B'
 }}}
 This feature is valuable since cdrskin -scanbus will not give you
 the device file name and its current permissions.
@@ -80,12 +79,58 @@ controls drive accessability by rw-permissions of the drive rather than
 by x-permission of the burn binary. To be usable with cdrskin, the drive
 has to offer both, r- and w-permission.
 
+--------------------------------------------------------------------------
+
+blank=as_needed applies the suitable blanking or formatting to make
+any supported type of media ready for writing from scratch.
+If this is not possible, e.g. because the media is written and not
+re-usable, then the program run fails.
+
+Option blank= offers several specialized blanking and formatting types,
+which one may use for particular purposes on DVD-RW, DVD-RAM and BD-RE.
+(See also below: blank=format_overwrite)
+The drive offers a list of possible formats by cdrskin option --list_formats.
+One should aquire MMC background information before making use of them.
+
+--------------------------------------------------------------------------
+
+cdrskin does not only read from and write to optical drives which comply
+to the MMC standard but also does the same with regular files or block
+devices other than optical drives.
+
+Because the power to alter a disk file might be a bad surprise for a
+traditional user of cdrecord, it is necessary to give option
+--allow_emulated_drives before an emulated drive may be addressed.
+Eventually one of the startup files would be a good place for it.
+See man page, section FILES.
+
+The addresses of emulated drives begin with the prefix "stdio:".
+{{{
+dev=stdio:/tmp/pseudo_drive
+dev=stdio:/dev/usbstick
+}}}
+
+Regular files and block devices behave much like DVD-RAM.
+  
+Other file types may be valid targets for write-only operations.
+This includes standard output, named pipes, character devices
+{{{
+dev=stdio:/dev/fd/1
+dev=stdio:/tmp/named_pipe
+dev=stdio:/dev/ptyxy
+}}}
+
+These files behave much like blank DVD-R.
+
+All files used as pseudo-drives have to offer rw-permission.
+
+
 --------------------------------------------------------------------------
 
 The DVD capabilities of cdrskin differ from those of cdrecord-ProDVD. cdrskin
-offers TAO-like multi-session with DVD-R[W], DVD+R and TAO-like single session
-with overwriteable DVD media. It also offers DAO on DVD-R[W] which is probably
-the same as the traditional cdrecord-ProDVD write mode.
+offers TAO-like multi-session with DVD-R[W], DVD+R[ DL] and TAO-like single
+session with overwriteable DVD media. It also offers DAO on DVD-R[W] which is
+probably the same as the traditional cdrecord-ProDVD write mode.
 
 Non-cdrecord blank mode blank=format_overwrite brings a DVD-RW
 disc from its initial profile "Sequential Recording" into profile state
@@ -94,9 +139,9 @@ disc from its initial profile "Sequential Recording" into profile state
 cdrskin dev=/dev/sr0 -v blank=format_overwrite
 }}}
 
-DVD-RAM, DVD+RW and overwriteable DVD-RW appear to cdrskin as blank media
-which are capable of taking only a single track. This track may be positioned
-on a 32KiB aligned address, though.
+DVD-RAM, DVD+RW, BD-RE and overwriteable DVD-RW appear to cdrskin as blank
+media which are capable of taking only a single track. This track may be
+positioned on a 32KiB aligned address, though.
 {{{
 cdrskin ... write_start_address=2412m ...
 }}}
@@ -107,8 +152,9 @@ multi-session, if the drive is capable of "Incremental Streaming"
 (MMC feature 21h).
 
 Used sequential DVD-RW media may be blanked by blank=fast or blank=all which
-normally both do full blanking.
-
+normally both do full blanking. Thus sequential DVD-RW behave much like large
+CD-RW with possibly more than 99 tracks.
+  
 blank=deformat_sequential does minimal blanking of DVD-RW which usually yields
 media incapable of "Incremental Streaming".
 
@@ -117,6 +163,13 @@ overwriteable DVD-RW which normally ignore those two options. It also makes
 option -multi tolerable with media and write modes which are not suitable for
 multi-session. (The default behavior of cdrskin deems me to be preferrable.)
 
+Option --grow_overwriteable_iso gives cdrskin ISO pseudo-multi-session
+capabilities on DVD-RAM, DVD+RW, BD-RE similar to growisofs.
+Associated options blank=, -multi, -msinfo and -toc are available in this case.
+They either pretend a blank media (if there is no ISO 9660 image) or appendable
+media with a single session and track on it. blank= invalidates ISO images.
+
+
 --------------------------------------------------------------------------
 
 assert_write_lba=<lba> allows to ensure that the start block address which
@@ -127,7 +180,7 @@ E.g. cdrskin aborts with an error message if
 {{{
 assert_write_lba=0
 }}}
-is given but an appendable media is to be burned which would start ati
+is given but an appendable media is to be burned which would start at
 block 68432.
 
 
@@ -228,10 +281,10 @@ for an illustrated example with K3b 0.10 .
 
 DVD advise:
 
-For burning of DVD media other than DVD-RAM, DVD+RW, DVD+R, DVD-RW, DVD-R,
-the cdrskin project currently advises to use Andy Polyakov's dvd+rw-tools
-which despite their historic name are capable of all the media above 
-and also do dual layer and even BD discs. 
+For burning of DVD/BD media other than DVD-RAM, DVD+RW, DVD+R, DVD+R DL,
+DVD-RW, DVD-R, BD-RE, the cdrskin project currently advises to use
+Andy Polyakov's dvd+rw-tools which despite their historic name are
+capable of all the media above and more, including BD discs. 
 
 http://fy.chalmers.se/~appro/linux/DVD+RW/tools
 
@@ -239,19 +292,27 @@ They are not compatible or related to cdrecord resp. cdrecord-ProDVD
 (now obsoleted by original source cdrtools cdrecord with identical
 capabilities besides the license key).
 
+
+--------------------------------------------------------------------------
+
+Advanced multi-session use cases:
+
 A special feature of dvd+rw-tools is growing of ISO-9660 filesystems on
 overwriteable media. This is not the same as multi-session writing of cdrskin
 with CD media, but retrieves additional information from the existing ISO
 image and finally manipulates the start sectors of this existing image.
-So for growable ISO filesystems on DVD-RAM or DVD+RW growisofs is the only
-choice, currently.
 
+So, inspired by growisofs, cdrskin can offer DVD multi-session not only with
+sequential DVD-R[W] and with DVD+R [DL], but also with DVD-RAM, DVD+RW, BD-RE
+and even regular disk files or block devices other than CD/DVD writers.
+This is enabled by option --grow_overwriteable_iso.
 
-cdrskin can offer DVD multi-session only with sequential DVD-R[W] and with
-DVD+R.
-Associated options blank=, -multi, -msinfo and -toc are available in this case.
-Thus sequential DVD-RW behave much like large CD-RW with possibly more than 99
-tracks.
+The libburnia project provides an integrated ISO-9660 multi-session tool
+named [wiki:Xorriso xorriso] which tries to go one step beyond
+growisofs. It uses  [wiki:Libburn libburn] , [wiki:Libisofs libisofs]
+and [wiki:Libisoburn libisoburn].
+
+See [http://scdbackup.sourceforge.net/man_1_xorriso.html man xorriso].
 
 --------------------------------------------------------------------------
 

configure.ac

@@ -1,41 +1,145 @@
-AC_INIT([libburn], [0.3.5], [http://libburnia.pykix.org])
+AC_INIT([libburn], [1.1.8], [http://libburnia-project.org])
 AC_PREREQ([2.50])
 dnl AC_CONFIG_HEADER([config.h])	
 
 AC_CANONICAL_HOST
 AC_CANONICAL_TARGET
 
-AM_INIT_AUTOMAKE([subdir-objects])
+LIBBURNIA_SET_FLAGS
 
-dnl Making releases:
-dnl   BURN_MICRO_VERSION += 1;
-dnl   BURN_INTERFACE_AGE += 1;
-dnl   BURN_BINARY_AGE += 1;
-dnl if any functions have been added, set BURN_INTERFACE_AGE to 0.
-dnl if backwards compatibility has been broken,
-dnl set BURN_BINARY_AGE and BURN_INTERFACE_AGE to 0.
+AM_INIT_AUTOMAKE([subdir-objects])
+AC_CONFIG_MACRO_DIR([./])
+
+dnl Notes about version numbers and .so numbers:
 dnl
-dnl if MAJOR or MINOR version changes, be sure to change AC_INIT above to match
+dnl Regrettably the meaning of the various version types was misunderstood
+dnl before version 0.4.1.
 dnl
-BURN_MAJOR_VERSION=0
-BURN_MINOR_VERSION=3
-BURN_MICRO_VERSION=5
-BURN_INTERFACE_AGE=0
-BURN_BINARY_AGE=0
+dnl In the past MAJOR.MINOR.MICRO versions led to the following SONAME numbers:
+dnl    0.2.2 = 2 , 0.2.3 = 3 , 0.2.6 = 6
+dnl    0.3.0 = 0 , 0.3.2 = 2 , 0.3.4 = 4 . 0.3.6 = 6 , 0.3.8 = 4
+dnl    0.4.0 = 0 (also released as SONAME 4)
+dnl
+dnl Meanwhile the following schemes are maintained in parallel:
+dnl
+dnl BURN_MAJOR_VERSION , BURN_MINOR_VERSION , BURN_MICRO_VERSION 
+dnl    are three small non-negative integers which describe the evolution
+dnl    steps of the library.
+dnl    Older applications are able to use younger libraries over
+dnl    quite a long range of such steps. Some day, nevertheless,
+dnl    compatibility might get terminated, after due notice.
+dnl
+dnl SONAME (libburn.so.4)
+dnl    is a small positive integer which marks a family of compatible
+dnl    evolution steps. Libraries with a particular SONAME allow a binary
+dnl    with the same SONAME to start up. Any further compatibility check is to
+dnl    be done by own runtime means. Especially  *_version() calls in the API
+dnl    which return BURN_MAJOR_VERSION, BURN_MINOR_VERSION, BURN_MICRO_VERSION.
+dnl    See below.
+dnl
+dnl CURRENT, AGE, REVISION
+dnl    are three integers used by libtool. CURRENT is positive, the others
+dnl    non-negative. The use at runtime is not known yet. But libtool computes
+dnl    at build time  SONAME = CURRENT - AGE.
+dnl    So this is a superspace of the SONAME version space. To avoid
+dnl    ill SONAME, the value of  CURRENT must be larger than AGE.
+dnl    See also http://www.gnu.org/software/libtool/manual.html#Interfaces
+dnl
+dnl On Linux the name of the dynamic library will be
+dnl    libburn.so.$SONAME.$AGE.$REV
+dnl In the terminology of this file:
+dnl    CURRENT = LT_CURRENT
+dnl    AGE     = LT_AGE
+dnl    REVISION= LT_REVISION
+dnl
+dnl Beginning with libburn-0.4.1 a rectified counting was introduced as
+dnl    CURRENT=10, REVISION=1, AGE=6
+dnl This rectification declared that version to be binary compatible up
+dnl from libburn-0.3.4.
+dnl Real compatibility was given since libburn-0.3.2.
+dnl Beware of libburn-0.2.6 which had SONAME=6 and is not binary compatible.
+dnl Applications for libburn-0.2 to libburn-0.3.1 need recompilation but no
+dnl source code changes.
+dnl
+dnl Neatly versioned stable releases meanwhile:
+dnl    0.4.2 = libburn.so.4.7.0
+dnl    0.4.4 = libburn.so.4.9.0
+dnl    0.4.6 = libburn.so.4.11.0
+dnl    0.4.8 = libburn.so.4.13.0
+dnl    0.5.0 = libburn.so.4.15.0
+dnl    0.5.2 = libburn.so.4.17.0
+dnl    0.5.4 = libburn.so.4.19.0
+dnl    0.5.6 = libburn.so.4.21.0
+dnl    0.5.8 = libburn.so.4.23.0
+dnl    0.6.0 = libburn.so.4.25.0
+dnl    0.6.2 = libburn.so.4.27.0
+dnl    0.6.4 = libburn.so.4.29.0
+dnl    0.6.6 = libburn.so.4.31.0
+dnl    0.6.8 = libburn.so.4.33.0
+dnl    0.7.0 = libburn.so.4.35.0
+dnl    0.7.2 = libburn.so.4.37.0
+dnl    0.7.4 = libburn.so.4.39.0
+dnl    0.7.6 = libburn.so.4.41.0
+dnl    0.7.8 = libburn.so.4.43.0
+dnl    0.8.0 = libburn.so.4.45.0
+dnl    0.8.2 = libburn.so.4.47.0
+dnl    0.8.4 = libburn.so.4.49.0
+dnl    0.8.6 = libburn.so.4.51.0
+dnl    0.8.8 = libburn.so.4.53.0
+dnl    0.9.0 = libburn.so.4.55.0
+dnl    1.0.0 = libburn.so.4.57.0
+dnl    1.0.2 = libburn.so.4.59.0
+dnl    1.0.4 = libburn.so.4.61.0
+dnl    1.0.6 = libburn.so.4.63.0
+dnl    1.1.0 = libburn.so.4.65.0
+dnl    1.1.4 = libburn.so.4.67.0
+dnl    1.1.6 = libburn.so.4.69.0
+dnl    1.1.8 = libburn.so.4.71.0
+dnl
+dnl So LT_CURRENT, LT_REVISION and LT_AGE get set directly here.
+dnl SONAME of the emerging library is  LT_CURRENT - LT_AGE.
+dnl The linker will do no finer checks. Especially no age range check for
+dnl the application binary. If SONAME matches, then the couple starts.
+dnl 
+dnl Therefore at run time info is provided by libburn function burn_version().
+dnl It returns the major, minor and micro revision of the library.
+dnl Before using any API feature, a program should check for age.
+dnl
+dnl The variables BURN_*_VERSION are mere copies for informing libtool.
+dnl The true values which get issued and should be compared are macros
+dnl defined in libburn/libburn.h .
+dnl
+dnl Normally one can allow a program to run with a library which passed the
+dnl linker SONAME test and which is not older than the library it was
+dnl developed for. Library2 is younger than library1 if:
+dnl   major2>major1 || (major2==major1 &&
+dnl                     (minor2>minor1 || (minor2==minor1 && micro2 > micro1)))
+dnl
+dnl If BURN_*_VERSION changes, be sure to change AC_INIT above to match.
+dnl
+dnl As said: Only copies. Original in libburn/libburn.h : burn_header_version_*
+BURN_MAJOR_VERSION=1
+BURN_MINOR_VERSION=1
+BURN_MICRO_VERSION=8
 BURN_VERSION=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION.$BURN_MICRO_VERSION
 
 AC_SUBST(BURN_MAJOR_VERSION)
 AC_SUBST(BURN_MINOR_VERSION)
 AC_SUBST(BURN_MICRO_VERSION)
-AC_SUBST(BURN_INTERFACE_AGE)
-AC_SUBST(BURN_BINARY_AGE)
 AC_SUBST(BURN_VERSION)
 
 dnl Libtool versioning
-LT_RELEASE=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION
-LT_CURRENT=`expr $BURN_MICRO_VERSION - $BURN_INTERFACE_AGE`
-LT_REVISION=$BURN_INTERFACE_AGE
-LT_AGE=`expr $BURN_BINARY_AGE - $BURN_INTERFACE_AGE`
+LT_RELEASE=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION.$BURN_MICRO_VERSION
+dnl
+dnl This is the release version libburn-1.1.8
+dnl ### This is the development version after above release version
+dnl LT_CURRENT++, LT_AGE++ has not yet happened.
+dnl ### LT_CURRENT++, LT_AGE++ has happened meanwhile.
+dnl
+dnl SONAME = 75 - 71 = 4 . Linux library name = libburn.so.4.71.0
+LT_CURRENT=75
+LT_AGE=71
+LT_REVISION=0
 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
 
 AC_SUBST(LT_RELEASE)
@@ -44,6 +148,12 @@ AC_SUBST(LT_REVISION)
 AC_SUBST(LT_AGE)
 AC_SUBST(LT_CURRENT_MINUS_AGE)
 
+dnl ts A71207: This is done only not to break any old components
+BURN_INTERFACE_AGE=$LT_REVISION
+BURN_BINARY_AGE=`expr $LT_AGE + $BURN_INTERFACE_AGE`
+AC_SUBST(BURN_INTERFACE_AGE)
+AC_SUBST(BURN_BINARY_AGE)
+
 AC_PREFIX_DEFAULT([/usr/local])
 test "$prefix" = "NONE" && prefix=$ac_default_prefix
 
@@ -75,8 +185,108 @@ AC_SUBST(THREAD_LIBS)
 
 TARGET_SHIZZLE
 AC_SUBST(ARCH)
+AC_SUBST(LIBBURNIA_PKGCONFDIR)
 AC_SUBST(LIBBURN_ARCH_LIBS)
 
+dnl ts A90303
+dnl Check the preconditions for using statvfs() in sg-dummy
+dnl (sg-linux and sg-freebsd use statvfs() unconditionally)
+STATVFS_DEF=-DLibburn_os_has_statvfS
+AC_CHECK_HEADER(sys/statvfs.h, X=, STATVFS_DEF=)
+AC_CHECK_FUNC([statvfs], X=, STATVFS_DEF=)
+dnl If this would be done more specifically in Makefile.am
+dnl via libburn_libburn_la_CFLAGS then undesired .o file names would emerge
+CFLAGS="$STATVFS_DEF $CFLAGS"
+
+dnl ts A91122
+AC_ARG_ENABLE(track-src-odirect,
+[  --enable-track-src-odirect Enable use of O_DIRECT with track input, default=no],
+               , enable_track_src_odirect=no)
+if test x$enable_track_src_odirect = xyes; then
+    LIBBURN_O_DIRECT_DEF="-DLibburn_read_o_direcT"
+    echo "enabled  use of O_DIRECT with track input"
+else
+    LIBBURN_O_DIRECT_DEF=
+    echo "disabled use of O_DIRECT with track input"
+fi
+dnl Avoid the need for libburn_libburn_la_CFLAGS in Makefile.am (ugly .o names)
+dnl ### AC_SUBST(LIBBURN_O_DIRECT_DEF)
+CFLAGS="$LIBBURN_O_DIRECT_DEF $CFLAGS"
+
+dnl ts A91116
+AC_ARG_ENABLE(dvd-obs-64k,
+[  --enable-dvd-obs-64k    64 KB default size for DVD/BD writing, default=no],
+               , enable_dvd_obs_64k=no)
+if test x$enable_dvd_obs_64k = xyes; then
+    LIBBURN_DVD_OBS_64K="-DLibburn_dvd_obs_default_64K"
+    echo "enabled  write size default 64 KB on DVD and BD"
+else
+    LIBBURN_DVD_OBS_64K=
+    echo "disabled write size default 64 KB on DVD and BD"
+fi
+CFLAGS="$LIBBURN_DVD_OBS_64K $CFLAGS"
+
+dnl ts A91218
+AC_ARG_ENABLE(libcdio,
+[  --enable-libcdio        Enable EXPERIMENTAL use of libcdio as system adapter, default=no],
+               , enable_libcdio=no)
+if test x$enable_libcdio = xyes; then
+dnl Check whether there is libcdio-devel and libcdio-runtime.
+dnl If not, erase this macro
+    LIBCDIO_DEF="-DLibburn_use_libcdiO" 
+dnl The empty yes case obviously causes -lcdio to be linked
+    AC_CHECK_HEADER(cdio/cdio.h, AC_CHECK_LIB(cdio, mmc_last_cmd_sense, , LIBCDIO_DEF= ), LIBCDIO_DEF= )
+else
+    LIBCDIO_DEF=
+fi
+if test x$LIBCDIO_DEF = x
+then
+    if test x$enable_libcdio = xyes
+    then
+      echo "WARNING: could not enable use of libcdio as system adapter"
+    fi
+else
+    echo "enabled  EXPERIMENTAL use of libcdio as system adapter"
+    CFLAGS="$LIBCDIO_DEF $CFLAGS"
+
+    LIBCDIO_REQUIRED=0.83
+    PKG_CHECK_MODULES(LIBCDIO, libcdio >= $LIBCDIO_REQUIRED)
+
+fi
+
+dnl ts B00704
+# Library versioning normally serves a complex purpose.
+# Since libburn obeys strict ABI backward compatibility, it needs only the
+# simple feature to declare function names "global:" or "local:". Only the
+# global ones are visible to applications at library load time.
+AC_ARG_ENABLE(versioned-libs,
+[  --enable-versioned-libs Enable strict symbol encapsulation , default=yes],
+               , enable_versioned_libs=yes)
+if test x$enable_versioned_libs = xyes; then
+    vers_libs_test=no
+    LIBBURN_ASSERT_VERS_LIBS
+    if test x$vers_libs_test = xno
+    then 
+        echo "disabled strict symbol encapsulation (test failed)"
+    else
+        echo "enabled  strict symbol encapsulation"
+    fi
+else
+    echo "disabled strict symbol encapsulation"
+fi
+
+AC_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)
+
+
 dnl Add compiler-specific flags
 
 dnl See if the user wants aggressive optimizations of the code
@@ -85,17 +295,23 @@ AC_ARG_ENABLE(debug,
               , enable_debug=yes)
 if test x$enable_debug != xyes; then
     if test x$GCC = xyes; then
-        CFLAGS="$CFLAGS -O3"
-        CFLAGS="$CFLAGS -fexpensive-optimizations"
+        CFLAGS="-O3 $CFLAGS"
+        CFLAGS="-fexpensive-optimizations $CFLAGS"
     fi
-    CFLAGS="$CFLAGS -DNDEBUG"
+    CFLAGS="-DNDEBUG $CFLAGS"
 else
     if test x$GCC = xyes; then
-        CFLAGS="$CFLAGS -g -pedantic -Wall"
+        CFLAGS="-g -pedantic -Wall -Wextra -Wno-unused-parameter $CFLAGS"
     fi
-    CFLAGS="$CFLAGS -DDEBUG"
+    CFLAGS="-DDEBUG $CFLAGS"
 fi
 
+dnl Determine target directory for libburn-*.pc
+dnl Important: Must be performed _after_ TARGET_SHIZZLE
+dnl
+LIBBURNIA_SET_PKGCONFIG
+
+
 AC_CONFIG_FILES([
 	Makefile
 	doc/doxygen.conf

doc/comments

@@ -1,75 +1,50 @@
 /**
    @author Mario Danic, Thomas Schmitt
 
-   @mainpage Libburnia Documentation Index
+   @mainpage Libburn Documentation Index
 
    @section intro Introduction
 
 Libburnia is an open-source project for reading, mastering and writing
-optical discs.
-For now this means CD-R, CD-RW, DVD-RAM, DVD+RW, DVD+R, DVD-RW, DVD-R.
+optical discs. This page is about its capability to handle optical media.
+For now this means CD-R, CD-RW, DVD-RAM, DVD+RW, DVD+R, DVD+R/DL, DVD-RW,
+DVD-R, DVD-R/DL, BD-R, BD-RE.
 
-Not supported yet are dual layer media, HD-DVD, BD (blue ray). Testers for
-dual layer DVD+/-R are wanted, though.
+Our scope is currently Linux 2.4 and 2.6, or FreeBSD, or Solaris . For ports
+to other systems we would need : login on a development machine resp.
+an OS ithat is installable on an AMD 64-bit PC, advise from a system person
+about the equivalent of Linux sg or FreeBSD CAM, volunteers for testing of
+realistic use cases.
 
-The project comprises of several more or less interdependent parts which
-together strive to be a usable foundation for application development.
-These are libraries, language bindings, and middleware binaries which emulate
-classical (and valuable) Linux tools.
+libburn is the library by which preformatted data get onto optical media.
+Its code is independent of cdrecord. Its DVD capabilities are learned from
+studying the code of dvd+rw-tools and MMC-5 specs. No code but only the pure
+SCSI knowledge has been taken from dvd+rw-tools, though.
 
-Our scope is currently Linux 2.4 and 2.6 only. For ports to other systems
-we would need : login on a development machine resp. a live OS on CD or DVD,
-advise from a system person about the equivalent of Linux sg or FreeBSD CAM,
-volunteers for testing of realistic use cases.
+cdrskin is a limited cdrecord compatibility wrapper for libburn.
+cdrecord is a powerful GPL'ed burn program included in Joerg Schilling's
+cdrtools. cdrskin strives to be a second source for the services traditionally
+provided by cdrecord. Additionally it provides libburn's DVD/BD capabilities,
+where only -sao is compatible with cdrecord.
+cdrskin does not contain any bytes copied from cdrecord's sources.
+Many bytes have been copied from the message output of cdrecord runs, though.
+See cdrskin/README for more.
 
-We have a workable code base for burning data and audio CDs and many DVD types.
-The burn API is quite comprehensively documented and can be used to build a
-presentable application.
-We have a functional binary which emulates the core use cases of cdrecord in
-order to prove that usability, and in order to allow you to explore libburn's
-scope by help of existing cdrecord frontends.
+The burn API example of libburn is named test/libburner.c . The API for media
+information inquiry is demonstrated in test/telltoc.c .
+Explore these examples if you look for inspiration.
 
-@subsection components The project components (list subject to growth, hopefully):
-
-- libburn  is the library by which preformatted data get onto optical media.
-           It uses either /dev/sgN (e.g. on kernel 2.4 with ide-scsi) or
-           /dev/hdX (e.g. on kernel 2.6).
-           libburn is the foundation of our cdrecord emulation. Its code is
-           independent of cdrecord. Its DVD capabilities are learned from
-           studying the code of dvd+rw-tools and MMC-5 specs. No code but only
-           the pure SCSI knowledge has been taken from dvd+rw-tools, though.
-
-- libisofs is the library to pack up hard disk files and directories into a
-           ISO 9660 disk image. This may then be brought to CD via libburn.
-           libisofs is to be the foundation of our upcoming mkisofs emulation.
-
-- cdrskin  is a limited cdrecord compatibility wrapper for libburn.
-           cdrecord is a powerful GPL'ed burn program included in Joerg
-           Schilling's cdrtools. cdrskin strives to be a second source for
-           the services traditionally provided by cdrecord. Additionally it
-           provides libburn's DVD capabilities, where only -sao is compatible
-           with cdrecord.
-           cdrskin does not contain any bytes copied from cdrecord's sources.
-           Many bytes have been copied from the message output of cdrecord
-           runs, though.
-           See cdrskin/README for more.
-
-- "test"   is a collection of application gestures and examples given by the
-           authors of the library features. The burn API example of libburn
-           is named test/libburner.c . The API for media information inquiry is
-           demonstrated in test/telltoc.c .
-           Explore these examples if you look for inspiration.
-
-We plan to be a responsive upstream. Bear with us.
+SONAME:
+libburn.so.4 (since 0.3.4, March 2007),
 
 
-   @section using Using the libraries
+   @section using Using libburn
 
 Our build system is based on autotools.
 User experience tells us that you will need at least autotools version 1.7.
 
-To build libburn and its subprojects it should be sufficient to go into
-its toplevel directory and execute
+To build libburn and its companion applications go into its toplevel directory
+and execute
 
 -  ./bootstrap  (needed if you downloaded from SVN)
 
@@ -81,30 +56,25 @@ To make the libraries accessible for running resp. developing applications
 
 -  make install
 
-Both libraries are written in C language and get built by autotools.
-Thus we expect them to be useable by a wide range of Linux-implemented
-languages and development tools.
-
 
 @section libburner Libburner
 
 libburner is a minimal demo application for the library libburn 
-(see: libburn/libburn.h) as provided on  http://libburn.pykix.org .
-It can list the available devices, can blank a CD-RW or DVD-RW and
-can burn to recordable CD and recordable single layer DVD.
+(see: libburn/libburn.h) as provided on  http://libburnia-project.org .
+It can list the available devices, can burn to recordable CD, DVD, or BD,
+can blank a CD-RW or DVD-RW, and can format unformatted DVD-RW, BD-R, or BD-RE. 
 
 It's main purpose, nevertheless, is to show you how to use libburn and also
 to serve the libburnia team as reference application. libburner does indeed
-define the standard way how above three gestures can be implemented and
-stay upward compatible for a good while.
+define the standard way how above gestures can be implemented and stay upward
+compatible for a good while.
 
    @subsection libburner-help Libburner --help
 <pre>
 Usage: test/libburner
-       [--drive <address>|<driveno>|"-"]  [--audio]
-       [--blank_fast|--blank_full|--format_overwrite]
-       [--try_to_simulate]
-       [--multi]  [<one or more imagefiles>|"-"]
+       [--drive address|driveno|"-"]  [--audio]
+       [--blank_fast|--blank_full|--format]  [--try_to_simulate]
+       [--multi]  [one or more imagefiles|"-"]
 Examples
 A bus scan (needs rw-permissions to see a drive):
   test/libburner --drive -
@@ -116,8 +86,8 @@ Blank a used CD-RW (is combinable with burning in one run):
   test/libburner --drive /dev/hdc --blank_fast
 Blank a used DVD-RW (is combinable with burning in one run):
   test/libburner --drive /dev/hdc --blank_full
-Format a DVD-RW to avoid need for blanking before re-use:
-  test/libburner --drive /dev/hdc --format_overwrite
+Format a DVD-RW, BD-RE or BD-R:
+  test/libburner --drive /dev/hdc --format
 Burn two audio tracks (to CD only):
   lame --decode -t /path/to/track1.mp3 track1.cd
   test/dewav /path/to/track2.wav -o track2.cd

doc/cookbook.txt

@@ -1,11 +1,18 @@
-libburnia.pykix.org Optical Media Rotisserie Recipes as of February 2007
+
+-------------------------------------------------------------------------------
+Note: This is about how libburn operates optical drives. Not about how to
+      operate libburn. The libburn API is described in libburn/libburn.h
+-------------------------------------------------------------------------------
+
+libburnia-project.org Optical Media Rotisserie Recipes as of January 2010
 
 Content:
 - TAO Multi-Session CD Cookbook (CD-R, CD-RW)
 - SAO CD Cookbook (CD-R, CD-RW, pure audio or pure data only)
-- Overwriteable DVD Cookbook (DVD-RAM, DVD+RW, DVD-RW)
+- Overwriteable DVD Cookbook (DVD-RAM, DVD+RW, DVD-RW, BD-RE)
 - Sequential DVD-R[W] Cookbook
-- DVD+R Cookbook
+- DVD+R[/DL] Cookbook
+- BD-R Cookbook
 
 -------------------------------------------------------------------------------
                          TAO Multi-Session CD Cookbook
@@ -18,7 +25,7 @@ by reading        libburn/*    from http://icculus.org/burn
 and by experiments with drives NEC ND-4570A, LG GSA-4082B, LITE-ON LTR48125S
 which used in part code from http://icculus.org/burn.
 
-For libburnia.pykix.org by Thomas Schmitt <scdbackup@gmx.net>
+For libburnia-project.org by Thomas Schmitt <scdbackup@gmx.net>
 
 -------------------------------------------------------------------------------
 
@@ -85,7 +92,7 @@ parameters:
  BUFE             Buffer Underrun protection      0=off, 1=on
  Test Write       -dummy mode for writing         0=off, 1=on
  Write Type       Packet/TAO/SAO/RAW              01h = TAO
- Multi-session    Wether to keep appendable       00b = finalize
+ Multi-session    Whether to keep appendable      00b = finalize
                                                   11b = keep appendable
  Track Mode       Describes frame type            4 for data , 0 for audio
  Data Block Type  Layout of payload blocks        8 for 2048 byte data blocks
@@ -118,19 +125,22 @@ A track must at least contain 300 payload blocks: 4 seconds of audio or
 600 KiB of data.
 (mmc5r03c.pdf 6.3.3.1.2)
 
-The track has to be closed by 5Bh CLOSE TRACK SESSION Close Function 001b.
-Older MMC specifies a valid Logical Track Number FFh to depict the open track.
-MMC-5 is quite silent about this. FFh works for my drives.
+Up to december 2009 the track was closed by 5Bh CLOSE TRACK SESSION Close
+Function 001b. Older MMC specifies a valid Logical Track Number FFh to depict
+the open track.  MMC-5 is quite silent about this. FFh worked for my drives.
 (mmc5r03c.pdf 6.3.3.1.2)
+This is omitted since libburn-0.7.4, relying entirely on 35h SYNCHRONIZE CACHE.
+First appeared a drive where CLOSE TRACK fails in simulation mode, later
+another one produced error replies even with real burning.
 
 After that, a new track may be written beginning with sending the mode page 05h
-again. It is not tested wether 05h can be omitted if Track Mode and Data Block
+again. It is not tested whether 05h can be omitted if Track Mode and Data Block
 Type are the same as with the previous track.
 The new track will be added to the session which was opened by the first track.
 
 After the last track of a session, 5Bh CLOSE TRACK SESSION Close Function 010b
 with Logical Track Number 0 closes the session. It depends on the Multi-Session
-value in mode page 05h wether the disc is finalized or stays appendable.
+value in mode page 05h whether the disc is finalized or stays appendable.
 (mmc5r03c.pdf 6.3.3.1.3)
 
 
@@ -201,7 +211,7 @@ for finalized disc.
 In libburn the address of the first track in the last session is obtained from
 the last session's POINT = A0h and from the track descriptor with the POINT
 value matching the PMIN value of the A0h descriptor.
-Untested is wether POINT = B0h and 52h READ TRACK INFORMATION are always in
+Untested is whether POINT = B0h and 52h READ TRACK INFORMATION are always in
 sync. libburn uses the info provided by 52h READ TRACK INFORMATION.
 
 
@@ -215,7 +225,7 @@ backed by reading mmc5r03c.pdf from http://www.t10.org/ftp/t10/drafts/mmc5/
 and by experiments with drives NEC ND-4570A, LG GSA-4082B, LITE-ON LTR48125S
 which used in part code from http://icculus.org/burn.
 
-For libburnia.pykix.org by Thomas Schmitt <scdbackup@gmx.net>
+For libburnia-project.org by Thomas Schmitt <scdbackup@gmx.net>
 
 -------------------------------------------------------------------------------
 
@@ -307,7 +317,7 @@ A Write Parameters mode page 05h has to be composed and transmitted via
  BUFE             Buffer Underrun protection      0=off, 1=on
  Test Write       -dummy mode for writing         0=off, 1=on
  Write Type       Packet/TAO/SAO/RAW              02h = SAO
- Multi-session    Wether to keep appendable       00b = finalize
+ Multi-session    Whether to keep appendable      00b = finalize
                                                   11b = keep appendable
  Track Mode       Describes frame type            0 (is ignored)
  Data Block Type  Layout of payload blocks        0 (is ignored)
@@ -348,7 +358,7 @@ There is no separator between the tracks of a pure mode SAO session.
 (If the session was mixed mode, there would be extended Pre-gaps and Post-gaps
 between data mode tracks and audio mode tracks.)
 (libburn sends its own buffer to the drive at the end of each track but does
-not sync the drive's chache. It is unclear wether this separation of tracks
+not sync the drive's chache. It is unclear whether this separation of tracks
 on the level of 2Ah WRITE is necessary with a pure mode session. It does not
 harm in any case and would probably be unavoidable if audio and data tracks
 were mixed.)
@@ -403,9 +413,10 @@ correctness of Pre-gap and Post-gap would become evident.
 -------------------------------------------------------------------------------
 Inspired by Andy Polyakov's http://fy.chalmers.se/~appro/linux/DVD+RW/tools ,
 backed by reading mmc5r03c.pdf from http://www.t10.org/ftp/t10/drafts/mmc5/
-and by experiments with drives NEC ND-4570A and LG GSA-4082B.
+by own experiments with drives NEC ND-4570A, LG GSA-4082B, PHILIPS SPD3300L,
+LG GGW H20L, and by BD-RE experiments done by Giulio Orsero on LG BE06LU10.
 
-For libburnia.pykix.org by Thomas Schmitt <scdbackup@gmx.net>
+For libburnia-project.org by Thomas Schmitt <scdbackup@gmx.net>
 
 -------------------------------------------------------------------------------
 
@@ -416,18 +427,24 @@ DVD-RAM                        0012h
 DVD-RW Restricted Overwrite    0013h
 DVD-RW Sequential Recording    0014h (i.e. unformatted)
 DVD+RW                         001Ah
+BD-RE                          0043h
 
 A short compilation of the write model:
 - Overwriting in general
 
 The recipes described here are depending on formatting state:
-- DVD-RAM, fully formatted DVD+RW or DVD-RW
+- DVD-RAM, fully formatted DVD+RW, DVD-RW, BD-RE
 - Unformatted DVD+RW
 - Partly formatted DVD+RW
 - Unformatted DVD-RW
 - Partly formatted DVD-RW
 - Intermediate state DVD-RW
+- DVD-RAM and BD-RE formatting
+- DVD-RAM and BD-RE speed tuning
 
+Slightly off topic are
+- ISO 9660 multi-session emulation on overwriteable media
+- ISO 9660 based TOC emulation on overwriteable media
 
 -------------------------------------------------------------------------------
 Overwriting in general :
@@ -444,7 +461,7 @@ Optimal performance is promised without any speed setting. But my experiments
 showed that SET STREAMING values persist after media change.
 
 In the formatted area of the media, coarse random access is possible.
-For DVD-RAM and DVD+RW write addresses and data size need to be aligned
+For DVD-RAM, DVD+RW, BD-RE write addresses and data size need to be aligned
 to 2 KiB. For DVD-RW alignment has to be 32 KiB. Within these limitations
 the write address is at the discretion of the sending program.
 Just use 2Ah WRITE to send data.
@@ -483,9 +500,12 @@ software did anything wrong.
 
 
 -------------------------------------------------------------------------------
-DVD-RAM, fully formatted DVD+RW or DVD-RW :
+DVD-RAM, fully formatted DVD+RW, DVD-RW, BD-RE :
 
-Full format is the natural state of DVD-RAM. 
+Full format is the natural state of DVD-RAM.
+
+BD-RE are sold unformatted and need to be fully formatted first.
+See paragraph about DVD-RAM and BD-RE formatting below.
 
 DVD+RW reaches this state if Background Formatting is allowed to finish without
 being stopped by 5Bh CLOSE TRACK SESSION.
@@ -516,7 +536,7 @@ with Close Function 010b despite there is no session open in this scenario.)
 
 
 -------------------------------------------------------------------------------
-Unformatted DVD+RW
+Unformatted DVD+RW :
 
 This is the state of previously unused DVD+RW media.
 
@@ -671,6 +691,170 @@ of Intermediate state by 5Bh CLOSE TRACK SESSION with Close Function 010b.
 (mmc5r03c.pdf 6.3.3.2.3)
 
 
+-------------------------------------------------------------------------------
+DVD-RAM and BD-RE formatting :
+
+Although DVD-RAM usually are sold formatted, there may still arise the wish
+to adjust formatting.
+BD-RE are sold unformatted and need to be formatted prior to usage.
+
+Two format types are relevant for DVD-RAM : 00h and 01h.
+00h offers the default size format and usually a maximum payload size format.
+Even with that maximum size payload there is hardware defect management.
+(mmc5r03c.pdf 6.5.4.2.1.2)
+01h allows to convert payload capacity into spare blocks for defect
+managment. There is no way to increase payload capacity by format 01h.
+(mmc5r03c.pdf 6.5.4.2.2.1)
+
+With BD-RE there are three format types : 00h, 30h and 31h.
+00h offers the default size format. This may be the only fast formatting
+mode that is offered by the drive.
+Feature 0023h tells whether format 31h and certain 30h subtypes are available.
+(mmc5r03c.pdf 5.3.13)
+30h offers several sizes with defect management. Usually there are three
+sizes given: #1: default size, #2: maximum spare area, #3: minimal spare.
+One may demand any spare size between maximum and minimum. There may be quick
+certification and full certification. See feature 0023h.
+31h offers a single size and disables defect management. This has the side
+effect to speed up writing to nominal speed.
+(mmc5r03c.pdf 6.5.4.2.15, 6.24.3.3, Table 472)
+
+Only format sizes from the list of format descriptors are permissible
+for DVD-RAM. The format list can be obtained by 23h READ FORMAT CAPACITIES.
+It also includes a description of the current formatting state.
+(mmc5r03c.pdf 6.24, 6.24.3.2, 6.24.3.3)
+
+Formatting is done by command 04h FORMAT UNIT. Its data payload consists
+of a Format List Header and a Format Descriptor. It is advisable to set
+the Immed bit and the FOV bit in header byte number 1. The descriptor should
+be a copy of a descriptor from 23h READ FORMAT CAPACITIES.
+(mmc5r03c.pdf 6.5, 6.5.3.2, 6.5.3.3)
+With nearly all formats Sub-type should be set to 0. But with BD-RE formats
+30h and 31h the Sub-type selects the certification mode.
+Usable with 30h seem 10b Full Certification and 11b Quick Certification.
+Usable with 31h seem also 00b Quick Reformat and 01b No Certification.
+(mmc5r03c.pdf 6.5.4.2.15.1)
+
+Other format types have their certification intensity controlled by
+a pair of bits: CmpList and DCRT.
+CmpList resides in CDB byte 1 as bit 3. DCRT resides in the payload byte 1
+as bit 5. Both together should request a quick size change without lengthy
+certification but maintaining the list of known defects.
+(mmc5r03c.pdf 6.5, table 249, 6.5.3.2)
+With DVD-RAM on my PHILIPS SPD3300L drive they prevent any format size
+change though. The TSSTcorp SH-S203B works properly.
+With BD-RE format 00h, the default is specified to be Quick Reformat,
+and with 00h in general certification can only be disabled not enabled.
+(mmc5r03c.pdf 6.5.4.2.1.7)
+
+
+-------------------------------------------------------------------------------
+DVD-RAM and BD-RE tuning :
+
+A special aspect of DVD-RAM and BD-RE is their low speed with write operations,
+which usually is only half than the nominal speed of media and drive.
+This is blamed to the automatic checkreading which happens for managing
+eventual defects. 
+
+Defect management of BD-RE can be disabled by format type 31h. See above.
+There is no drive known yet which would apply command 2Ah WRITE10 to DVD-RAM
+with full speed.
+
+The only known way to get full speed from DVD-RAM or BD-RE with enabled defect
+management is the use of AAh WRITE12 with Streaming Bit set to 1.
+(mmc5r03c.pdf 6.45)
+With some DVD-RAM drives this fails if a write buffer is not full 32 kB.
+With the tested BD-RE one must write full 64 kB buffers, or else writing
+might not get into effect at all.
+
+Although it seems not optimal, this is specified not only to disable the
+cumbersome checkread but also to ignore known defects and to write data
+to these defective addresses.
+(mmc5r03c.pdf 4.8.5)
+So the speed-up is only advisable as long as the media are free of
+incorrectable errors.
+
+Caveat:
+MMC-5 does not guarantee AAh WRITE12 to work on DVD-RAM or BD-RE at all.
+None of the features of profiles 0012h and 0043h promises the existence of
+AAh WRITE12.
+(mmc5r03c.pdf 5.4.13, 6.45)
+Nevertheless it worked on all tested drives if proper alignment and block
+size was observed.
+
+
+-------------------------------------------------------------------------------
+ISO 9660 multi-session emulation on overwriteable media :
+
+Overwriteable media provide a single overwriteable track which may grow up to
+the full media capacity. There is no builtin table-of-content which records
+the history of write sessions.
+mount -t iso9660 will use sbsector=0 as default.
+The term "superblock" shall depict the first 64 KiB after the sbsector address.
+
+ISO 9660 multi-session depends on typical TOC information in two ways:
+It needs the superblock address MSC1 of the most recently recorded session and
+it needs the Next Writeable Address NWA for which to prepare the adress offset.
+
+The following is learned from growisofs and from ECMA-119:
+http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-119.pdf
+
+ISO 9660 filesystems provide information about the number of sectors which
+is also the lowest unused block address and thus a suitable NWA.
+This block address is stored in the Primary Volume Descriptor which is supposed
+to be stored in block 16 (eventually relative to MSC1).
+The bytes 0 to 5 of a PVD block are 
+   0x01 'C' 'D' '0' '0' '1'
+The sector count can then be read from byte 80 to 83
+   sectors= pvd[80] | (pvd[81] << 8) | (pvd[82] << 16) | (pvd[83] << 24);
+(Ecma-119.pdf 8.4)
+To support CD, DVD and BD media alike, it is advisable to round the NWA
+to the next multiple of 32 (= 64 KiB).
+
+So one can use 0 as MSC1 and prepare a new ISO session for the computed NWA.
+After writing the session it is necessary to patch the PVD at LBA 16.
+The minimal change would be to update the number of image sectors.
+It is stored in both notations LSB and MSB:
+   for(i= 0; i < 4; i++)
+     pvd[87 - i]= pvd[80 + i]= (sectors >> (8 * i)) & 0xff;
+
+cdrskin --grow_overwriteable_iso not only patches the sector fields of the
+PVD block but also the blocks up to LBA 31 which begin with
+   0xff 'C' 'D' '0' '0' '1'
+libisoburn submits 64 KiB data buffer to libisofs before image generation and
+afterwards writes these 64 KiB as new superblock to LBA 0.
+
+
+-------------------------------------------------------------------------------
+ISO 9660 based TOC emulation on overwriteable media :
+
+Above method of multi-session emulation yields a single session image after
+each add-on session. No reliable session history can be read because the
+sector size of the existing session gets overwritten by the new one.
+A TOC with session history is nevertheless desirable with incremental backups
+in order to access older backup states by mounting older superblocks at the
+start addresses of older sessions.
+
+All usual ISO 9660 formatter programs write a complete superblock to the
+start of each session.
+With a uniform NWA rounding rule it is possible to compute the address of
+superblock N+1 as the NWA after session N. The only problem is N=1
+because it gets overwritten by later sessions.
+
+libisoburn preserves the information of session 1 by writing the first session
+to LBA 32 rather than LBA 0. Afterwards it writes the overall superblock to
+LBA 0 (up to 31).
+So with all further add-on sessions the superblock at LBA 0 will enclose the
+overall image, while the superblocks of the sessions form a chain beginning
+at LBA 32. Each session superblock points to the next one by its sector count
+rounded up to 32. The chain end is marked by the overall image size.
+This chain gives the start addresses of sessions. The sector count minus start
+address gives the size of a particular session. ECMA-119 explains how to
+retrieve more info from the PVD (e.g. the volume id).
+
+See also the multi-session example in libisofs/doc/checksums.txt.
+
+
 -------------------------------------------------------------------------------
 
 -------------------------------------------------------------------------------
@@ -680,7 +864,7 @@ Inspired by Andy Polyakov's http://fy.chalmers.se/~appro/linux/DVD+RW/tools ,
 backed by reading mmc5r03c.pdf from http://www.t10.org/ftp/t10/drafts/mmc5/
 and by experiments with drives NEC ND-4570A and LG GSA-4082B.
 
-For libburnia.pykix.org by Thomas Schmitt <scdbackup@gmx.net>
+For libburnia-project.org by Thomas Schmitt <scdbackup@gmx.net>
 
 -------------------------------------------------------------------------------
 
@@ -762,7 +946,7 @@ Multi-Session by the application.
  LS_V             Link size valid                 1=true
  Test Write       -dummy mode for writing         0=off, 1=on
  Write Type       Packet/TAO/SAO/RAW              00h = Incremental (Packet)
- Multi-session    Wether to keep appendable       00b = finalize
+ Multi-session    Whether to keep appendable      00b = finalize
                                                   11b = keep appendable
  Track Mode       Describes frame type            5  [*1]
  Data Block Type  Layout of payload blocks        8  [*2]
@@ -788,12 +972,12 @@ growisofs (transport.hxx) sets Link Size to 16 for profiles 0011h and 0014h.
 libburn now records the first link size from feature 0021h in its burn_drive
 structure. If another link size item is 16, then 16 is used.
 [*4:]
-growisofs takes Packet Size from 52h. Specs predict it will be 16 (= 32 kB).
+growisofs takes Packet Size from 52h. Specs predict it will be 16 (= 32 kiB).
 (mmc5r03.pdf 7.5.4.16)
 
 The writing process is much like in "Writing a session to CD in TAO mode" :
 Next Writeable Address is fetched from the reply of 52h READ TRACK INFORMATION.
-libburn writes full 32 kB buffers via 2Ah WRITE.
+libburn writes full 32 kiB buffers via 2Ah WRITE.
 (mmc5r03c.pdf, 6.27 READ TRACK INFORMATION, 6.44 WRITE)
 When writing is done, it is mandatory to force the drive's buffer to media by
 35h SYNCHRONIZE CACHE.
@@ -809,7 +993,7 @@ from the reply of  51h READ DISC INFORMATION requesting Data Type 000b
 Multiple tracks are permissible in a single session. After all of them have
 been written, 5Bh CLOSE TRACK SESSION Close Function 010b with Logical Track
 Number 0 closes the session. It depends on the Multi-Session value in mode
-page 05h wether the disc is finalized or stays appendable.
+page 05h whether the disc is finalized or stays appendable.
 (mmc5r03c.pdf 6.3.3.2.3)
 
 
@@ -834,7 +1018,7 @@ The mode page 05h to be sent :
  LS_V             Link size valid                 0=false [*3]
  Test Write       -dummy mode for writing         0=off, 1=on
  Write Type       Packet/TAO/SAO/RAW              02h = DAO (same code as SAO)
- Multi-session    Wether to keep appendable       00b = finalize
+ Multi-session    Whether to keep appendable      00b = finalize
  Track Mode       Describes frame type            5  [*1]
  Data Block Type  Layout of payload blocks        8  [*2]
  Link Size        ???                             0 [*3]
@@ -860,7 +1044,8 @@ tested yet, what happens if not enough data get written.
 (mmc5r03c.pdf 6.31)
 
 Next Writeable Address is fetched from the reply of 52h READ TRACK INFORMATION.
-The reply is supposed to be 0. libburn writes full 32 kB buffers via 2Ah WRITE.
+The reply is supposed to be 0. libburn writes full 32 kiB buffers via
+2Ah WRITE.
 (mmc5r03c.pdf, 6.27 READ TRACK INFORMATION, 6.44 WRITE)
 If the track source delivers less than the announced size then libburn pads up
 by zeros.
@@ -989,15 +1174,12 @@ close session if multi-session is demanded.
 -------------------------------------------------------------------------------
 
 -------------------------------------------------------------------------------
-
-                              INCOMPLETE YET
-
-                              DVD+R Cookbook
+                             DVD+R[/DL] Cookbook
 -------------------------------------------------------------------------------
 Inspired by reading mmc5r03c.pdf from http://www.t10.org/ftp/t10/drafts/mmc5/
 backed by Andy Polyakov's http://fy.chalmers.se/~appro/linux/DVD+RW/tools ,
 
-For libburnia.pykix.org by Thomas Schmitt <scdbackup@gmx.net>
+For libburnia-project.org by Thomas Schmitt <scdbackup@gmx.net>
 
 -------------------------------------------------------------------------------
 
@@ -1008,7 +1190,7 @@ DVD+R/DL                       002bh
 
 - About empty, appendable and finalized DVD+R
 - Writing a Pseudo Session to DVD+R
-- >>> Hearsay about DVD+R/DL (Dual Layer) :
+- DVD+R/DL (Dual Layer
 
 The following two chapters of the Sequential DVD-R[W] Cookbook are valid for
 DVD+R media too:
@@ -1053,7 +1235,7 @@ No mode page 05h is to be sent.
 growisofs sends a page but the specs clearly state that one shall not do.
 (mmc5r03c.pdf 7.5.3)
 
-It is optional wether a track size is reserved in advance or not. Eventually
+It is optional whether a track size is reserved in advance or not. Eventually
 this is done by 53h RESERVE TRACK, RMZ=ARSV=0. Reservation size should better
 already be aligned to 32 KiB.
 (mmc5r03c.pdf 6.31)
@@ -1063,7 +1245,7 @@ The specs promise to pad up the track if not enough data get written.
 Next Writeable Address is fetched from the reply of 52h READ TRACK INFORMATION
 with track number FFh.
 (mmc5r03c.pdf 6.27)
-Since the fixely set write type is 16-block packet, full 32 kB buffers have
+Since the fixely set write type is 16-block packet, full 32 kiB buffers have
 to be transmitted via 2Ah WRITE.
 (mmc5r03c.pdf 4.3.6.2.2)
 
@@ -1087,13 +1269,141 @@ closed by Close Function 101b rather than 010b. This finalizes the media
 "with minimal radius".
 (mmc5r03c.pdf 6.3.3.4.4) 
 
-Note: growisofs has code for that gesture but explicitly avoids to use it.
-Instead it recommends to fill up the media with zeros.
+Note: growisofs has code for that gesture but explicitly avoids to use it, if
+the media was appendable before writing began. Instead it recommends to fill
+up the media with zeros. This gesture nevertheless caused error replies from
+the drives in my own experiments.
+The reason given by Andy Polyakov is that some DVD-ROM drives get mislead by
+the lead-out information of (formerly) appendable media unless the media is
+fully written.
+(http://fy.chalmers.se/~appro/linux/DVD+RW/ , "Compatibility: caveat lector")
+
+Own experiments showed no such problems with PC attached PATA DVD-ROM drives.
+For best DVD-ROM compatibility one should avoid appendable media at all
+by closing them already after the first session.
+
 
 -------------------------------------------------------------------------------
-Hearsay about DVD+R/DL (Dual Layer) :
+DVD+R/DL (Dual Layer) :
 
->>>
+libburn treats DL media just like their single layer equivalents.
+This seems to work fine for DVD+R/DL, according to a report by nightmorph
+in http://libburnia-project.org/ticket/13 .
+
+-------------------------------------------------------------------------------
+
+-------------------------------------------------------------------------------
+                              BD-R Cookbook
+-------------------------------------------------------------------------------
+Inspired by reading mmc5r03c.pdf from http://www.t10.org/ftp/t10/drafts/mmc5/
+backed by experiments iwith drive LG GGW H20L.
+
+For libburnia-project.org by Thomas Schmitt <scdbackup@gmx.net>
+
+-------------------------------------------------------------------------------
+Media type can be recognized by Current Profile from 46h GET CONFIGURATION.
+(mmc5r03c.pdf 6.6.2.1)
+BD-R                           0042h
+
+There are two basic recording modes defined: Sequential Recording Mode SRM and
+Random Recording Mode RRM. The latter is optional and for now not topic of this
+text.
+(mmc5r03c.pdf 4.5.3.5)
+
+
+- SRM Formatting
+- Writing a session in SRM-POW
+(- Pseudo-OverWrite SRM+POW)
+
+
+-------------------------------------------------------------------------------
+SRM Formatting:
+
+Despite being write-once media BD-R can optionally carry some formatting.
+
+SRM has a disc structure model with tracks and sessions.
+Several tracks may be open at the same time, each having its own NWA.
+(mmc5r03c.pdf 4.5.3.5.2.2)
+This structure is formatted onto blank media automatically as soon as the
+first serious write attempt occurs.
+(mmc5r03c.pdf 4.5.3.5)
+Before such a write attempt, blank media may be explicitely formatted with
+spares, which provide defect management.
+(mmc5r03c.pdf 4.5.3.5.3)
+Tracks get created from other tracks via RESERVE TRACK splitting.
+(mmc5r03c.pdf 4.5.3.5.2.5)
+
+On top of defect management there may be Pseudo-OverWrite SRM+POW, a costly
+way to write several times to the same LBA. See below.
+Fully sequential states are called SRM-POW.
+(mmc5r03c.pdf 4.5.3.5.4)
+
+Explicite formatting is done by 04h FORMAT UNIT. Its data payload consists
+of a Format List Header and a Format Descriptor. It is advisable to set
+the Immed bit and the FOV bit in header byte number 1. The descriptor should
+be a copy of a descriptor from 23h READ FORMAT CAPACITIES but the size may be
+adjusted within a certain range.
+(mmc5r03c.pdf 6.5, 6.5.3.2, 6.5.3.3)
+
+Format type 00h creates SRM layouts with a default number of spares (or
+eventually RRM) chosen by the format sub-type:
+  00b = SRM with support for POW
+  01b = SRM without POW (but with some spares for defect management)
+  10b = (RRM)
+(mmc5r03c.pdf 6.5.4.2.1.6)
+
+Format type 32h uses the same sub-types but allows to allocate non-default
+amounts of spares. Similar to BD-RE format 31h, three format descriptors are
+offered: #1: default size, #2: maximum spare area, #3: minimal spare.
+The size may be chosen within that range.
+
+The sense behind the Type Dependent Parameters is obscure
+to me. Best will be to set ISA_V and TDMA_V to 0.
+(mmc5r03c.pdf 6.5.4.2.1.17)
+
+
+-------------------------------------------------------------------------------
+Writing a session in SRM:
+
+The procedure and constraints for writing BD-R SRM-POW are very similar to
+DVD+R. libburn flatly re-uses its DVD+R code except the Close Function for
+finalizing a disc.
+
+In short:
+If all written sessions are closed, then there is exactly one NWA.
+In the beginning there is an empty session and track. A new track can be
+written either with pre-announced size (by RESERVE TRACK) or open-end by
+simply starting to write to the NWA. When done the track gets closed by
+close function 001b. Then either session or disc gets closed depending on
+the Close Function used:
+- Close Function 010b closes the session and keeps the media appendable
+  (same as with DVD+R)
+- Close Function 110b finalizes the media and makes it read-only.
+  (differs from libburn DVD+R procedure which uses 101b)
+
+-------------------------------------------------------------------------------
+Pseudo-OverWrite POW: (no used yet by libburn)
+
+This enhancement of SRM emulates overwriting of existing data blocks.
+(mmc5r03c.pdf 4.5.3.5.4)
+
+POW establishes a virtual vLBA space on top of the real address space rLBA.
+All read and write commands deal with vLBA. It seems that track NWAs are
+assumed to be identical in vLBA space and in rLBA space.
+It is not clear whether one may write to vLBA blocks which are neither written
+yet nor at one of the track NWAs. Probably not, or else one could make NWAs run
+into vLBAs which are associated with older rLBAs.
+
+Replacing invalidated blocks consumes addresses in rLBA space at the NWA of
+some track. I.e. no spares are consumed by POW. Nevertheless it is costly by
+a special map called Orphanage. It covers rLBA which have been consumed
+by differing vLBAs. It never shrinks and can grow with each write to remapped
+addresses.
+To avoid heavy Orphanage growth it is advised to write mostly to vLBA which
+still coincide with their rLBA. E.g. those addresses which have neither been
+written as rLBA nor as vLBA yet. So one should begin the vLBA of new sessions
+at the NWA of a sufficiently sized track.
+(mmc5r03c.pdf 4.5.3.5.4.2 , 4.5.3.6.9)
 
 -------------------------------------------------------------------------------
 

libburn-1.pc.in

@@ -4,7 +4,7 @@ libdir=@libdir@
 includedir=@includedir@
 
 Name: libburn
-Description: Disc reading/writing library
+Description: Library to read/write optical discs
 Version: @VERSION@
 Requires: 
 Libs: -L${libdir} -lburn

libburn/async.c

@@ -1,18 +1,49 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+/* ts A71019 */
+
+/* Standard measure should be: Threads are created detached.
+   According to the man pages they should then care for disposing themselves.
+
+   >>> ??? It is yet unclear why the threads vanish from the process list
+           even if joinable and even if never joined.
+
+   To be activated after release of libburn-0.4.0
+*/
+#define Libburn_create_detached_threadS 1
+
+/* Alternative : Threads are created joinable.
+   Threads get detached in remove_worker() and thus should dispose themselves.
+
+#define Libburn_detach_done_workeR 1
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include "libburn.h"
 #include "transport.h"
 #include "drive.h"
 #include "write.h"
 #include "options.h"
+#include "file.h"
 #include "async.h"
 #include "init.h"
 #include "back_hacks.h"
 
 #include <pthread.h>
+#include <sys/types.h>
+#include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
+#include <signal.h>
 
 /*
 #include <a ssert.h>
@@ -20,7 +51,15 @@
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
 
-#define SCAN_GOING() (workers && !workers->drive)
+/* ts A80714 : introduced type codes for the worker list */
+#define Burnworker_type_scaN    0
+#define Burnworker_type_erasE   1
+#define Burnworker_type_formaT  2
+#define Burnworker_type_writE   3
+#define Burnworker_type_fifO    4
+
+#define SCAN_GOING() (workers != NULL && \
+			workers->w_type == Burnworker_type_scaN)
 
 typedef void *(*WorkerFunc) (void *);
 
@@ -53,9 +92,18 @@ struct write_opts
 	struct burn_disc *disc;
 };
 
+struct fifo_opts
+{
+	struct burn_source *source;
+	int flag;
+};
+
 
 struct w_list
 {
+	/* ts A80714 */
+	int w_type; /* see above define Burnworker_type_* */
+
 	struct burn_drive *drive;
 	pthread_t thread;
 
@@ -67,10 +115,12 @@ struct w_list
 		struct erase_opts erase;
 		struct format_opts format;
 		struct write_opts write;
+		struct fifo_opts fifo;
 	} u;
 };
 
-static struct w_list *workers;
+static struct w_list *workers = NULL;
+
 
 static struct w_list *find_worker(struct burn_drive *d)
 {
@@ -82,12 +132,19 @@ static struct w_list *find_worker(struct burn_drive *d)
 	return NULL;
 }
 
-static void add_worker(struct burn_drive *d, WorkerFunc f, void *data)
+static void add_worker(int w_type, struct burn_drive *d,
+			WorkerFunc f, void *data)
 {
 	struct w_list *a;
 	struct w_list *tmp;
+	pthread_attr_t *attr_pt = NULL;
 
-	a = malloc(sizeof(struct w_list));
+#ifdef Libburn_create_detached_threadS
+	pthread_attr_t attr;
+#endif
+
+	a = calloc(1, sizeof(struct w_list));
+	a->w_type = w_type;
 	a->drive = d;
 	a->u = *(union w_list_data *)data;
 
@@ -96,16 +153,32 @@ static void add_worker(struct burn_drive *d, WorkerFunc f, void *data)
 	tmp = workers;
 	workers = a;
 
-	if (d)
+	if (d != NULL)
 		d->busy = BURN_DRIVE_SPAWNING;
 
-	if (pthread_create(&a->thread, NULL, f, a)) {
+#ifdef Libburn_create_detached_threadS
+	/* ts A71019 :
+	   Trying to start the threads detached to get rid of the zombies
+	   which do neither react on pthread_join() nor on pthread_detach().
+	*/
+	pthread_attr_init(&attr);
+	pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+	attr_pt= &attr;
+/*
+	libdax_msgs_submit(libdax_messenger, -1, 0x00020158,
+			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_LOW,
+			"add_worker(): Creating detached thread.", 0, 0);
+*/
+#endif
+
+	if (pthread_create(&a->thread, attr_pt, f, a)) {
 		free(a);
 		workers = tmp;
 		return;
 	}
 }
 
+
 static void remove_worker(pthread_t th)
 {
 	struct w_list *a, *l = NULL;
@@ -116,6 +189,28 @@ static void remove_worker(pthread_t th)
 				l->next = a->next;
 			else
 				workers = a->next;
+
+#ifdef Libburn_detach_done_workeR
+			/* ts A71019 : burry dead puppy before forgetting it */
+			/* Alternative : threads get detached and thus should
+					dispose themselves.
+			*/
+			pthread_detach(th);
+/*
+			int ret;
+			char msg[80];
+
+			ret = pthread_detach(th);
+			sprintf(msg,
+			 "remove_workers(): pid= %lu  pthread_detach(%lu)= %d",
+			 (unsigned long) getpid(), (unsigned long) th, ret);
+			libdax_msgs_submit(libdax_messenger, -1, 0x00020158,
+				LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_LOW,
+				msg, 0, 0);
+*/
+			
+#endif /* Libburn_detach_done_workeR */
+
 			free(a);
 			break;
 		}
@@ -130,11 +225,32 @@ static void remove_worker(pthread_t th)
 
 static void *scan_worker_func(struct w_list *w)
 {
-	burn_drive_scan_sync(w->u.scan.drives, w->u.scan.n_drives);
-	w->u.scan.done = 1;
+	int ret;
+
+	ret = burn_drive_scan_sync(w->u.scan.drives, w->u.scan.n_drives, 1);
+	if (ret <= 0)
+		w->u.scan.done = -1;
+	else
+		w->u.scan.done = 1;
 	return NULL;
 }
 
+static void reset_progress(struct burn_drive *d, int sessions, int tracks,
+				int indices, int sectors, int flag)
+{
+	/* reset the progress indicator */
+	d->progress.session = 0;
+	d->progress.sessions = sessions;
+	d->progress.track = 0;
+	d->progress.tracks = tracks;
+	d->progress.index = 0;
+	d->progress.indices = indices;
+	d->progress.start_sector = 0;
+	d->progress.sectors = sectors;
+	d->progress.sector = 0;
+}
+
+
 int burn_drive_scan(struct burn_drive_info *drives[], unsigned int *n_drives)
 {
 	struct scan_opts o;
@@ -165,12 +281,13 @@ drive_is_active:;
 		return -1;
 	}
 
-	if (!workers) {
+	if (workers == NULL) {
 		/* start it */
 
 		/* ts A61007 : test moved up from burn_drive_scan_sync()
 				was burn_wait_all() */
-		if (!burn_drives_are_clear())
+		/* ts A70907 : now demanding freed drives, not only released */
+		if (!burn_drives_are_clear(1))
 			goto drive_is_active;
 		*drives = NULL;
 		*n_drives = 0;
@@ -178,7 +295,8 @@ drive_is_active:;
 		o.drives = drives;
 		o.n_drives = n_drives;
 		o.done = 0;
-		add_worker(NULL, (WorkerFunc) scan_worker_func, &o);
+		add_worker(Burnworker_type_scaN, NULL,
+				 (WorkerFunc) scan_worker_func, &o);
 	} else if (workers->u.scan.done) {
 		/* its done */
 		ret = workers->u.scan.done;
@@ -189,7 +307,7 @@ drive_is_active:;
 		if (workers != NULL) {
 			libdax_msgs_submit(libdax_messenger, -1, 0x00020101,
 				LIBDAX_MSGS_SEV_WARNING, LIBDAX_MSGS_PRIO_HIGH,
-			     "After scan a  drive operation is still going on",
+			     "After scan a drive operation is still going on",
 				0, 0);
 			return -1;
 		}
@@ -202,8 +320,27 @@ drive_is_active:;
 
 static void *erase_worker_func(struct w_list *w)
 {
+
+#define Libburn_protect_erase_threaD 1
+
+#ifdef Libburn_protect_erase_threaD
+	sigset_t sigset, oldset;
+
+	/* Protect blank thread from being interrupted by external signals */
+	sigfillset(&sigset);
+	sigdelset(&sigset, SIGSEGV);
+	sigdelset(&sigset, SIGILL);
+	pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
+#endif /* Libburn_protect_erase_threaD */
+
 	burn_disc_erase_sync(w->u.erase.drive, w->u.erase.fast);
 	remove_worker(pthread_self());
+
+#ifdef Libburn_protect_erase_threaD
+	/* (just in case it would not end with all signals blocked) */
+	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+#endif /* Libburn_protect_erase_threaD */
+
 	return NULL;
 }
 
@@ -211,21 +348,19 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 {
 	struct erase_opts o;
 
-	/* A70103 : will be set to 0 by burn_disc_erase_sync() */
-	drive->cancel = 1;
-
 	/* ts A61006 */
 	/* a ssert(drive); */
 	/* a ssert(!SCAN_GOING()); */
 	/* a ssert(!find_worker(drive)); */
+
 	if((drive == NULL)) {
-		libdax_msgs_submit(libdax_messenger, drive->global_index,
+		libdax_msgs_submit(libdax_messenger, -1,
 			0x00020104,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			"NULL pointer caught in burn_disc_erase", 0, 0);
 		return;
 	}
-	if ((SCAN_GOING()) || find_worker(drive)) {
+	if ((SCAN_GOING()) || find_worker(drive) != NULL) {
 		libdax_msgs_submit(libdax_messenger, drive->global_index,
 			0x00020102,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
@@ -234,12 +369,22 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 		return;
 	}
 
+	reset_progress(drive, 1, 1, 1, 0x10000, 0);
+
+	/* A70103 : will be set to 0 by burn_disc_erase_sync() */
+	drive->cancel = 1;
+
 	/* ts A70103 moved up from burn_disc_erase_sync() */
 	/* ts A60825 : allow on parole to blank appendable CDs */
 	/* ts A70131 : allow blanking of overwriteable DVD-RW (profile 0x13) */
 	/* ts A70216 : allow blanking of CD-RW or DVD-RW in any regular state
 	               and of any kind of full media */
-	if ((drive->current_profile != 0x0a &&
+	/* ts A70909 : the willingness to burn any BURN_DISC_FULL media is
+	               inappropriate. One would rather need a -force option
+	               Note: keep this in sync with mmc_read_disc_info() */
+	/* ts B10321 : Allowed role 5 to be blanked */
+	if ((drive->drive_role == 1 &&
+	     drive->current_profile != 0x0a &&
 	     drive->current_profile != 0x13 &&
 	     drive->current_profile != 0x14 &&
 	     drive->status != BURN_DISC_FULL)
@@ -247,6 +392,8 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 	    (drive->status != BURN_DISC_FULL &&
 	     drive->status != BURN_DISC_APPENDABLE &&
 	     drive->status != BURN_DISC_BLANK)
+	    ||
+	    (drive->drive_role != 1 && drive->drive_role != 5)
 	   ) {
 		libdax_msgs_submit(libdax_messenger, drive->global_index,
 			0x00020130,
@@ -258,16 +405,36 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 
 	o.drive = drive;
 	o.fast = fast;
-	add_worker(drive, (WorkerFunc) erase_worker_func, &o);
+	add_worker(Burnworker_type_erasE, drive,
+			(WorkerFunc) erase_worker_func, &o);
 }
 
 
 /* ts A61230 */
 static void *format_worker_func(struct w_list *w)
 {
+
+#define Libburn_protect_format_threaD 1
+
+#ifdef Libburn_protect_format_threaD
+	sigset_t sigset, oldset;
+
+	/* Protect format thread from being interrupted by external signals */
+	sigfillset(&sigset);
+	sigdelset(&sigset, SIGSEGV);
+	sigdelset(&sigset, SIGILL);
+	pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
+#endif /* Libburn_protect_format_threaD */
+
 	burn_disc_format_sync(w->u.format.drive, w->u.format.size,
 				w->u.format.flag);
 	remove_worker(pthread_self());
+
+#ifdef Libburn_protect_format_threaD
+	/* (just in case it would not end with all signals blocked) */
+	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+#endif /* Libburn_protect_format_threaD */
+
 	return NULL;
 }
 
@@ -276,10 +443,12 @@ static void *format_worker_func(struct w_list *w)
 void burn_disc_format(struct burn_drive *drive, off_t size, int flag)
 {
 	struct format_opts o;
-	int ok = 0;
-	char msg[160];
+	int ok = 0, ret;
+	char msg[40];
 
-	if ((SCAN_GOING()) || find_worker(drive)) {
+	reset_progress(drive, 1, 1, 1, 0x10000, 0);
+
+	if ((SCAN_GOING()) || find_worker(drive) != NULL) {
 		libdax_msgs_submit(libdax_messenger, drive->global_index,
 			0x00020102,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
@@ -287,6 +456,14 @@ void burn_disc_format(struct burn_drive *drive, off_t size, int flag)
 			0, 0);
 		return;
 	}
+	if (drive->drive_role != 1) {
+		libdax_msgs_submit(libdax_messenger, drive->global_index,
+			0x00020146,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+			"Drive is a virtual placeholder", 0, 0);
+		drive->cancel = 1;
+		return;
+	}
 	if (flag & 128)     /* application prescribed format type */
 		flag |= 16; /* enforce re-format */
 
@@ -299,6 +476,48 @@ void burn_disc_format(struct burn_drive *drive, off_t size, int flag)
 		size = 0;
 		flag &= ~(2|8); /* no insisting in size 0, no expansion */
 		flag |= 4;      /* format up to maximum size */
+	} else if (drive->current_profile == 0x12) {
+		ok = 1; /* DVD-RAM */
+
+	} else if (drive->current_profile == 0x41) {
+		/* BD-R SRM */
+		ok= 1;
+		ret = drive->read_format_capacities(drive, 0x00);
+		if (ret > 0 &&
+		    drive->format_descr_type == BURN_FORMAT_IS_FORMATTED)
+			ok = 0;
+		if (drive->status != BURN_DISC_BLANK)
+			ok = 0;
+		if (!ok) {
+			libdax_msgs_submit(libdax_messenger,
+				drive->global_index, 0x00020162,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			 "BD-R not unformatted blank any more. Cannot format.",
+				0, 0);
+			drive->cancel = 1;
+			return;
+		}
+		if (flag & 32) {
+			libdax_msgs_submit(libdax_messenger,
+				drive->global_index, 0x00020163,
+				LIBDAX_MSGS_SEV_NOTE, LIBDAX_MSGS_PRIO_HIGH,
+			"Blank BD-R left unformatted for zero spare capacity.",
+				0, 0);
+			return;
+		}
+	} else if (drive->current_profile == 0x43) {
+		ok = 1; /* BD-RE */
+
+		if ((flag & 32) && !(drive->current_feat23h_byte4 & 8)) {
+			libdax_msgs_submit(libdax_messenger,
+				drive->global_index, 0x00020164,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				"Drive does not format BD-RE without spares.",
+				0, 0);
+			drive->cancel = 1;
+			return;
+
+		} 
 	}
 
 	if (!ok) {
@@ -314,53 +533,110 @@ void burn_disc_format(struct burn_drive *drive, off_t size, int flag)
 	o.drive = drive;
 	o.size = size;
 	o.flag = flag;
-	add_worker(drive, (WorkerFunc) format_worker_func, &o);
+	add_worker(Burnworker_type_formaT, drive,
+			(WorkerFunc) format_worker_func, &o);
 }
 
 
 static void *write_disc_worker_func(struct w_list *w)
 {
+	struct burn_drive *d = w->u.write.drive;
+	char msg[80];
+
+#define Libburn_protect_write_threaD 1
+
+#ifdef Libburn_protect_write_threaD
+	sigset_t sigset, oldset;
+
+	/* Protect write thread from being interrupted by external signals */
+	sigfillset(&sigset);
+	sigdelset(&sigset, SIGSEGV);
+	sigdelset(&sigset, SIGILL);
+	pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
+#endif /* Libburn_protect_write_threaD */
+
+	d->thread_pid = getpid();
+	d->thread_tid = pthread_self();
+	d->thread_pid_valid= 1;
 	burn_disc_write_sync(w->u.write.opts, w->u.write.disc);
+	d->thread_pid_valid= 0;
+	d->thread_pid = 0;
 
 	/* the options are refcounted, free out ref count which we added below 
 	 */
 	burn_write_opts_free(w->u.write.opts);
 
+	sprintf(msg, "Write thread on drive %d ended", d->global_index);
+	libdax_msgs_submit(libdax_messenger, d->global_index, 0x00020178,
+			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+			msg, 0, 0);
+
 	remove_worker(pthread_self());
+	d->busy = BURN_DRIVE_IDLE;
+
+#ifdef Libburn_protect_write_threaD
+	/* (just in case it would not end with all signals blocked) */
+	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+#endif /* Libburn_protect_write_threaD */
+
 	return NULL;
 }
 
 void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 {
 	struct write_opts o;
-	char reasons[BURN_REASONS_LEN+80];
-#ifndef Libburn_precheck_write_ruleS
-	int i, j, mode, mixed_mode = 0;
-#endif
+	char *reasons= NULL;
+	struct burn_drive *d;
 
-
-	/* For the next lines any return indicates failure */
-	opts->drive->cancel = 1;
-
-	/* ts A70203 : people have been warned in API specs */
-	if (opts->write_type == BURN_WRITE_NONE)
-		return;
+	d = opts->drive;
 
 	/* ts A61006 */
 	/* a ssert(!SCAN_GOING()); */
 	/* a ssert(!find_worker(opts->drive)); */
-	if ((SCAN_GOING()) || find_worker(opts->drive)) {
-		libdax_msgs_submit(libdax_messenger, opts->drive->global_index,
+	if ((SCAN_GOING()) || find_worker(opts->drive) != NULL) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
 			0x00020102,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			"A drive operation is still going on (want to write)",
 			0, 0);
 		return;
 	}
+
+	reset_progress(d, disc->sessions, disc->session[0]->tracks,
+			 disc->session[0]->track[0]->indices, 0, 0);
+
+	/* For the next lines any return indicates failure */
+	d->cancel = 1;
+
+	/* ts A70203 : people have been warned in API specs */
+	if (opts->write_type == BURN_WRITE_NONE) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x0002017c,
+			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+			"No valid write type selected", 0, 0);
+		return;
+	}
+
+	if (d->drive_role == 0) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020146,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+			"Drive is a virtual placeholder (null-drive)", 0, 0);
+		return;
+	}
+	if (d->drive_role == 4) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020181,
+			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+			"Pseudo-drive is a read-only file. Cannot write.",
+			0, 0);
+		return;
+	}
+
 	/* ts A61007 : obsolete Assert in spc_select_write_params() */
-	if (!opts->drive->mdata->valid) {
+	if (d->drive_role == 1 && d->mdata->valid <= 0) {
 		libdax_msgs_submit(libdax_messenger,
-				opts->drive->global_index, 0x00020113,
+				d->global_index, 0x00020113,
 				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 				"Drive capabilities not inquired yet", 0, 0);
 		return;
@@ -369,62 +645,128 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 	/* ts A70219 : intended to replace all further tests here and many
 	               tests in burn_*_write_sync()
 	*/
+
+        BURN_ALLOC_MEM_VOID(reasons, char, BURN_REASONS_LEN + 80);
 	strcpy(reasons, "Write job parameters are unsuitable:\n");
 	if (burn_precheck_write(opts, disc, reasons + strlen(reasons), 1)
-	     == BURN_WRITE_NONE) {
-
-#ifndef Libburn_precheck_write_ruleS
+	     <= 0) {
 		libdax_msgs_submit(libdax_messenger,
-				opts->drive->global_index, 0x00020139,
-				LIBDAX_MSGS_SEV_WARNING, LIBDAX_MSGS_PRIO_HIGH,
-				reasons, 0, 0);
-#else
-		libdax_msgs_submit(libdax_messenger,
-				opts->drive->global_index, 0x00020139,
+				d->global_index, 0x00020139,
 				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 				reasons, 0, 0);
-		return;
-#endif /* Libburn_precheck_write_ruleS */
-
+		goto ex;
 	}
+        BURN_FREE_MEM(reasons); reasons= NULL;
 
+	/* ts A90106 : early catching of unformatted BD-RE */
+	if (d->current_profile == 0x43) 
+		if (d->read_format_capacities(d, 0x00) > 0 &&
+		    d->format_descr_type != BURN_FORMAT_IS_FORMATTED) {
+			libdax_msgs_submit(libdax_messenger,
+				d->global_index, 0x00020168,
+				LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+				"Media not properly formatted. Cannot write.",
+				0, 0);
+			return;
+		}
 
-#ifndef Libburn_precheck_write_ruleS
-	/* <<< covered burn_precheck_write() */
-	/* ts A61009 : obsolete Assert in sector_headers() */
-	if (! burn_disc_write_is_ok(opts, disc, 0)) /* issues own msgs */
-		return;
+	d->cancel = 0; /* End of the return = failure area */
 
-	/* <<< covered burn_precheck_write() */
-	/* ts A70122 : libburn SAO code mishandles mode changes */
-	for (i = 0; i < disc->sessions; i++) {
-		if (disc->session[i]->tracks <= 0)
-	continue;
-		mode =  disc->session[i]->track[0]->mode;
-		for (j = 1; j < disc->session[i]->tracks; j++)
-			if (mode != disc->session[i]->track[j]->mode)
-				mixed_mode = 1;
-	}
-	if (mixed_mode && opts->write_type == BURN_WRITE_SAO) {
-		libdax_msgs_submit(libdax_messenger,
-				opts->drive->global_index, 0x00020133,
-				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
-				"Cannot mix data and audio in SAO mode", 0, 0);
-		return;
-	}
-#endif /* ! Libburn_precheck_write_ruleS */
-
-	opts->drive->cancel = 0; /* End of the return = failure area */
-
-	o.drive = opts->drive;
+	o.drive = d;
 	o.opts = opts;
 	o.disc = disc;
 
 	opts->refcount++;
 
-	add_worker(opts->drive, (WorkerFunc) write_disc_worker_func, &o);
+	add_worker(Burnworker_type_writE, d,
+			(WorkerFunc) write_disc_worker_func, &o);
+
+ex:;
+	BURN_FREE_MEM(reasons);
 }
 
+
+static void *fifo_worker_func(struct w_list *w)
+{
+	int old;
+
+#define Libburn_protect_fifo_threaD 1
+
+#ifdef Libburn_protect_fifo_threaD
+	sigset_t sigset, oldset;
+
+	/* Protect fifo thread from being interrupted by external signals */
+	sigfillset(&sigset);
+	sigdelset(&sigset, SIGSEGV);
+	sigdelset(&sigset, SIGILL);
+	pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
+#endif /* Libburn_protect_fifo_threaD */
+
+	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old);
+	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old);
+		/* Note: Only burn_fifo_abort() shall cancel the fifo thread */
+
+	burn_fifo_source_shoveller(w->u.fifo.source, w->u.fifo.flag);
+	remove_worker(pthread_self());
+
+#ifdef Libburn_protect_fifo_threaD
+	/* (just in case it would not end with all signals blocked) */
+	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
+#endif /* Libburn_protect_fifo_threaD */
+
+	return NULL;
+}
+
+
+int burn_fifo_start(struct burn_source *source, int flag)
+{
+	struct fifo_opts o;
+	struct burn_source_fifo *fs = source->data;
+
+	fs->is_started = -1;
+
+	/* create and set up ring buffer */;
+	fs->buf = burn_os_alloc_buffer(
+			((size_t) fs->chunksize) * (size_t) fs->chunks, 0);
+	if (fs->buf == NULL) {
+		/* >>> could not start ring buffer */;
+		return -1;
+	}
+
+	o.source = source;
+	o.flag = flag;
+	add_worker(Burnworker_type_fifO, NULL,
+			(WorkerFunc) fifo_worker_func, &o);
+	fs->is_started = 1;
+
+	return 1;
+}
+
+
+int burn_fifo_abort(struct burn_source_fifo *fs, int flag)
+{
+	int ret;
+	pthread_t pt;
+
+	if (fs->thread_is_valid <= 0 || fs->thread_handle == NULL)
+		return(2);
+
+#ifdef NIX
+	libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
+			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+			"Aborting running burn_source_fifo thread", 0, 0);
+#endif /* NIX */
+
+	pt= *((pthread_t *) fs->thread_handle);
+	remove_worker(pt);
+	ret = pthread_cancel(pt);
+	return (ret == 0);
+}
+
+
+#ifdef Libburn_has_burn_async_join_alL
+
+/* ts A71019 : never used */
 void burn_async_join_all(void)
 {
 	void *ret;
@@ -432,3 +774,7 @@ void burn_async_join_all(void)
 	while (workers)
 		pthread_join(workers->thread, &ret);
 }
+
+#endif /* Libburn_has_burn_async_join_alL */
+
+

libburn/async.h

@@ -5,4 +5,14 @@
 
 void burn_async_join_all(void);
 struct burn_write_opts;
+
+/* ts A70930 */
+/* To be called when the first read() call comes to a fifo */
+int burn_fifo_start(struct burn_source *source, int flag);
+
+/* ts A81108 */
+/* To abort a running fifo thread before the fifo object gets deleted */
+int burn_fifo_abort(struct burn_source_fifo *fs, int flag);
+
+
 #endif /* BURN__ASYNC_H */

libburn/back_hacks.h

@@ -1,4 +1,6 @@
 /**
+ Copyright (c) 2006 Thomas Schmitt <scdbackup@gmx.net>
+ Provided under GPL version 2 or later.
 
  This file bundles variables which disable changes in libburn which are
  not yet completely accepted.

libburn/cleanup.c

@@ -1,15 +1,19 @@
 /*
- cleanup.c , Copyright 2006 Thomas Schmitt <scdbackup@gmx.net>
+ cleanup.c , Copyright 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
 
  A signal handler which cleans up an application and exits.
 
- Provided under GPL license within GPL projects, BSD license elsewise.
+ Provided under GPLv2+ license within GPL projects, BSD license elsewise.
 */
 
 /*
  cc -g -o cleanup -DCleanup_standalonE cleanup.c
 */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <sys/types.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -40,7 +44,8 @@ static int non_signal_list_count=  BURN_OS_NON_SIGNAL_COUNT;
 #else /* ! Cleanup_has_no_libburn_os_H */
 
 
-/* Outdated. Linux only. For backward compatibility with pre-libburn-0.2.3 */
+/* Outdated. GNU/Linux only.
+   For backward compatibility with pre-libburn-0.2.3 */
 
 /* Signals to be caught */
 static int signal_list[]= {
@@ -97,8 +102,8 @@ static int Cleanup_handler_exit(int exit_value, int signum, int flag)
        return(2);
    }
  if(cleanup_exiting) {
-   fprintf(stderr,"cleanup: ABORT : repeat by pid=%d, signum=%d\n",
-           getpid(),signum);
+   fprintf(stderr,"cleanup: ABORT : repeat by pid=%.f, signum=%d\n",
+           (double) getpid(), signum);
    return(0);
  }
  cleanup_exiting= 1;
@@ -200,9 +205,10 @@ main()
  Cleanup_set_handlers(&demoapp,(Cleanup_app_handler_T) Demo_app_handler,0);
 
  if(1) { /* change to 0 in order to wait for external signals */
-   char *cpt= NULL,c;
+   char *cpt= NULL, c= ' ';
    printf("Intentionally provoking SIGSEGV ...\n");
    c= *cpt;
+   printf("Strange: The system ignored a SIGSEGV: c= %u\n", (unsigned int) c);
  } else {
    printf("killme: %d\n",getpid());
    sleep(3600);

libburn/cleanup.h

@@ -3,7 +3,7 @@
 
  A signal handler which cleans up an application and exits.
 
- Provided under GPL license within GPL projects, BSD license elsewise.
+ Provided under GPLv2+ within GPL projects, BSD license elsewise.
 */
 
 #ifndef Cleanup_includeD

libburn/crc.c

@@ -1,5 +1,9 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include "crc.h"
 
 static unsigned short ccitt_table[256] = {
@@ -104,6 +108,15 @@ unsigned long crc32_table[256] = {
 	0x71C0FC00L, 0xE151FD01L, 0xE0E1FE01L, 0x7070FF00L
 };
 
+
+/* Exploration ts B00214 :
+   ECMA-130, 22.3.6 "CRC field"
+   Generating polynomial: x^16 + x^12 + x^5 + 1
+   Also known as CRC-16-CCITT, CRC-CCITT 
+
+   Use in libburn for raw write modes in sector.c.
+   There is also disabled code in read.c which would use it.
+*/
 unsigned short crc_ccitt(unsigned char *q, int len)
 {
 	unsigned short crc = 0;
@@ -112,6 +125,20 @@ unsigned short crc_ccitt(unsigned char *q, int len)
 		crc = ccitt_table[(crc >> 8 ^ *q++) & 0xff] ^ (crc << 8);
 	return ~crc;
 }
+
+
+/* Exploration ts B00214 :
+   ECMA-130, 14.3 "EDC field"
+   "The EDC codeword must be divisible by the check polynomial:
+    P(x) = (x^16 + x^15 + x^2 + 1) . (x^16 + x^2 + x + 1)   
+   "
+
+   >>> Test whether this coincides with CRC-32 IEEE 802.3
+   x^32 + x^26 + x^23 + x^22 + x^16 + x^12 + x^11 + x^10
+   + x^8 + x^7 + x^5 + x^4 + x^2 + x + 1
+
+   Used for raw writing in sector.c
+*/
 unsigned int crc_32(unsigned char *data, int len)
 {
 	unsigned int crc = 0;

libburn/crc.h

@@ -3,7 +3,21 @@
 #ifndef BURN__CRC_H
 #define BURN__CRC_H
 
+
+#ifdef Xorriso_standalonE
+/* Source module crc.c of yet unclear ancestry is excluded from GNU xorriso */
+#ifndef Libburn_no_crc_C
+#define Libburn_no_crc_C 1
+#endif
+#endif
+
+
+#ifndef Libburn_no_crc_C
+
 unsigned short crc_ccitt(unsigned char *, int len);
 unsigned int crc_32(unsigned char *, int len);
 
+#endif /* Libburn_no_crc_C */
+
+
 #endif /* BURN__CRC_H */

libburn/ddlpa.c

@@ -22,6 +22,10 @@
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>

libburn/debug.c

@@ -1,5 +1,14 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+
 #ifdef WIN32
 #include <windows.h>
 #endif
@@ -16,20 +25,4 @@ void burn_set_verbosity(int v)
 	burn_verbosity = v;
 }
 
-void burn_print(int level, const char *a, ...)
-{
-#ifdef WIN32
-	char debug_string_data[256];
-#endif
-	va_list vl;
 
-	if (level <= burn_verbosity) {
-		va_start(vl, a);
-#ifdef WIN32
-		vsprintf(debug_string_data, a, vl);
-		OutputDebugString(debug_string_data);
-#else
-		vfprintf(stderr, a, vl);
-#endif
-	}
-}

libburn/drive.h

@@ -1,11 +1,18 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
 #ifndef __DRIVE
 #define __DRIVE
 
 #include "libburn.h"
 #include "toc.h"
 #include "structure.h"
+#include <pthread.h>
 
 struct burn_drive;
 struct command;
@@ -43,7 +50,8 @@ unsigned int burn_drive_count(void);
 
 /* ts A61007 */
 /* void burn_wait_all(void); */
-int burn_drives_are_clear(void);
+/* @param flag  bit0= demand freed drives (else released drives) */
+int burn_drives_are_clear(int flag);
 
 int burn_sector_length_write(struct burn_drive *d);
 int burn_track_control(struct burn_drive *d, int);
@@ -52,8 +60,10 @@ void burn_write_empty_subcode(int fd);
 void burn_drive_free(struct burn_drive *d);
 void burn_drive_free_all(void);
 
+/* @param flag bit0= reset global drive list */
 int burn_drive_scan_sync(struct burn_drive_info *drives[],
-			 unsigned int *n_drives);
+			 unsigned int *n_drives, int flag);
+
 void burn_disc_erase_sync(struct burn_drive *d, int fast);
 int burn_drive_get_block_types(struct burn_drive *d,
 			       enum burn_write_types write_type);
@@ -75,7 +85,7 @@ struct burn_drive *burn_drive_finish_enum(struct burn_drive *d);
 int burn_drive_inquire_media(struct burn_drive *d);
 
 /* ts A61125 : model aspects of burn_drive_release */
-int burn_drive_mark_unready(struct burn_drive *d);
+int burn_drive_mark_unready(struct burn_drive *d, int flag);
 
 
 /* ts A61226 */
@@ -111,4 +121,38 @@ int burn_disc_get_write_mode_demands(struct burn_disc *disc,
 			struct burn_write_opts *opts,
 			struct burn_disc_mode_demands *result, int flag);
 
+
+/* ts A70924 : convert a special stdio address into fd number.
+   @return >0 is a valid fd , -1 indicates unsuitable address string. 
+*/
+int burn_drive__fd_from_special_adr(char *adr);
+
+
+/* ts A70929 : Find the drive which is being worked on by pid , tid */
+int burn_drive_find_by_thread_pid(struct burn_drive **d, pid_t pid,
+					pthread_t tid);
+
+
+/* ts A51221 - A80731 : Whitelist inquiry functions */
+int burn_drive_is_banned(char *device_address);
+int burn_drive_whitelist_count(void);
+char *burn_drive_whitelist_item(int idx, int flag);
+
+
+/* ts A80801 */
+int burn_drive_is_listed(char *path, struct burn_drive **found, int flag);
+
+
+/* ts B00226 : Outsourced backend of burn_abort()
+   @param elapsed  to be subtracted from start time
+   @param flag     bit0= do not shutdown the library
+*/ 
+int burn_abort_5(int patience,
+               int (*pacifier_func)(void *handle, int patience, int elapsed),
+               void *handle, int elapsed, int flag);
+
+/* ts B10730 */
+/* Send a default mode page 05 to CD and DVD-R-oids */
+int burn_drive_send_default_page_05(struct burn_drive *d, int flag);
+
 #endif /* __DRIVE */

libburn/ecma130ab.c

@@ -0,0 +1,855 @@
+
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+/* ts A91016 : libburn/ecma130ab.c is the replacement for old libburn/lec.c
+
+   Copyright 2009, Thomas Schmitt <scdbackup@gmx.net>, libburnia-project.org
+   Provided under GPL version 2 or later.
+
+   This code module implements the production of RSPC parity bytes (P- and Q-
+   parity) and the scrambling of raw CD-ROM sectors as specified in ECMA-130:
+     http://www.ecma-international.org/publications/files/ECMA-ST/Ecma-130.pdf
+
+   The following statements about Galois Fields have been learned mostly from
+     http://www.cs.utk.edu/~plank/plank/papers/CS-96-332.pdf
+   by James S. Plank after an e-mail exchange with Norbert Preining.
+
+   The output has been compared with the output of the old code of libburn
+   which was labeled "borrowed HEAVILY from cdrdao" and claimed by Joerg
+   Schilling to stem from code by Heiko Eissfeldt.
+
+   -------------------------------------------------------------------------
+   Note: In this text, "^" denotes exponentiation and not the binary exor
+         operation. Confusingly in the C code "^" is said exor.
+   Note: This is not C1, C2 which is rather mentioned in ECMA-130 Annex C and
+         always performed inside the drive.
+   -------------------------------------------------------------------------
+
+
+                            RSPC resp. P- and Q-Parity
+
+   ECMA-130 Annex A prescribes to compute the parity bytes for P-columns and
+   Q-diagonals by RSPC based on a Galois Field GF(2^8) with enumerating
+   polynomials x^8+x^4+x^3+x^2+1 (i.e. 0x11d) and x^1 (i.e. 0x02).
+   Bytes 12 to 2075 of a audio-sized sector get ordered in two byte words
+   as 24 rows and 43 columns. Then this matrix is split into a LSB matrix
+   and a MSB matrix of the same layout. Parity bytes are to be computed
+   from these 8-bit values.
+   2 P-bytes cover each column of 24 bytes. They get appended to the matrix
+   as rows 24 and 25.
+   2 Q-bytes cover each the 26 diagonals of the extended matrix.
+
+   Both parity byte pairs have to be computed so that extended rows or
+   diagonals match this linear equation:
+      H x V = (0,0)
+   H is a 2-row matrix of size n matching the length of the V ectors
+     [   1        1     ...   1   1 ]
+     [ x^(n-1)  x^(n-2)      x^1  1 ]
+   Vp represents a P-row. It is a byte vector consisting of row bytes at
+   position 0 to 23 and the two parity bytes which shall be determined
+   at position 24 and 25. So Hp has 26 columns.
+   Vq represents a Q-diagonal. It is a byte vector consisting of diagonal
+   bytes at position 0 to 42 and the two parity bytes at position 43 and 44.
+   So Hq has 45 columns. The Q-diagonals cover P-parity bytes.
+
+   By applying some high school algebra one gets the parity bytes b0, b1 of
+   vector V = (n_payload_bytes, b0 , b1) as
+
+     b0 = ( H[n] * SUM(n_payload_bytes) - H[0..(n-1)] x n_payload_bytes )
+          / (H[n+1] - H[n])
+     b1 = - SUM(n_payload_bytes) - b0
+
+   H[i] is the i-the element of the second row of matrix H. E.g. H[0] = x^(n-1)
+   The result has to be computed by Galois field arithmetics. See below.
+
+   The P-parity bytes of each column get reunited as LSB and MSB of two words.
+   word1 gets written to positions 1032 to 1074, word0 to 1075 to 1117.
+   The Q-parity bytes of each diagonal get reunited too. word1 goes to 1118
+   to 1143, word0 to 1144 to 1169.
+   >>> I do not read this swap of word1 and word0 from ECMA-130 Annex A.
+   >>> But the new output matches the old output only if it is done that way.
+   >>> See correctness reservation below.
+
+   Algebra on Galois fields is the same as on Rational Numbers.
+   But arithmetics is defined by operations on polynomials rather than the
+   usual integer arithmetics on binary numbers.
+   Addition and subtraction are identical with the binary exor operator.
+   Multiplication and division would demand polynomial division, e.g. by the
+   euclidian algorithm. The computing path over logarithms and powers follows
+   algebra and allows to reduce the arithmetic task to table lookups, additions
+   modulo 255, and exor operations. Note that the logarithms are natural
+   numbers, not polynomials. They get added or subtracted by the usual addition
+   (not by exor) and their polynomial power depends on their value modulo 255.
+
+   Needed are a logarithm table and a power table (or inverse logarithm table)
+   for Galois Field GF(2^8) which will serve to perform the peculiar
+   multiplication and division operation of Galois fields.
+
+   The power table is simply an enumeration of x^n accorting to
+   GF-multiplication. It also serves as second line of matrix H for the parity
+   equations:
+     Hp[i] = gfpow[25-i] , i out of {0,..,25}
+     Hq[i] = gfpow[44-i] , i out of {0,..,44}
+
+   The logarithm table is the inverse permutation of the power table.
+
+   Some simplifications apply to the implementation:
+   In the world of Galois fields there is no difference between - and +.
+   The term (H[n+1] - H[n]) is constant: 3.
+
+   -------------------------------------------------------------------------
+
+
+                                 Scrambling
+
+   ECMA-130 Annex B prescribes to exor the byte stream of an audio-sized sector
+   with a sequence of pseudo random bytes. It mentions polynomial x^15+x+1 and
+   a 15-bit register.
+   It shows a diagram of a Feedback Shift Register with 16 bit boxes, though.
+ 
+   Comparing this with explanations in 
+     http://www.newwaveinstruments.com/resources/articles/m_sequence_linear_feedback_shift_register_lfsr.htm
+   one can recognize the diagram as a Fibonacci Implementation. But there seems
+   really to be one bit box too many.
+
+   The difference of both lengths is expressed in function next_bit() by
+   the constants 0x3fff,0x4000 for 15 bit versus 0x7fff,0x8000 for 16 bits.
+   Comparing the output of both alternatives with the old scrambler output
+   lets 15 bit win for now.
+
+   So the prescription is to start with 15 bit value 1, to use the lowest bit
+   as output, to shift the bits down by one, to exor the output bit with the
+   next lowest bit, and to put that exor result into bit 14 of the register.
+
+   -------------------------------------------------------------------------
+
+
+                             Correctness Reservation
+
+   In both cases, parity and scrambling, the goal for now is to replicate the
+   output of the dismissed old lec.c by output which is based on published
+   specs and own implementation code. Whether they comply to ECMA-130 is a
+   different question which can only be answered by real test cases for
+   raw CD recording.
+
+   Of course this implementation will be corrected so that it really complies
+   to ECMA-130 as soon as evidence emerges that it does not yet.
+
+*/
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* Power and logarithm tables for GF(2^8), parity matrices for ECMA-130.
+   Generated by burn_rspc_setup_tables() and burn_rspc_print_tables().
+
+   The highest possible sum of gflog[] values is is 508. So the table gfpow[]
+   with period 255 was manually unrolled to 509 elements to avoid one modulo
+   255 operation in burn_rspc_mult().
+   Proposed by D. Hugh Redelmeier.
+   
+*/
+
+static unsigned char gfpow[509] = {
+	  1,   2,   4,   8,  16,  32,  64, 128,  29,  58, 
+	116, 232, 205, 135,  19,  38,  76, 152,  45,  90, 
+	180, 117, 234, 201, 143,   3,   6,  12,  24,  48, 
+	 96, 192, 157,  39,  78, 156,  37,  74, 148,  53, 
+	106, 212, 181, 119, 238, 193, 159,  35,  70, 140, 
+	  5,  10,  20,  40,  80, 160,  93, 186, 105, 210, 
+	185, 111, 222, 161,  95, 190,  97, 194, 153,  47, 
+	 94, 188, 101, 202, 137,  15,  30,  60, 120, 240, 
+	253, 231, 211, 187, 107, 214, 177, 127, 254, 225, 
+	223, 163,  91, 182, 113, 226, 217, 175,  67, 134, 
+	 17,  34,  68, 136,  13,  26,  52, 104, 208, 189, 
+	103, 206, 129,  31,  62, 124, 248, 237, 199, 147, 
+	 59, 118, 236, 197, 151,  51, 102, 204, 133,  23, 
+	 46,  92, 184, 109, 218, 169,  79, 158,  33,  66, 
+	132,  21,  42,  84, 168,  77, 154,  41,  82, 164, 
+	 85, 170,  73, 146,  57, 114, 228, 213, 183, 115, 
+	230, 209, 191,  99, 198, 145,  63, 126, 252, 229, 
+	215, 179, 123, 246, 241, 255, 227, 219, 171,  75, 
+	150,  49,  98, 196, 149,  55, 110, 220, 165,  87, 
+	174,  65, 130,  25,  50, 100, 200, 141,   7,  14, 
+	 28,  56, 112, 224, 221, 167,  83, 166,  81, 162, 
+	 89, 178, 121, 242, 249, 239, 195, 155,  43,  86, 
+	172,  69, 138,   9,  18,  36,  72, 144,  61, 122, 
+	244, 245, 247, 243, 251, 235, 203, 139,  11,  22, 
+	 44,  88, 176, 125, 250, 233, 207, 131,  27,  54, 
+	108, 216, 173,  71, 142,
+	  1,   2,   4,   8,  16,  32,  64, 128,  29,  58, 
+	116, 232, 205, 135,  19,  38,  76, 152,  45,  90, 
+	180, 117, 234, 201, 143,   3,   6,  12,  24,  48, 
+	 96, 192, 157,  39,  78, 156,  37,  74, 148,  53, 
+	106, 212, 181, 119, 238, 193, 159,  35,  70, 140, 
+	  5,  10,  20,  40,  80, 160,  93, 186, 105, 210, 
+	185, 111, 222, 161,  95, 190,  97, 194, 153,  47, 
+	 94, 188, 101, 202, 137,  15,  30,  60, 120, 240, 
+	253, 231, 211, 187, 107, 214, 177, 127, 254, 225, 
+	223, 163,  91, 182, 113, 226, 217, 175,  67, 134, 
+	 17,  34,  68, 136,  13,  26,  52, 104, 208, 189, 
+	103, 206, 129,  31,  62, 124, 248, 237, 199, 147, 
+	 59, 118, 236, 197, 151,  51, 102, 204, 133,  23, 
+	 46,  92, 184, 109, 218, 169,  79, 158,  33,  66, 
+	132,  21,  42,  84, 168,  77, 154,  41,  82, 164, 
+	 85, 170,  73, 146,  57, 114, 228, 213, 183, 115, 
+	230, 209, 191,  99, 198, 145,  63, 126, 252, 229, 
+	215, 179, 123, 246, 241, 255, 227, 219, 171,  75, 
+	150,  49,  98, 196, 149,  55, 110, 220, 165,  87, 
+	174,  65, 130,  25,  50, 100, 200, 141,   7,  14, 
+	 28,  56, 112, 224, 221, 167,  83, 166,  81, 162, 
+	 89, 178, 121, 242, 249, 239, 195, 155,  43,  86, 
+	172,  69, 138,   9,  18,  36,  72, 144,  61, 122, 
+	244, 245, 247, 243, 251, 235, 203, 139,  11,  22, 
+	 44,  88, 176, 125, 250, 233, 207, 131,  27,  54, 
+	108, 216, 173,  71,
+};
+
+static unsigned char gflog[256] = {
+	   0,   0,   1,  25,   2,  50,  26, 198,   3, 223,
+	  51, 238,  27, 104, 199,  75,   4, 100, 224,  14,
+	  52, 141, 239, 129,  28, 193, 105, 248, 200,   8,
+	  76, 113,   5, 138, 101,  47, 225,  36,  15,  33,
+	  53, 147, 142, 218, 240,  18, 130,  69,  29, 181,
+	 194, 125, 106,  39, 249, 185, 201, 154,   9, 120,
+	  77, 228, 114, 166,   6, 191, 139,  98, 102, 221,
+	  48, 253, 226, 152,  37, 179,  16, 145,  34, 136,
+	  54, 208, 148, 206, 143, 150, 219, 189, 241, 210,
+	  19,  92, 131,  56,  70,  64,  30,  66, 182, 163,
+	 195,  72, 126, 110, 107,  58,  40,  84, 250, 133,
+	 186,  61, 202,  94, 155, 159,  10,  21, 121,  43,
+	  78, 212, 229, 172, 115, 243, 167,  87,   7, 112,
+	 192, 247, 140, 128,  99,  13, 103,  74, 222, 237,
+	  49, 197, 254,  24, 227, 165, 153, 119,  38, 184,
+	 180, 124,  17,  68, 146, 217,  35,  32, 137,  46,
+	  55,  63, 209,  91, 149, 188, 207, 205, 144, 135,
+	 151, 178, 220, 252, 190,  97, 242,  86, 211, 171,
+	  20,  42,  93, 158, 132,  60,  57,  83,  71, 109,
+	  65, 162,  31,  45,  67, 216, 183, 123, 164, 118,
+	 196,  23,  73, 236, 127,  12, 111, 246, 108, 161,
+	  59,  82,  41, 157,  85, 170, 251,  96, 134, 177,
+	 187, 204,  62,  90, 203,  89,  95, 176, 156, 169,
+	 160,  81,  11, 245,  22, 235, 122, 117,  44, 215,
+	  79, 174, 213, 233, 230, 231, 173, 232, 116, 214,
+	 244, 234, 168,  80,  88, 175
+};
+
+
+#define Libburn_use_h_matriceS 1
+
+#ifdef Libburn_use_h_matriceS
+
+/* On my AMD 2x64 bit 3000 MHz processor h[i] costs about 7 % more time
+   than using gfpow[25-i] resp. gfpow[44-1]. I blame this on the more
+   condensed data representation which slightly increases the rate of cache
+   hits.
+   Nevertheless this effect is very likely depending on the exact cache
+   size and architecture. In general, using h[] saves more than 8000
+   subtractions per sector.
+*/
+
+/* Parity matrices H as prescribed by ECMA-130 Annex A.
+   Actually just reverted order start pieces of gfpow[].
+*/
+static unsigned char h26[26] = {
+           3, 143, 201, 234, 117, 180,  90,  45, 152,  76,
+          38,  19, 135, 205, 232, 116,  58,  29, 128,  64,
+          32,  16,   8,   4,   2,   1,
+};
+
+static unsigned char h45[45] = {
+         238, 119, 181, 212, 106,  53, 148,  74,  37, 156,
+          78,  39, 157, 192,  96,  48,  24,  12,   6,   3,
+         143, 201, 234, 117, 180,  90,  45, 152,  76,  38,
+          19, 135, 205, 232, 116,  58,  29, 128,  64,  32,
+          16,   8,   4,   2,   1,
+};
+
+#endif /* Libburn_use_h_matriceS */
+
+
+/* Pseudo-random bytes which of course are exactly the same as with the
+   previously used code.
+   Generated by function print_ecma_130_scrambler().
+*/
+static unsigned char ecma_130_annex_b[2340] = {
+	  1, 128,   0,  96,   0,  40,   0,  30, 128,   8, 
+	 96,   6, 168,   2, 254, 129, 128,  96,  96,  40, 
+	 40,  30, 158, 136, 104, 102, 174, 170, 252, 127, 
+	  1, 224,   0,  72,   0,  54, 128,  22, 224,  14, 
+	200,   4,  86, 131, 126, 225, 224,  72,  72,  54, 
+	182, 150, 246, 238, 198, 204,  82, 213, 253, 159, 
+	  1, 168,   0, 126, 128,  32,  96,  24,  40,  10, 
+	158, 135,  40,  98, 158, 169, 168, 126, 254, 160, 
+	 64, 120,  48,  34, 148,  25, 175,  74, 252,  55, 
+	  1, 214, 128,  94, 224,  56,  72,  18, 182, 141, 
+	182, 229, 182, 203,  54, 215,  86, 222, 190, 216, 
+	112,  90, 164,  59,  59,  83,  83, 125, 253, 225, 
+	129, 136,  96, 102, 168,  42, 254, 159,   0, 104, 
+	  0,  46, 128,  28,  96,   9, 232,   6, 206, 130, 
+	212,  97, 159, 104, 104,  46, 174, 156, 124, 105, 
+	225, 238, 200,  76,  86, 181, 254, 247,   0,  70, 
+	128,  50, 224,  21, 136,  15,  38, 132,  26, 227, 
+	 75,   9, 247,  70, 198, 178, 210, 245, 157, 135, 
+	 41, 162, 158, 249, 168,  66, 254, 177, 128, 116, 
+	 96,  39, 104,  26, 174, 139,  60, 103,  81, 234, 
+	188,  79,  49, 244,  20,  71,  79, 114, 180,  37, 
+	183,  91,  54, 187,  86, 243, 126, 197, 224,  83, 
+	  8,  61, 198, 145, 146, 236, 109, 141, 237, 165, 
+	141, 187,  37, 179,  91,  53, 251,  87,   3, 126, 
+	129, 224,  96,  72,  40,  54, 158, 150, 232, 110, 
+	206, 172,  84, 125, 255,  97, 128,  40,  96,  30, 
+	168,   8, 126, 134, 160,  98, 248,  41, 130, 158, 
+	225, 168,  72, 126, 182, 160, 118, 248,  38, 194, 
+	154, 209, 171,  28, 127,  73, 224,  54, 200,  22, 
+	214, 142, 222, 228,  88,  75, 122, 183,  99,  54, 
+	169, 214, 254, 222, 192,  88,  80,  58, 188,  19, 
+	 49, 205, 212,  85, 159, 127,  40,  32,  30, 152, 
+	  8, 106, 134, 175,  34, 252,  25, 129, 202, 224, 
+	 87,   8,  62, 134, 144,  98, 236,  41, 141, 222, 
+	229, 152,  75,  42, 183,  95,  54, 184,  22, 242, 
+	142, 197, 164,  83,  59, 125, 211,  97, 157, 232, 
+	105, 142, 174, 228, 124,  75,  97, 247, 104,  70, 
+	174, 178, 252, 117, 129, 231,  32,  74, 152,  55, 
+	 42, 150, 159,  46, 232,  28,  78, 137, 244, 102, 
+	199, 106, 210, 175,  29, 188,   9, 177, 198, 244, 
+	 82, 199, 125, 146, 161, 173, 184, 125, 178, 161, 
+	181, 184, 119,  50, 166, 149, 186, 239,  51,  12, 
+	 21, 197, 207,  19,  20,  13, 207,  69, 148,  51, 
+	 47,  85, 220,  63,  25, 208,  10, 220,   7,  25, 
+	194, 138, 209, 167,  28, 122, 137, 227,  38, 201, 
+	218, 214, 219,  30, 219,  72,  91, 118, 187, 102, 
+	243, 106, 197, 239,  19,  12,  13, 197, 197, 147, 
+	 19,  45, 205, 221, 149, 153, 175,  42, 252,  31, 
+	  1, 200,   0,  86, 128,  62, 224,  16,  72,  12, 
+	 54, 133, 214, 227,  30, 201, 200,  86, 214, 190, 
+	222, 240,  88,  68,  58, 179,  83,  53, 253, 215, 
+	  1, 158, 128, 104,  96,  46, 168,  28, 126, 137, 
+	224, 102, 200,  42, 214, 159,  30, 232,   8,  78, 
+	134, 180,  98, 247, 105, 134, 174, 226, 252,  73, 
+	129, 246, 224,  70, 200,  50, 214, 149, 158, 239, 
+	 40,  76,  30, 181, 200, 119,  22, 166, 142, 250, 
+	228,  67,  11, 113, 199, 100,  82, 171, 125, 191, 
+	 97, 176,  40, 116,  30, 167,  72, 122, 182, 163, 
+	 54, 249, 214, 194, 222, 209, 152,  92, 106, 185, 
+	239,  50, 204,  21, 149, 207,  47,  20,  28,  15, 
+	 73, 196,  54, 211,  86, 221, 254, 217, 128,  90, 
+	224,  59,   8,  19,  70, 141, 242, 229, 133, 139, 
+	 35,  39,  89, 218, 186, 219,  51,  27,  85, 203, 
+	127,  23,  96,  14, 168,   4, 126, 131,  96,  97, 
+	232,  40,  78, 158, 180, 104, 119, 110, 166, 172, 
+	122, 253, 227,   1, 137, 192, 102, 208,  42, 220, 
+	 31,  25, 200,  10, 214, 135,  30, 226, 136,  73, 
+	166, 182, 250, 246, 195,   6, 209, 194, 220,  81, 
+	153, 252, 106, 193, 239,  16,  76,  12,  53, 197, 
+	215,  19,  30, 141, 200, 101, 150, 171,  46, 255, 
+	 92,  64,  57, 240,  18, 196,  13, 147,  69, 173, 
+	243,  61, 133, 209, 163,  28, 121, 201, 226, 214, 
+	201, 158, 214, 232,  94, 206, 184,  84, 114, 191, 
+	101, 176,  43,  52,  31,  87,  72,  62, 182, 144, 
+	118, 236,  38, 205, 218, 213, 155,  31,  43,  72, 
+	 31, 118, 136,  38, 230, 154, 202, 235,  23,  15, 
+	 78, 132,  52,  99,  87, 105, 254, 174, 192, 124, 
+	 80,  33, 252,  24,  65, 202, 176,  87,  52,  62, 
+	151,  80, 110, 188,  44, 113, 221, 228,  89, 139, 
+	122, 231,  99,  10, 169, 199,  62, 210, 144,  93, 
+	172,  57, 189, 210, 241, 157, 132, 105, 163, 110, 
+	249, 236,  66, 205, 241, 149, 132, 111,  35, 108, 
+	 25, 237, 202, 205, 151,  21, 174, 143,  60, 100, 
+	 17, 235,  76,  79, 117, 244,  39,   7,  90, 130, 
+	187,  33, 179,  88, 117, 250, 167,   3,  58, 129, 
+	211,  32,  93, 216,  57, 154, 146, 235,  45, 143, 
+	 93, 164,  57, 187,  82, 243, 125, 133, 225, 163, 
+	  8, 121, 198, 162, 210, 249, 157, 130, 233, 161, 
+	142, 248, 100,  66, 171, 113, 191, 100, 112,  43, 
+	100,  31, 107,  72,  47, 118, 156,  38, 233, 218, 
+	206, 219,  20,  91,  79, 123, 116,  35, 103,  89, 
+	234, 186, 207,  51,  20,  21, 207,  79,  20,  52, 
+	 15,  87,  68,  62, 179,  80, 117, 252,  39,   1, 
+	218, 128,  91,  32,  59,  88,  19, 122, 141, 227, 
+	 37, 137, 219,  38, 219,  90, 219, 123,  27,  99, 
+	 75, 105, 247, 110, 198, 172,  82, 253, 253, 129, 
+	129, 160,  96, 120,  40,  34, 158, 153, 168, 106, 
+	254, 175,   0, 124,   0,  33, 192,  24,  80,  10, 
+	188,   7,  49, 194, 148,  81, 175, 124, 124,  33, 
+	225, 216,  72,  90, 182, 187,  54, 243,  86, 197, 
+	254, 211,   0,  93, 192,  57, 144,  18, 236,  13, 
+	141, 197, 165, 147,  59,  45, 211,  93, 157, 249, 
+	169, 130, 254, 225, 128,  72,  96,  54, 168,  22, 
+	254, 142, 192, 100,  80,  43, 124,  31,  97, 200, 
+	 40,  86, 158, 190, 232, 112,  78, 164,  52, 123, 
+	 87,  99, 126, 169, 224, 126, 200,  32,  86, 152, 
+	 62, 234, 144,  79,  44,  52,  29, 215,  73, 158, 
+	182, 232, 118, 206, 166, 212, 122, 223,  99,  24, 
+	 41, 202, 158, 215,  40,  94, 158, 184, 104, 114, 
+	174, 165, 188, 123,  49, 227,  84,  73, 255, 118, 
+	192,  38, 208,  26, 220,  11,  25, 199,  74, 210, 
+	183,  29, 182, 137, 182, 230, 246, 202, 198, 215, 
+	 18, 222, 141, 152, 101, 170, 171,  63,  63,  80, 
+	 16,  60,  12,  17, 197, 204,  83,  21, 253, 207, 
+	  1, 148,   0, 111,  64,  44,  48,  29, 212,   9, 
+	159,  70, 232,  50, 206, 149, 148, 111,  47, 108, 
+	 28,  45, 201, 221, 150, 217, 174, 218, 252,  91, 
+	  1, 251,  64,  67, 112,  49, 228,  20,  75,  79, 
+	119, 116,  38, 167,  90, 250, 187,   3,  51,  65, 
+	213, 240,  95,   4,  56,   3,  82, 129, 253, 160, 
+	 65, 184,  48, 114, 148,  37, 175,  91,  60,  59, 
+	 81, 211, 124,  93, 225, 249, 136,  66, 230, 177, 
+	138, 244, 103,   7, 106, 130, 175,  33, 188,  24, 
+	113, 202, 164,  87,  59, 126, 147,  96, 109, 232, 
+	 45, 142, 157, 164, 105, 187, 110, 243, 108,  69, 
+	237, 243,  13, 133, 197, 163,  19,  57, 205, 210, 
+	213, 157, 159,  41, 168,  30, 254, 136,  64, 102, 
+	176,  42, 244,  31,   7,  72,   2, 182, 129, 182, 
+	224, 118, 200,  38, 214, 154, 222, 235,  24,  79, 
+	 74, 180,  55,  55,  86, 150, 190, 238, 240,  76, 
+	 68,  53, 243,  87,   5, 254, 131,   0,  97, 192, 
+	 40,  80,  30, 188,   8, 113, 198, 164,  82, 251, 
+	125, 131,  97, 161, 232, 120,  78, 162, 180, 121, 
+	183,  98, 246, 169, 134, 254, 226, 192,  73, 144, 
+	 54, 236,  22, 205, 206, 213, 148,  95,  47, 120, 
+	 28,  34, 137, 217, 166, 218, 250, 219,   3,  27, 
+	 65, 203, 112,  87, 100,  62, 171,  80, 127, 124, 
+	 32,  33, 216,  24,  90, 138, 187,  39,  51,  90, 
+	149, 251,  47,   3,  92,   1, 249, 192,  66, 208, 
+	 49, 156,  20, 105, 207, 110, 212,  44,  95,  93, 
+	248,  57, 130, 146, 225, 173, 136, 125, 166, 161, 
+	186, 248, 115,   2, 165, 193, 187,  16, 115,  76, 
+	 37, 245, 219,   7,  27,  66, 139, 113, 167, 100, 
+	122, 171,  99,  63, 105, 208,  46, 220,  28,  89, 
+	201, 250, 214, 195,  30, 209, 200,  92,  86, 185, 
+	254, 242, 192,  69, 144,  51,  44,  21, 221, 207, 
+	 25, 148,  10, 239,  71,  12,  50, 133, 213, 163, 
+	 31,  57, 200,  18, 214, 141, 158, 229, 168,  75, 
+	 62, 183,  80, 118, 188,  38, 241, 218, 196,  91, 
+	 19, 123,  77, 227, 117, 137, 231,  38, 202, 154, 
+	215,  43,  30, 159,  72, 104,  54, 174, 150, 252, 
+	110, 193, 236,  80,  77, 252,  53, 129, 215,  32, 
+	 94, 152,  56, 106, 146, 175,  45, 188,  29, 177, 
+	201, 180,  86, 247, 126, 198, 160,  82, 248,  61, 
+	130, 145, 161, 172, 120, 125, 226, 161, 137, 184, 
+	102, 242, 170, 197, 191,  19,  48,  13, 212,   5, 
+	159,  67,  40,  49, 222, 148,  88, 111, 122, 172, 
+	 35,  61, 217, 209, 154, 220, 107,  25, 239,  74, 
+	204,  55,  21, 214, 143,  30, 228,   8,  75,  70, 
+	183, 114, 246, 165, 134, 251,  34, 195,  89, 145, 
+	250, 236,  67,  13, 241, 197, 132,  83,  35, 125, 
+	217, 225, 154, 200, 107,  22, 175,  78, 252,  52, 
+	 65, 215, 112,  94, 164,  56, 123,  82, 163, 125, 
+	185, 225, 178, 200, 117, 150, 167,  46, 250, 156, 
+	 67,  41, 241, 222, 196,  88,  83, 122, 189, 227, 
+	 49, 137, 212, 102, 223, 106, 216,  47,  26, 156, 
+	 11,  41, 199,  94, 210, 184,  93, 178, 185, 181, 
+	178, 247,  53, 134, 151,  34, 238, 153, 140, 106, 
+	229, 239,  11,  12,   7,  69, 194, 179,  17, 181, 
+	204, 119,  21, 230, 143,  10, 228,   7,  11,  66, 
+	135, 113, 162, 164, 121, 187,  98, 243, 105, 133, 
+	238, 227,  12,  73, 197, 246, 211,   6, 221, 194, 
+	217, 145, 154, 236, 107,  13, 239,  69, 140,  51, 
+	 37, 213, 219,  31,  27,  72,  11, 118, 135, 102, 
+	226, 170, 201, 191,  22, 240,  14, 196,   4,  83, 
+	 67, 125, 241, 225, 132,  72,  99, 118, 169, 230, 
+	254, 202, 192,  87,  16,  62, 140,  16, 101, 204, 
+	 43,  21, 223,  79,  24,  52,  10, 151,  71,  46, 
+	178, 156, 117, 169, 231,  62, 202, 144,  87,  44, 
+	 62, 157, 208, 105, 156,  46, 233, 220,  78, 217, 
+	244,  90, 199, 123,  18, 163,  77, 185, 245, 178, 
+	199,  53, 146, 151,  45, 174, 157, 188, 105, 177, 
+	238, 244,  76,  71, 117, 242, 167,   5, 186, 131, 
+	 51,  33, 213, 216,  95,  26, 184,  11,  50, 135, 
+	 85, 162, 191,  57, 176,  18, 244,  13, 135,  69, 
+	162, 179,  57, 181, 210, 247,  29, 134, 137, 162, 
+	230, 249, 138, 194, 231,  17, 138, 140, 103,  37, 
+	234, 155,  15,  43,  68,  31, 115,  72,  37, 246, 
+	155,   6, 235,  66, 207, 113, 148,  36, 111,  91, 
+	108,  59, 109, 211, 109, 157, 237, 169, 141, 190, 
+	229, 176,  75,  52,  55,  87,  86, 190, 190, 240, 
+	112,  68,  36,  51,  91,  85, 251, 127,   3,  96, 
+	  1, 232,   0,  78, 128,  52,  96,  23, 104,  14, 
+	174, 132, 124,  99,  97, 233, 232,  78, 206, 180, 
+	 84, 119, 127, 102, 160,  42, 248,  31,   2, 136, 
+	  1, 166, 128, 122, 224,  35,   8,  25, 198, 138, 
+	210, 231,  29, 138, 137, 167,  38, 250, 154, 195, 
+	 43,  17, 223,  76,  88,  53, 250, 151,   3,  46, 
+	129, 220,  96,  89, 232,  58, 206, 147,  20, 109, 
+	207, 109, 148,  45, 175,  93, 188,  57, 177, 210, 
+	244,  93, 135, 121, 162, 162, 249, 185, 130, 242, 
+	225, 133, 136,  99,  38, 169, 218, 254, 219,   0, 
+	 91,  64,  59, 112,  19, 100,  13, 235,  69, 143, 
+	115,  36,  37, 219,  91,  27, 123,  75,  99, 119, 
+	105, 230, 174, 202, 252,  87,   1, 254, 128,  64, 
+	 96,  48,  40,  20,  30, 143,  72, 100,  54, 171, 
+	 86, 255, 126, 192,  32,  80,  24,  60,  10, 145, 
+	199,  44,  82, 157, 253, 169, 129, 190, 224, 112, 
+	 72,  36,  54, 155,  86, 235, 126, 207,  96,  84, 
+	 40,  63,  94, 144,  56, 108,  18, 173, 205, 189, 
+	149, 177, 175,  52, 124,  23,  97, 206, 168,  84, 
+	126, 191,  96, 112,  40,  36,  30, 155,  72, 107, 
+	118, 175, 102, 252,  42, 193, 223,  16,  88,  12, 
+	 58, 133, 211,  35,  29, 217, 201, 154, 214, 235, 
+	 30, 207,  72,  84,  54, 191,  86, 240,  62, 196, 
+	 16,  83,  76,  61, 245, 209, 135,  28,  98, 137, 
+	233, 166, 206, 250, 212,  67,  31, 113, 200,  36, 
+	 86, 155, 126, 235,  96,  79, 104,  52,  46, 151, 
+	 92, 110, 185, 236, 114, 205, 229, 149, 139,  47, 
+	 39,  92,  26, 185, 203,  50, 215,  85, 158, 191, 
+	 40, 112,  30, 164,   8, 123,  70, 163, 114, 249, 
+	229, 130, 203,  33, 151,  88, 110, 186, 172, 115, 
+	 61, 229, 209, 139,  28, 103,  73, 234, 182, 207, 
+	 54, 212,  22, 223,  78, 216,  52,  90, 151, 123, 
+	 46, 163,  92, 121, 249, 226, 194, 201, 145, 150, 
+	236, 110, 205, 236,  85, 141, 255,  37, 128,  27, 
+	 32,  11,  88,   7, 122, 130, 163,  33, 185, 216, 
+	114, 218, 165, 155,  59,  43,  83,  95, 125, 248, 
+	 33, 130, 152,  97, 170, 168, 127,  62, 160,  16, 
+	120,  12,  34, 133, 217, 163,  26, 249, 203,   2, 
+	215,  65, 158, 176, 104, 116,  46, 167,  92, 122, 
+	185, 227,  50, 201, 213, 150, 223,  46, 216,  28, 
+	 90, 137, 251,  38, 195,  90, 209, 251,  28,  67, 
+	 73, 241, 246, 196,  70, 211, 114, 221, 229, 153
+};
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* This is the new implementation of P- and Q-parity generation.
+   It needs about the same computing time as the old implementation (both
+   with gcc -O2 on AMD 64 bit). Measurements indicate that about 280 MIPS
+   are needed for 48x CD speed (7.1 MB/s).
+*/
+
+static unsigned char burn_rspc_mult(unsigned char a, unsigned char b)
+{
+	if (a == 0 || b == 0)
+		return 0;
+	/* Optimization of (a == 0 || b == 0) by D. Hugh Redelmeier
+	if((((int)a - 1) | ((int)b - 1)) < 0)
+		return 0;
+	*/
+
+        return gfpow[gflog[a] + gflog[b]];
+	/* % 255 not necessary because gfpow is unrolled up to index 510 */
+}
+
+
+/* Divide by polynomial 0x03. Derived from burn_rspc_div() and using the
+   unrolled size of the gfpow[] array.
+*/
+static unsigned char burn_rspc_div_3(unsigned char a)
+{
+	if (a == 0)
+		return 0;
+	return gfpow[230 + gflog[a]];
+}
+
+
+static void burn_rspc_p0p1(unsigned char *sector, int col, 
+                          unsigned char *p0_lsb, unsigned char *p0_msb,
+                          unsigned char *p1_lsb, unsigned char *p1_msb)
+{
+	unsigned char *start, b;
+	unsigned int i, sum_v_lsb = 0, sum_v_msb = 0;
+	unsigned int hxv_lsb = 0, hxv_msb = 0;
+
+	start = sector + 12 + 2 * col;
+	for(i = 0; i < 24; i++) {
+		b = *start;
+		sum_v_lsb ^= b;
+
+#ifdef Libburn_use_h_matriceS
+		hxv_lsb ^= burn_rspc_mult(b, h26[i]);
+#else
+		hxv_lsb ^= burn_rspc_mult(b, gfpow[25 - i]);
+#endif
+
+		b = *(start + 1);
+		sum_v_msb ^= b;
+
+#ifdef Libburn_use_h_matriceS
+		hxv_msb ^= burn_rspc_mult(b, h26[i]);
+#else
+		hxv_msb ^= burn_rspc_mult(b, gfpow[25 - i]);
+#endif
+
+		start += 86;
+	}
+
+				/* 3 = gfpow[1] ^ gfpow[0] , 2 = gfpow[1] */
+	*p0_lsb = burn_rspc_div_3(burn_rspc_mult(2, sum_v_lsb) ^ hxv_lsb);
+	*p0_msb = burn_rspc_div_3(burn_rspc_mult(2, sum_v_msb) ^ hxv_msb);
+	*p1_lsb = sum_v_lsb ^ *p0_lsb;
+	*p1_msb = sum_v_msb ^ *p0_msb;
+}
+
+
+void burn_rspc_parity_p(unsigned char *sector)
+{
+	int i;
+	unsigned char p0_lsb, p0_msb, p1_lsb, p1_msb;
+
+	/* Loop over P columns */
+	for(i = 0; i < 43; i++) {
+		burn_rspc_p0p1(sector, i, &p0_lsb, &p0_msb, &p1_lsb, &p1_msb);
+		sector[2162 + 2 * i]     =  p0_lsb;
+		sector[2162 + 2 * i + 1] =  p0_msb;
+		sector[2076 + 2 * i]     =  p1_lsb;
+		sector[2076 + 2 * i + 1] =  p1_msb;
+
+#ifdef Libburn_with_lec_generatoR
+		if(verbous) {
+			printf("p %2d :  %2.2X  %2.2X  ", i,
+				(unsigned int) p0_lsb, (unsigned int) p0_msb);
+			printf("%2.2X  %2.2X  ",
+				(unsigned int) p1_lsb, (unsigned int) p1_msb);
+			printf("-> %d,%d\n", 2162 + 2 * i, 2076 + 2 * i);
+		}
+#endif /* Libburn_with_lec_generatoR */
+
+	}
+}
+
+
+static void burn_rspc_q0q1(unsigned char *sector, int diag,
+                          unsigned char *q0_lsb, unsigned char *q0_msb,
+                          unsigned char *q1_lsb, unsigned char *q1_msb)
+{
+	unsigned char *start, b;
+	unsigned int i, idx, sum_v_lsb = 0, sum_v_msb = 0;
+	unsigned int hxv_lsb = 0, hxv_msb = 0;
+
+	start = sector + 12;
+	idx = 2 * 43 * diag;
+	for(i = 0; i < 43; i++) {
+		if (idx >= 2236)
+			idx -= 2236;
+		b = start[idx];
+		sum_v_lsb ^= b;
+
+#ifdef Libburn_use_h_matriceS
+		hxv_lsb ^= burn_rspc_mult(b, h45[i]);
+#else
+		hxv_lsb ^= burn_rspc_mult(b, gfpow[44 - i]);
+#endif
+
+		b = start[idx + 1];
+		sum_v_msb ^= b;
+
+#ifdef Libburn_use_h_matriceS
+		hxv_msb ^= burn_rspc_mult(b, h45[i]);
+#else
+		hxv_msb ^= burn_rspc_mult(b, gfpow[44 - i]);
+#endif
+
+		idx += 88;
+	}
+				/* 3 = gfpow[1] ^ gfpow[0] , 2 = gfpow[1] */
+	*q0_lsb = burn_rspc_div_3(burn_rspc_mult(2, sum_v_lsb) ^ hxv_lsb);
+	*q0_msb = burn_rspc_div_3(burn_rspc_mult(2, sum_v_msb) ^ hxv_msb);
+	*q1_lsb = sum_v_lsb ^ *q0_lsb;
+	*q1_msb = sum_v_msb ^ *q0_msb;
+}
+
+
+void burn_rspc_parity_q(unsigned char *sector)
+{
+	int i;
+	unsigned char q0_lsb, q0_msb, q1_lsb, q1_msb;
+
+	/* Loop over Q diagonals */
+	for(i = 0; i < 26; i++) {
+		burn_rspc_q0q1(sector, i, &q0_lsb, &q0_msb, &q1_lsb, &q1_msb);
+		sector[2300 + 2 * i]     =  q0_lsb;
+		sector[2300 + 2 * i + 1] =  q0_msb;
+		sector[2248 + 2 * i]     =  q1_lsb;
+		sector[2248 + 2 * i + 1] =  q1_msb;
+
+#ifdef Libburn_with_lec_generatoR
+		if(verbous) {
+			printf("q %2d :  %2.2X  %2.2X  ", i,
+				(unsigned int) q0_lsb, (unsigned int) q0_msb);
+			printf("%2.2X  %2.2X  ",
+				(unsigned int) q1_lsb, (unsigned int) q1_msb);
+			printf("-> %d,%d\n", 2300 + 2 * i, 2248 + 2 * i);
+		}
+#endif /* Libburn_with_lec_generatoR */
+
+	}
+}
+
+/* ------------------------------------------------------------------------- */
+
+
+/* The new implementation of the ECMA-130 Annex B scrambler.
+   It is totally unoptimized. One should make use of larger word operations. 
+   Measurements indicate that about 50 MIPS are needed for 48x CD speed.
+*/
+
+void burn_ecma130_scramble(unsigned char *sector) 
+{
+        int i;
+	unsigned char *s;
+
+	s = sector + 12;
+        for (i = 0; i < 2340; i++)
+                s[i] ^= ecma_130_annex_b[i];
+}
+
+
+/* ------------------------------------------------------------------------- */
+
+
+/* The following code is not needed for libburn but rather documents the
+   origin of the tables above. In libburn it will not be compiled.
+*/
+
+
+#ifdef Libburn_with_lec_generatoR
+
+
+/* This function produced the content of gflog[] and gfpow[]
+*/
+static int burn_rspc_setup_tables(void)
+{
+	unsigned int b, l;
+
+	memset(gflog, 0, sizeof(gflog));
+	memset(gfpow, 0, sizeof(gfpow));
+	b = 1;
+	for (l = 0; l < 255; l++) {
+		gfpow[l] = (unsigned char) b;
+		gflog[b] = (unsigned char) l;
+		b = b << 1;
+		if (b & 256)
+			b = b ^ 0x11d;
+	}
+	return 0;
+}
+
+
+/* This function printed the content of gflog[] and gfpow[] as C code
+   and compared the content with the tables of the old implementation.
+   h26[] and h45[] are reverted order copies of gfpow[]
+*/
+static int burn_rspc_print_tables(void)
+{
+ int i;
+
+ printf("static unsigned char gfpow[255] = {");
+ printf("\n\t"); 
+ for(i= 0; i < 255; i++) {
+   printf("%3u, ", gfpow[i]);
+
+#ifdef Libburn_with_old_lec_comparisoN
+   if(gfpow[i] != gf8_ilog[i])
+     fprintf(stderr, "*** ILOG %d : %d != %d ***\n", i, gfpow[i], gf8_ilog[i]);
+#endif
+
+   if((i % 10) == 9)
+     printf("\n\t"); 
+ }
+ printf("\n};\n\n");
+
+ printf("static unsigned char gflog[256] = {");
+ printf("\n\t"); 
+ for(i= 0; i < 256; i++) {
+   printf(" %3u,", gflog[i]);
+
+#ifdef Libburn_with_old_lec_comparisoN
+   if(gflog[i] != gf8_log[i])
+     fprintf(stderr, "*** LOG %d : %d != %d ***\n", i, gflog[i], gf8_log[i]);
+#endif
+
+   if((i % 10) == 9)
+     printf("\n\t"); 
+ }
+ printf("\n};\n\n");
+
+ printf("static unsigned char h26[26] = {");
+ printf("\n\t");
+ for(i= 0; i < 26; i++) {
+   printf(" %3u,", gfpow[25 - i]);
+   if((i % 10) == 9)
+     printf("\n\t"); 
+ }
+ printf("\n};\n\n");
+
+ printf("static unsigned char h45[45] = {");
+ printf("\n\t");
+ for(i= 0; i < 45; i++) {
+   printf(" %3u,",gfpow[44 - i]);
+   if((i % 10) == 9)
+     printf("\n\t"); 
+ }
+ printf("\n};\n\n");
+
+ return 0;
+}
+
+
+/* This code was used to generate the content of array ecma_130_annex_b[].
+*/
+static unsigned short ecma_130_fsr = 1;
+
+static int next_bit(void)
+{
+	int ret;
+
+	ret = ecma_130_fsr & 1;
+	ecma_130_fsr = (ecma_130_fsr >> 1) & 0x3fff;
+	if (ret ^ (ecma_130_fsr & 1))
+		ecma_130_fsr |= 0x4000;
+	return ret;
+}
+
+
+static int print_ecma_130_scrambler(void)
+{
+	int i, j, b;
+
+	ecma_130_fsr = 1;
+	printf("static unsigned char ecma_130_annex_b[2340] = {");
+	printf("\n\t");
+	for (i = 0; i < 2340; i++) {
+		b = 0;
+		for (j = 0; j < 8; j++)
+			b |= next_bit() << j;
+
+		printf("%3u, ", b);
+		if ((i % 10) == 9)
+			printf("\n\t");
+	}
+	printf("\n};\n");
+	return 1;
+}
+
+
+#ifdef Libburn_with_general_rspc_diV
+
+/* This is a general polynomial division function.
+   burn_rspc_div_3() has been derived from this by setting b to constant 3.
+*/
+static unsigned char burn_rspc_div(unsigned char a, unsigned char b)
+{
+	int d;
+
+	if (a == 0)
+		return 0;
+	if (b == 0)
+		return -1;
+	d = gflog[a] - gflog[b];
+	if (d < 0)
+		d += 255;
+	return gfpow[d];
+}
+
+#endif /* Libburn_with_general_rspc_diV */
+
+
+#endif /* Libburn_with_lec_generatoR */
+

libburn/ecma130ab.h

@@ -0,0 +1,24 @@
+
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+/* ts A91016 : libburn/ecma130ab.h is the replacement for old libburn/lec.h
+
+   Copyright 2009, Thomas Schmitt <scdbackup@gmx.net>, libburnia-project.org
+   Provided under GPL version 2 or later.
+
+   This code module implements the computations prescribed in ECMA-130 Annex A
+   and B. For explanations of the underlying mathematics see ecma130ab.c .
+
+*/
+
+#ifndef Libburn_ecma130ab_includeD
+#define Libburn_ecma130ab_includeD 1
+
+void burn_rspc_parity_p(unsigned char *sector);
+
+void burn_rspc_parity_q(unsigned char *sector);
+
+void burn_ecma130_scramble(unsigned char *sector);
+
+#endif /* ! Libburn_ecma130ab_includeD */
+

libburn/file.c

@@ -1,13 +1,35 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+
 #include <stdlib.h>
 #include <sys/types.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <time.h>
+#include <pthread.h>
+
 #include "source.h"
 #include "libburn.h"
 #include "file.h"
+#include "async.h"
+
+#include "libdax_msgs.h"
+extern struct libdax_msgs *libdax_messenger;
+
 
 /* main channel data can be padded on read, but 0 padding the subs will make
 an unreadable disc */
@@ -16,8 +38,6 @@ an unreadable disc */
 /* This is a generic OS oriented function wrapper which compensates
    shortcommings of read() in respect to a guaranteed amount of return data.
    See  man 2 read , paragraph "RETURN VALUE".
-   Possibly libburn/file.c is not the right storage location for this.
-   To make it ready for a move, this function is not declared static.
 */
 static int read_full_buffer(int fd, unsigned char *buffer, int size)
 {
@@ -73,7 +93,9 @@ static off_t file_size(struct burn_source *source)
 
 	if (fs->fixed_size > 0)
 		return fs->fixed_size;
-	if (fstat(fs->datafd, &buf) == -1)
+	if (fstat(fs->datafd, &buf) != 0)
+		return (off_t) 0;
+	if ((buf.st_mode & S_IFMT) != S_IFREG)
 		return (off_t) 0;
 	return (off_t) buf.st_size;
 }
@@ -93,30 +115,45 @@ struct burn_source *burn_file_source_new(const char *path, const char *subpath)
 {
 	struct burn_source_file *fs;
 	struct burn_source *src;
-	int fd1, fd2 = 0;
+	int fd1 = -1, fd2 = -1;
 
 	if (!path)
 		return NULL;
 	fd1 = open(path, O_RDONLY);
 	if (fd1 == -1)
 		return NULL;
-	if (subpath) {
+	if (subpath != NULL) {
 		fd2 = open(subpath, O_RDONLY);
 		if (fd2 == -1) {
 			close(fd1);
 			return NULL;
 		}
 	}
-	fs = malloc(sizeof(struct burn_source_file));
-	fs->datafd = fd1;
+	fs = calloc(1, sizeof(struct burn_source_file));
 
-	if (subpath)
-		fs->subfd = fd2;
+	/* ts A70825 */
+	if (fs == NULL) {
+failure:;
+		close(fd1);
+		if (fd2 >= 0)
+			close(fd2);
+		return NULL;
+	}
+
+	fs->datafd = fd1;
+	fs->subfd = fd2;
 
 	/* ts A70125 */
 	fs->fixed_size = 0;
 
 	src = burn_source_new();
+
+	/* ts A70825 */
+	if (src == NULL) {
+		free((char *) fs);
+		goto failure;
+	}
+
 	src->read = file_read;
 	if (subpath)
 		src->read_sub = file_read_sub;
@@ -138,15 +175,24 @@ struct burn_source *burn_fd_source_new(int datafd, int subfd, off_t size)
 
 	if (datafd == -1)
 		return NULL;
-	fs = malloc(sizeof(struct burn_source_file));
+	fs = calloc(1, sizeof(struct burn_source_file));
+	if (fs == NULL) /* ts A70825 */
+		return NULL;
 	fs->datafd = datafd;
 	fs->subfd = subfd;
 	fs->fixed_size = size;
 
 	src = burn_source_new();
+
+	/* ts A70825 */
+	if (src == NULL) {
+		free((char *) fs);
+		return NULL;
+	}
+
 	src->read = file_read;
 	if(subfd != -1)
-		src->read = file_read_sub;
+		src->read_sub = file_read_sub;
 	src->get_size = file_size;
 	src->set_size = file_set_size;
 	src->free_data = file_free;
@@ -154,3 +200,713 @@ struct burn_source *burn_fd_source_new(int datafd, int subfd, off_t size)
 	return src;
 }
 
+
+/* ts A71003 */
+/* ------------------------------ fifo --------------------------- */
+
+/* The fifo mechanism consists of a burn_source proxy which is here,
+   a thread management team which is located in async.c,
+   and a synchronous shoveller which is here.
+*/
+
+static int fifo_sleep(int flag)
+{
+	static unsigned long sleeptime = 50000; /* 50 ms */
+
+	usleep(sleeptime);
+	return 0;
+}
+
+
+static int fifo_read(struct burn_source *source,
+		     unsigned char *buffer,
+		     int size)
+{
+	struct burn_source_fifo *fs = source->data;
+	int ret, todo, rpos, bufsize, diff, counted = 0;
+
+	if (fs->end_of_consumption) {
+		/* ??? msg: reading has been ended already */;
+		return 0;
+	}
+        if (fs->is_started == 0) {
+		ret = burn_fifo_start(source, 0);
+		if (ret <= 0) {
+			libdax_msgs_submit(libdax_messenger, -1, 0x00020152,
+				 LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+				"Cannot start fifo thread", 0, 0);
+			fs->end_of_consumption = 1;
+			return -1;
+		}
+		fs->is_started = 1;
+	}
+	if (size == 0)
+		return 0;
+
+	/* Reading from the ring buffer */
+
+	/* This needs no mutex because each volatile variable has one thread
+	   which may write and the other which only reads and is aware of
+	   volatility.
+	   The feeder of the ringbuffer is in burn_fifo_source_shoveller().
+	*/
+	todo = size;
+	bufsize = fs->chunksize * fs->chunks;
+	while (todo > 0) {
+		/* readpos is not volatile here , writepos is volatile */
+		rpos = fs->buf_readpos;
+		while (rpos == fs->buf_writepos) {
+			if (fs->end_of_input)
+		break;
+			if (fs->input_error) {
+				if (todo < size) /* deliver partial buffer */
+		break;
+				fs->end_of_consumption = 1;
+				libdax_msgs_submit(libdax_messenger, -1,
+				   0x00020154,
+				   LIBDAX_MSGS_SEV_NOTE, LIBDAX_MSGS_PRIO_HIGH,
+				   "Forwarded input error ends output", 0, 0);
+				return -1;
+			}
+			if (!counted)
+				fs->empty_counter++;
+			counted = 1;
+			fifo_sleep(0);
+		}
+		diff = fs->buf_writepos - rpos; /* read volatile only once */
+		if (diff == 0)
+	break;
+		if (diff > 0)
+			/* diff bytes are available */;
+		else 
+			/* at least (bufsize - rpos) bytes are available */
+			diff =  bufsize - rpos;
+		if (diff > todo)
+			diff = todo;
+		memcpy(buffer, fs->buf+(size-todo)+rpos, diff);
+		fs->buf_readpos += diff;
+		if (fs->buf_readpos >= bufsize)
+			fs->buf_readpos = 0;
+		todo -= diff;
+	}
+	if (size - todo <= 0)
+		fs->end_of_consumption = 1;
+	else
+		fs->out_counter += size - todo;
+
+/*
+	fprintf(stderr,
+		"libburn_EXPERIMENTAL: read= %d , pos= %d , out_count= %.f\n",
+		(size - todo), fs->buf_readpos, (double) fs->out_counter);
+*/
+
+	fs->get_counter++;
+	return (size - todo);
+}
+
+
+static off_t fifo_get_size(struct burn_source *source)
+{
+	struct burn_source_fifo *fs = source->data;
+
+	return fs->inp->get_size(fs->inp);
+}
+
+
+static int fifo_set_size(struct burn_source *source, off_t size)
+{
+	struct burn_source_fifo *fs = source->data;
+
+	return fs->inp->set_size(fs->inp, size);
+}
+
+
+static void fifo_free(struct burn_source *source)
+{
+	struct burn_source_fifo *fs = source->data;
+
+	burn_fifo_abort(fs, 0);
+	if (fs->inp != NULL)
+		burn_source_free(fs->inp);
+
+	if (fs->buf != NULL)
+		burn_os_free_buffer(fs->buf,
+			((size_t) fs->chunksize) * (size_t) fs->chunks, 0);
+	free((char *) fs);
+}
+
+
+int burn_fifo_source_shoveller(struct burn_source *source, int flag)
+{
+	struct burn_source_fifo *fs = source->data;
+	int ret, bufsize, diff, wpos, rpos, trans_end, free_bytes, fill;
+	int counted;
+	char *bufpt;
+	pthread_t thread_handle_storage;
+
+	fs->thread_handle= &thread_handle_storage;
+	*((pthread_t *) fs->thread_handle)= pthread_self();
+	fs->thread_pid = getpid();
+	fs->thread_is_valid = 1;
+
+	bufsize = fs->chunksize * fs->chunks;
+	while (!fs->end_of_consumption) {
+
+		/* wait for enough buffer space available */
+		wpos = fs->buf_writepos;
+		counted = 0;
+		while (1) {
+			rpos = fs->buf_readpos;
+			diff = rpos - wpos;
+			trans_end = 0;
+			if (diff == 0)
+				free_bytes = bufsize - 1;
+			else if (diff > 0)
+				free_bytes = diff - 1;
+			else {
+				free_bytes = (bufsize - wpos) + rpos - 1;
+				if (bufsize - wpos < fs->inp_read_size)
+					trans_end = 1;
+			}
+			if (free_bytes >= fs->inp_read_size)
+		break;
+			if (!counted)
+				fs->full_counter++;
+			counted = 1;
+			fifo_sleep(0);
+		}
+
+		fill = bufsize - free_bytes - 1;
+		if (fill < fs->total_min_fill)
+			fs->total_min_fill = fill;
+		if (fill < fs->interval_min_fill)
+			fs->interval_min_fill = fill;
+
+		/* prepare the receiving memory */
+		bufpt = fs->buf + wpos;
+		if (trans_end) {
+			bufpt = burn_os_alloc_buffer(
+					(size_t) fs->inp_read_size, 0);
+			if (bufpt == NULL) {
+				libdax_msgs_submit(libdax_messenger, -1,
+				  0x00000003,
+				  LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+				  "Out of virtual memory", 0, 0);
+				fs->input_error = ENOMEM;
+	break;
+			}
+		}
+
+		/* Obtain next chunk */
+		if (fs->inp->read != NULL)
+			ret = fs->inp->read(fs->inp,
+				 (unsigned char *) bufpt, fs->inp_read_size);
+		else
+			ret = fs->inp->read_xt( fs->inp,
+				 (unsigned char *) bufpt, fs->inp_read_size);
+		if (ret == 0) {
+
+			/* >>> ??? ts B00326 */
+			/* >>> report EOF of fifo input and fs->in_counter */;
+
+	break; /* EOF */
+		} else if (ret < 0) {
+			libdax_msgs_submit(libdax_messenger, -1, 0x00020153,
+				 LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				"Read error on fifo input", errno, 0);
+			fs->input_error = errno;
+			if(errno == 0)
+				fs->input_error = EIO;
+	break;
+		}
+		fs->in_counter += ret;
+		fs->put_counter++;
+
+		/* activate read chunk */
+		if (ret > fs->inp_read_size)
+					/* beware of ill custom burn_source */
+			ret = fs->inp_read_size;
+		if (trans_end) {
+			/* copy to end of buffer */
+			memcpy(fs->buf + wpos, bufpt, bufsize - wpos);
+			/* copy to start of buffer */
+			memcpy(fs->buf, bufpt + (bufsize - wpos),
+				fs->inp_read_size - (bufsize - wpos));
+			burn_os_free_buffer(bufpt, (size_t) fs->inp_read_size,
+						0);
+			if (ret >= bufsize - wpos)
+				fs->buf_writepos = ret - (bufsize - wpos);
+			else
+				fs->buf_writepos += ret;
+		} else if (fs->buf_writepos + ret == bufsize)
+			fs->buf_writepos = 0;
+		else
+			fs->buf_writepos += ret;
+
+/*
+		fprintf(stderr, "[%2.2d%%] ",
+			 (int) (100.0 - 100.0 * ((double) free_bytes) /
+						 (double) bufsize));
+		fprintf(stderr,
+			"libburn_EXPERIMENTAL: writepos= %d ,in_count = %.f\n",
+			fs->buf_writepos, (double) fs->in_counter);
+*/
+	}
+	if (!fs->end_of_consumption)
+		fs->end_of_input = 1;
+
+	/* wait for end of reading by consumer */;
+	while (fs->buf_readpos != fs->buf_writepos && !fs->end_of_consumption)
+			fifo_sleep(0);
+
+	/* destroy ring buffer */;
+	if (!fs->end_of_consumption)
+		fs->end_of_consumption = 2; /* Claim stop of consumption */
+
+	/* This is not prone to race conditions because either the consumer
+	   indicated hangup by fs->end_of_consumption = 1 or the consumer set
+	   fs->buf_readpos to a value indicating the buffer is empty.
+	   So in both cases the consumer is aware that reading is futile
+	   or even fatal.
+	*/
+	if(fs->buf != NULL)
+		burn_os_free_buffer(fs->buf,
+			((size_t) fs->chunksize) * (size_t) fs->chunks, 0);
+	fs->buf = NULL;
+
+	fs->thread_handle= NULL;
+	fs->thread_is_valid = 0;
+	return (fs->input_error == 0);
+}
+
+
+int burn_fifo_cancel(struct burn_source *source)
+{
+	int ret;
+	struct burn_source_fifo *fs = source->data;
+
+	ret = burn_source_cancel(fs->inp);
+	return ret;
+}
+
+/*
+   @param flag bit0= allow larger read chunks
+*/
+struct burn_source *burn_fifo_source_new(struct burn_source *inp,
+		 		int chunksize, int chunks, int flag)
+{
+	struct burn_source_fifo *fs;
+	struct burn_source *src;
+
+	if (((double) chunksize) * ((double) chunks) > 1024.0*1024.0*1024.0) {
+		libdax_msgs_submit(libdax_messenger, -1, 0x00020155,
+				 LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				"Desired fifo buffer too large (> 1GB)", 0, 0);
+		return NULL;
+	}
+	if (chunksize < 1 || chunks < 2) {
+		libdax_msgs_submit(libdax_messenger, -1, 0x00020156,
+				 LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				"Desired fifo buffer too small", 0, 0);
+		return NULL;
+	}
+	fs = calloc(1, sizeof(struct burn_source_fifo));
+	if (fs == NULL)
+		return NULL;
+	fs->is_started = 0;
+	fs->thread_handle = NULL;
+	fs->thread_pid = 0;
+	fs->thread_is_valid = 0;
+	fs->inp = NULL; /* set later */
+	if (flag & 1)
+		fs->inp_read_size = 32 * 1024;
+	else
+		fs->inp_read_size = chunksize;
+	fs->chunksize = chunksize;
+	fs->chunks = chunks;
+	fs->buf = NULL;
+	fs->buf_writepos = fs->buf_readpos = 0;
+	fs->end_of_input = 0;
+	fs->input_error = 0;
+	fs->end_of_consumption = 0;
+	fs->in_counter = fs->out_counter = 0;
+	fs->total_min_fill = fs->interval_min_fill = 0;
+	fs->put_counter = fs->get_counter = 0;
+	fs->empty_counter = fs->full_counter = 0;
+
+	src = burn_source_new();
+	if (src == NULL) {
+		free((char *) fs);
+		return NULL;
+	}
+	src->read = NULL;
+	src->read_sub = NULL;
+	src->get_size = fifo_get_size;
+	src->set_size = fifo_set_size;
+	src->free_data = fifo_free;
+	src->data = fs;
+	src->version= 1;
+	src->read_xt = fifo_read;
+	src->cancel= burn_fifo_cancel;
+	fs->inp = inp;
+	inp->refcount++; /* make sure inp lives longer than src */
+
+	return src;
+}
+
+
+/* ts A71003 : API */
+int burn_fifo_inquire_status(struct burn_source *source,
+		 int *size, int *free_bytes, char **status_text)
+{
+	struct burn_source_fifo *fs = source->data;
+	int ret = 0, diff, wpos, rpos;
+	static char *(states[8]) = {
+			"standby", "active", "ending", "failing",
+			"unused", "abandoned", "ended", "aborted"};
+
+	*status_text = NULL;
+	*size = 0;
+
+	if (source->free_data != fifo_free) {
+		libdax_msgs_submit(libdax_messenger, -1, 0x00020157,
+				 LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+		  "burn_source is not a fifo object", 0, 0);
+		return -1;
+	}
+	*size = fs->chunksize * fs->chunks;
+	rpos = fs->buf_readpos;
+	wpos = fs->buf_writepos;
+	diff = rpos - wpos;
+	if (diff == 0)
+		*free_bytes = *size - 1;
+	else if (diff > 0)
+		*free_bytes = diff - 1;
+	else
+		*free_bytes = (*size - wpos) + rpos - 1;
+	ret = 0;
+	if (fs->end_of_consumption > 0)
+		ret |= 4;
+	if (fs->input_error)
+		ret |= 3;
+	else if (fs->end_of_input)
+		ret |= 2;
+	else if(fs->buf != NULL)
+		ret |= 1;
+	*status_text = states[ret];
+	return ret;
+}
+
+
+/* ts A91125 : API */
+void burn_fifo_get_statistics(struct burn_source *source,
+                             int *total_min_fill, int *interval_min_fill,
+                             int *put_counter, int *get_counter,
+                             int *empty_counter, int *full_counter)
+{
+	struct burn_source_fifo *fs = source->data;
+
+	*total_min_fill = fs->total_min_fill;
+	*interval_min_fill = fs->interval_min_fill;
+	*put_counter = fs->put_counter;
+	*get_counter = fs->get_counter;
+	*empty_counter = fs->empty_counter;
+	*full_counter = fs->full_counter;
+}
+
+
+/* ts A91125 : API */
+void burn_fifo_next_interval(struct burn_source *source,
+                            int *interval_min_fill)
+{ 
+	struct burn_source_fifo *fs = source->data;
+	int size, free_bytes, ret;
+	char *status_text;
+
+	*interval_min_fill = fs->interval_min_fill;
+	ret = burn_fifo_inquire_status(source,
+					 &size, &free_bytes, &status_text);
+	if (ret < 0)
+		return;
+	fs->interval_min_fill = size - free_bytes - 1;
+}
+
+
+/* @param flag bit0= do not copy to buf but only wait until the fifo has read
+                     bufsize or input ended.
+                     The same happens if buf is NULL.
+               bit1= fill to max fifo size
+*/
+int burn_fifo_fill_data(struct burn_source *source, char *buf, int bufsize,
+                        int flag)
+{
+	int size, free_bytes, ret, wait_count= 0;
+	char *status_text;
+	struct burn_source_fifo *fs = source->data;
+
+	if (buf == NULL)
+		flag |= 1;
+
+	/* Eventually start fifo thread by reading 0 bytes */
+	ret = fifo_read(source, (unsigned char *) NULL, 0);
+	if (ret<0)
+		{ret = 0; goto ex;}
+
+	/* wait for at least bufsize bytes being ready */
+	while (1) {
+		ret= burn_fifo_inquire_status(source,
+					 &size, &free_bytes, &status_text);
+		if (flag & 2) {
+			bufsize = size - (size % fs->inp_read_size) -
+					fs->inp_read_size;
+			if (bufsize <= 0)
+				{ret = 0; goto ex;}
+		}
+		if (size - fs->inp_read_size < bufsize) {
+			if (flag & 1) {
+				bufsize = size - (size % fs->inp_read_size) -
+						fs->inp_read_size;
+				if (bufsize <= 0)
+					{ret = 0; goto ex;}
+			} else {
+				libdax_msgs_submit(libdax_messenger, -1,
+					0x0002015c, LIBDAX_MSGS_SEV_FAILURE,
+					 LIBDAX_MSGS_PRIO_HIGH,
+			 	"Fifo size too small for desired peek buffer",
+					 0, 0);
+				{ret = -1; goto ex;}
+			}
+		}
+		if (fs->out_counter > 0 || (ret & 4) || fs->buf == NULL) {
+			libdax_msgs_submit(libdax_messenger, -1, 0x0002015e,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+	 	"Fifo is already under consumption when peeking is desired",
+			0, 0);
+			{ret = -1; goto ex;}
+		}
+		if(size - free_bytes >= bufsize) {
+
+			/* <<<
+			fprintf(stderr,
+		"libburn_DEBUG: after waiting cycle %d : fifo %s , %d bytes\n",
+			 wait_count, status_text, size - free_bytes);
+			*/
+			if(!(flag & 1))
+				memcpy(buf, fs->buf, bufsize);
+			{ret = 1; goto ex;}
+		}
+
+		if (ret & 2) {
+			/* input has ended, not enough data arrived */
+			if (flag & 1)
+				{ret = 0; goto ex;}
+			libdax_msgs_submit(libdax_messenger, -1, 0x0002015d,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+		 	"Fifo input ended short of desired peek buffer size",
+			0, 0);
+			{ret = 0; goto ex;}
+		}
+
+		if (free_bytes < fs->inp_read_size) {
+			/* Usable fifo size filled, not enough data arrived */
+			if (flag & 1)
+				{ret = 0; goto ex;}
+			libdax_msgs_submit(libdax_messenger, -1, 0x00020174,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+		 	"Fifo alignment does not allow desired read size",
+			0, 0);
+			{ret = 0; goto ex;}
+		}
+
+		usleep(100000);
+		wait_count++;
+
+		/* <<<
+		if(wait_count%10==0)
+			fprintf(stderr,
+		 "libburn_DEBUG: waiting cycle %d : fifo %s , %d bytes\n",
+			 wait_count, status_text, size - free_bytes);
+		*/
+
+	}
+	ret = 0;
+ex:;
+	fs->total_min_fill = fs->interval_min_fill = fs->buf_writepos;
+	return(ret);
+}
+
+
+/* ts A80713 : API */
+int burn_fifo_peek_data(struct burn_source *source, char *buf, int bufsize,
+                        int flag)
+{
+	return burn_fifo_fill_data(source, buf, bufsize, 0);
+}
+
+
+/* ts A91125 : API */
+int burn_fifo_fill(struct burn_source *source, int bufsize, int flag)
+{
+	return burn_fifo_fill_data(source, NULL, bufsize,
+					1 | ((flag & 1) << 1));
+}
+
+
+/* ----------------------------- Offset source ----------------------------- */
+/* ts B00922 */
+
+static void offst_free(struct burn_source *source);
+
+static struct burn_source_offst *offst_auth(struct burn_source *source)
+{
+	if (source->free_data != offst_free) {
+		libdax_msgs_submit(libdax_messenger, -1, 0x0002017a,
+			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+ 			"Expected offset source object as parameter",
+			0, 0);
+		return NULL;
+	}
+	return (struct burn_source_offst *) source->data;
+}
+
+static off_t offst_get_size(struct burn_source *source)
+{
+        struct burn_source_offst *fs;
+
+	if ((fs = offst_auth(source)) == NULL)
+		return (off_t) 0;
+        return fs->size;
+}
+
+static int offst_set_size(struct burn_source *source, off_t size)
+{
+	struct burn_source_offst *fs;
+
+	if ((fs = offst_auth(source)) == NULL)
+		return 0;
+	fs->size = size;
+	return 1;
+}
+
+static void offst_free(struct burn_source *source)
+{
+	struct burn_source_offst *fs;
+
+	if ((fs = offst_auth(source)) == NULL)
+		return;
+	if (fs->prev != NULL)
+		offst_auth(fs->prev)->next = fs->next;
+	if (fs->next != NULL)
+		offst_auth(fs->next)->prev = fs->prev;
+	if (fs->inp != NULL)
+		burn_source_free(fs->inp); /* i.e. decrement refcount */
+	free(source->data);
+}
+
+static int offst_read(struct burn_source *source, unsigned char *buffer,
+			int size)
+{
+	int ret, to_read, todo;
+	struct burn_source_offst *fs;
+
+	if ((fs = offst_auth(source)) == NULL)
+		return -1;
+
+	/* Eventually skip bytes up to start position */;
+	if (!fs->running) {
+		if (fs->prev != NULL)
+			fs->pos = offst_auth(fs->prev)->pos;
+		fs->running= 1;
+	}
+	if(fs->pos < fs->start) {
+		todo = fs->start - fs->pos;
+		while (todo > 0) {
+			to_read = todo;
+			if (to_read > size)
+				to_read = size;
+			ret = burn_source_read(fs->inp, buffer, to_read);
+			if (ret <= 0)
+				return ret;
+			todo -= ret;
+			fs->pos += ret;
+		}
+	}
+
+	/* Produce EOF if source size is exhausted.
+	   burn_source delivers no incomplete sector buffers.
+	*/
+	if (fs->pos + size > fs->start + fs->size)
+		return 0;
+
+	/* Read payload */
+	ret = burn_source_read(fs->inp, buffer, size);
+	if (ret > 0)
+		fs->pos += ret;
+	return ret;
+}
+
+static int offst_cancel(struct burn_source *source)
+{
+	int ret;
+	struct burn_source_offst *fs;
+
+	if ((fs = offst_auth(source)) == NULL)
+		return -1;
+	ret = burn_source_cancel(fs->inp);
+	return ret;
+}
+
+struct burn_source *burn_offst_source_new(
+		struct burn_source *inp, struct burn_source *prev,
+		off_t start, off_t size, int flag)
+{
+	struct burn_source *src;
+	struct burn_source_offst *fs, *prev_fs = NULL;
+
+	if (prev != NULL)
+		if ((prev_fs = offst_auth(prev)) == NULL)
+			return NULL; /* Not type burn_source_offst */
+
+	fs = calloc(1, sizeof(struct burn_source_offst));
+	if (fs == NULL)
+		return NULL;
+        src = burn_source_new();
+        if (src == NULL) {
+                free((char *) fs);
+                return NULL;
+        }
+        src->read = NULL;
+        src->read_sub = NULL;
+        src->get_size = offst_get_size;
+        src->set_size = offst_set_size;
+        src->free_data = offst_free;
+        src->data = fs;
+        src->version= 1;
+        src->read_xt = offst_read;
+        src->cancel= offst_cancel;
+        fs->inp = inp;
+	fs->prev = prev;
+	fs->next = NULL;
+	if (prev != NULL) {
+		if (prev_fs->next != NULL) {
+			offst_auth(prev_fs->next)->prev = src;
+			fs->next = prev_fs->next;
+		}
+		prev_fs->next = src;
+		if (prev_fs->start + prev_fs->size > start) {
+			libdax_msgs_submit(libdax_messenger, -1, 0x00020179,
+			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+ 		"Offset source start address is before end of previous source",
+			0, 0);
+			return NULL;
+		}
+	}
+	fs->start = start;
+	fs->size = size;
+	fs->running = 0;
+	fs->pos = 0;
+        inp->refcount++; /* make sure inp lives longer than src */
+
+        return src;
+}
+

libburn/file.h

@@ -1,17 +1,95 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
 #ifndef BURN__FILE_H
 #define BURN__FILE_H
 
 struct burn_source_file
 {
+	char magic[4];
+
 	int datafd;
 	int subfd;
 	off_t fixed_size;
 };
 
-
 /* ts A70126 : burn_source_file obsoleted burn_source_fd */
 
 
+/* ts A70930 */
+struct burn_source_fifo {
+	char magic[4];
+
+	/* The fifo stays inactive and unequipped with eventual resources
+	   until its read() method is called for the first time.
+	   Only then burn_fifo_start() gets called, allocates the complete
+           resources, starts a thread with burn_fifo_source_shuffler()
+	   which shuffles data and finally destroys the resources.
+	   This late start is to stay modest in case of multiple tracks
+	   in one disc.
+	*/
+	int is_started;
+
+	void *thread_handle; /* actually a pointer to a thread_t */
+	int thread_pid;
+	int thread_is_valid;
+
+	/* the burn_source for which this fifo is acting as proxy */
+	struct burn_source *inp;
+	int inp_read_size;
+
+	/* <<< up to now it was only a pipe. This is on its way out. */
+	int outlet[2];
+
+	/* The ring buffer mechanism */
+	int chunksize;
+	int chunks;
+	char *buf;
+	volatile int buf_writepos;
+	volatile int buf_readpos;
+	volatile int end_of_input;
+	volatile int input_error;
+	volatile int end_of_consumption;
+
+	off_t in_counter;
+	off_t out_counter;
+
+	int total_min_fill;
+	int interval_min_fill;
+	int put_counter;
+	int get_counter;
+	int empty_counter;
+	int full_counter;
+
+};
+
+
+/** The worker behind the fifo thread.
+    Gets started from burn_fifo_start() in async.c
+*/
+int burn_fifo_source_shoveller(struct burn_source *source, int flag);
+
+
+/* ts B00922 */
+struct burn_source_offst {
+
+	/* See burn_offst_source_new() */
+	struct burn_source *inp;
+	struct burn_source *prev;
+	off_t start;
+	off_t size;
+
+	/* To help offst_free() */
+	struct burn_source *next;
+
+	/* The current reading position */
+	int running;
+	off_t pos;
+
+};
+
 #endif /* LIBBURN__FILE_H */

libburn/init.c

@@ -1,5 +1,15 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+
 #include <unistd.h>
 
 /* ts A61007 */
@@ -8,12 +18,19 @@
 #include <stdio.h>
 #include <signal.h>
 #include <string.h>
+#include <stdlib.h>
+#include <pthread.h>
 
+/* ts A70928 : init.h is for others, not for init .c
 #include "init.h"
+*/
+
+
 #include "sg.h"
 #include "error.h"
 #include "libburn.h"
 #include "drive.h"
+#include "transport.h"
 
 /* ts A60825 : The storage location for back_hacks.h variables. */
 #define BURN_BACK_HACKS_INIT 1
@@ -26,14 +43,16 @@ struct libdax_msgs *libdax_messenger= NULL;
 
 int burn_running = 0;
 
-/* ts A60813 : Linux: wether to use O_EXCL on open() of device files */
+/* ts A60813 : GNU/Linux: whether to use O_EXCL on open() of device files
+   ts B00212 : FreeBSD:   whether to use flock(LOCK_EX) after open()
+*/
 int burn_sg_open_o_excl = 1;
 
-/* ts A70403 : Linux: wether to use fcntl(,F_SETLK,)
+/* ts A70403 : GNU/Linux: wether to use fcntl(,F_SETLK,)
                       after open() of device files  */
 int burn_sg_fcntl_f_setlk = 1;
 
-/* ts A70314 : Linux: what device family to use :
+/* ts A70314 : GNU/Linux: what device family to use :
     0= default family
     1= sr
     2= scd
@@ -54,6 +73,11 @@ int burn_sg_open_o_nonblock = 1;
 int burn_sg_open_abort_busy = 0;
 
 
+/* The message returned from sg_id_string() and/or sg_initialize()
+*/
+static char sg_initialize_msg[1024] = {""};
+
+
 /* ts A61002 */
 
 #include "cleanup.h"
@@ -61,11 +85,33 @@ int burn_sg_open_abort_busy = 0;
 /* Parameters for builtin abort handler */
 static char abort_message_prefix[81] = {"libburn : "};
 static pid_t abort_control_pid= 0;
+static pthread_t abort_control_thread;
+volatile int burn_global_abort_level= 0;
+int burn_global_abort_signum= 0;
+void *burn_global_signal_handle = NULL;
+burn_abort_handler_t burn_global_signal_handler = NULL;
+int burn_builtin_signal_action = 0;            /* burn_set_signal_handling() */
+volatile int burn_builtin_triggered_action = 0;       /*  burn_is_aborting() */
 
 
 /* ts A70223 : wether implemented untested profiles are supported */
 int burn_support_untested_profiles = 0;
 
+/* ts A91111 :
+   whether to log SCSI commands (to be implemented in sg-*.c)
+   bit0= log in /tmp/libburn_sg_command_log
+   bit1= log to stderr
+   bit2= flush every line
+*/
+int burn_sg_log_scsi = 0;
+
+
+/* ts B10312 :
+   Whether to map random-access readonly files to drive role 4.
+   Else it is role 2 overwriteable drive
+*/
+int burn_drive_role_4_allowed = 0;
+
 
 /* ts A60925 : ticket 74 */
 /** Create the messenger object for libburn. */
@@ -94,6 +140,14 @@ int burn_initialize(void)
 	ret = burn_msgs_initialize();
 	if (ret <= 0)
 		return 0;
+	ret = sg_initialize(sg_initialize_msg, 0);
+	if (ret <= 0) {
+                libdax_msgs_submit(libdax_messenger, -1,
+                        0x00020175,
+                        LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+                        sg_initialize_msg, 0, 0);
+		return 0;
+	}
 	burn_running = 1;
 	return 1;
 }
@@ -107,11 +161,12 @@ void burn_finish(void)
 
 	/* ts A61007 */
 	/* burn_wait_all(); */
-	if (!burn_drives_are_clear()) {
+	if (!burn_drives_are_clear(0)) {
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020107,
-			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
-			"Drive is busy on attempt to shut down library", 0, 0);
-		return;
+			LIBDAX_MSGS_SEV_WARNING, LIBDAX_MSGS_PRIO_HIGH,
+			"A drive is still busy on shutdown of library", 0, 0);
+		usleep(1000001);
+		burn_abort(4440, burn_abort_pacifier, abort_message_prefix);
 	}
 
 	/* ts A60904 : ticket 62, contribution by elmom : name addon "_all" */
@@ -120,10 +175,24 @@ void burn_finish(void)
 	/* ts A60924 : ticket 74 */
 	libdax_msgs_destroy(&libdax_messenger,0);
 
+	sg_shutdown(0);
+
+	burn_drive_clear_whitelist();
+
 	burn_running = 0;
 }
 
 
+/* ts A91226 */
+/** API function. See libburn.h */
+char *burn_scsi_transport_id(int flag)
+{
+	if (!burn_running)
+		sg_id_string(sg_initialize_msg, 0);
+	return sg_initialize_msg;
+}
+
+
 /* ts A60813 */
 /** API function. See libburn.h */
 void burn_preset_device_open(int exclusive, int blocking, int abort_on_busy)
@@ -200,6 +269,8 @@ int burn_msgs_obtain(char *minimum_severity,
 	ret = libdax_msgs__text_to_sev(minimum_severity, &minimum_sevno, 0);
 	if (ret <= 0)
 		return 0;
+	if (libdax_messenger == NULL)
+		return 0;
 	ret = libdax_msgs_obtain(libdax_messenger, &item, minimum_sevno,
 				LIBDAX_MSGS_PRIO_ZERO, 0);
 	if (ret <= 0)
@@ -226,41 +297,179 @@ ex:
 	return ret;
 }
 
+
+/* ts A70922 : API */
+int burn_msgs_submit(int error_code, char msg_text[], int os_errno,
+			char severity[], struct burn_drive *d)
+{
+	int ret, sevno, global_index = -1;
+
+	ret = libdax_msgs__text_to_sev(severity, &sevno, 0);
+	if (ret <= 0)
+		sevno = LIBDAX_MSGS_SEV_ALL;
+	if (error_code <= 0) {
+		switch(sevno) {
+		       case LIBDAX_MSGS_SEV_ABORT:   error_code = 0x00040000;
+		break; case LIBDAX_MSGS_SEV_FATAL:   error_code = 0x00040001;
+		break; case LIBDAX_MSGS_SEV_SORRY:   error_code = 0x00040002;
+		break; case LIBDAX_MSGS_SEV_WARNING: error_code = 0x00040003;
+		break; case LIBDAX_MSGS_SEV_HINT:    error_code = 0x00040004;
+		break; case LIBDAX_MSGS_SEV_NOTE:    error_code = 0x00040005;
+		break; case LIBDAX_MSGS_SEV_UPDATE:  error_code = 0x00040006;
+		break; case LIBDAX_MSGS_SEV_DEBUG:   error_code = 0x00040007;
+		break; default:                      error_code = 0x00040008;
+		}
+	}
+	if (d != NULL)
+		global_index = d->global_index;
+	ret = libdax_msgs_submit(libdax_messenger, global_index, error_code,
+			sevno, LIBDAX_MSGS_PRIO_HIGH, msg_text, os_errno, 0);
+	return ret;
+}
+
+
+/* ts A71016 API */
+int burn_text_to_sev(char *severity_name, int *sevno, int flag)
+{
+	int ret;
+
+	ret = libdax_msgs__text_to_sev(severity_name, sevno, 0);
+	return ret;
+}
+
+
+/* ts A80202 API */
+int burn_sev_to_text(int severity_number, char **severity_name, int flag)
+{
+	int ret;
+
+	ret = libdax_msgs__sev_to_text(severity_number, severity_name, 0);
+	return ret;
+}
+
+/* ts B00224 */
+char *burn_util_thread_id(pid_t pid, pthread_t tid, char text[80])
+{
+	int i, l;
+
+	sprintf(text, "[%lu,", (unsigned long int) getpid());
+	l= strlen(text);
+	for(i= 0; i < ((int) sizeof(pthread_t)) && 2 * i < 80 - l - 3; i++)
+		sprintf(text + l + 2 * i,
+			 "%2.2X", ((unsigned char *) &tid)[i]);
+
+	sprintf(text + l + 2 * i, "]");
+	return text;
+}
+
 int burn_builtin_abort_handler(void *handle, int signum, int flag)
 {
+
+#define Libburn_new_thread_signal_handleR 1
+/*
+#define Libburn_signal_handler_verbouS 1
+*/
+
+	int ret;
+	struct burn_drive *d;
+
+#ifdef Libburn_signal_handler_verbouS
+	char text[80];
+
+	fprintf(stderr, "libburn_ABORT: in = %s\n",
+		burn_util_thread_id(getpid(), pthread_self(), text));
+	fprintf(stderr, "libburn_ABORT: ctrl = %s\n",
+		burn_util_thread_id(abort_control_pid, abort_control_thread,
+					text));
+	if (burn_global_signal_handler == burn_builtin_abort_handler)
+		fprintf(stderr, "libburn_ABORT: signal action = %d\n",
+				burn_builtin_signal_action);
+
+	/* >>> find writing drives and report their tid
+	fprintf(stderr, "libburn_ABORT: wrt = %s\n",
+		burn_util_thread_id(0, burn_write_thread_id, text));
+	fprintf(stderr, "libburn_ABORT: sig= %d\n", signum);
+	*/
+#endif
+
+	burn_builtin_triggered_action = burn_builtin_signal_action;
+	burn_global_abort_level = -1;
+
+	if (burn_builtin_signal_action > 1) {
+		Cleanup_set_handlers(NULL, NULL, 2);
+		if (burn_builtin_signal_action == 4)
+			return -2;
+		fprintf(stderr,"%sABORT : Trying to shut down busy drives\n",
+			abort_message_prefix);
+		fprintf(stderr,
+		 "%sABORT : Wait the normal burning time before any kill -9\n",
+		 	abort_message_prefix);
+		burn_abort_5(0, burn_abort_pacifier, abort_message_prefix,
+				0, 1);
+		libdax_msgs_submit(libdax_messenger, -1, 0x00020177,
+			LIBDAX_MSGS_SEV_ABORT, LIBDAX_MSGS_PRIO_HIGH,
+			"Urged drive worker threads to do emergency halt",
+			0, 0);
+		return -2;
+	}
+
+
+	/* ---- old deprecated stuck-in-abort-handler loop ---- */
+
+	/* ts A70928:
+	Must be quick. Allowed to coincide with other thread and to share
+	the increment with that one. It must not decrease, though, and
+	yield at least 1 if any thread calls this function.
+	*/
+	burn_global_abort_level++;
+	burn_global_abort_signum= signum;
+
 	if(getpid() != abort_control_pid) {
 
-#ifdef Not_yeT
-		pthread_t thread_id;
+#ifdef Libburn_new_thread_signal_handleR
 
-		/* >>> need better handling of self-induced SIGs 
-		       like SIGSEGV or SIGFPE.
-		       Like bonking the control thread if it did not show up
-		       after a short while.
-		*/
+		ret = burn_drive_find_by_thread_pid(&d, getpid(),
+							pthread_self());
+		if (ret > 0 && d->busy == BURN_DRIVE_WRITING) {
+					/* This is an active writer thread */
 
-		/* >>> if this is a non-fatal signal : return -2 */
+#ifdef Libburn_signal_handler_verbouS
+			fprintf(stderr, "libburn_ABORT: pid %d found drive busy with writing, (level= %d)\n", (int) getpid(), burn_global_abort_level);
+#endif
 
-		thread_id = pthread_self();
-		/* >>> find thread_id  in worker list of async.c */
-		/* >>> if owning a drive : mark idle and canceled
-		       (can't do anything more) */
+			d->sync_cache(d);
 
-		usleep(1000000); /* calm down */
+			/* >>> perform a more qualified end of burn process */;
 
- 		/* forward signal to control thread */
-		if (abort_control_pid>1)
-			kill(abort_control_pid, signum);
+			d->busy = BURN_DRIVE_IDLE;
 
-		/* >>> ??? end thread */;
+			if (burn_global_abort_level > 0) {
+				/* control process did not show up yet */
+#ifdef Libburn_signal_handler_verbouS
+					fprintf(stderr, "libburn_ABORT: pid %d sending signum %d to pid %d\n", (int) getpid(), (int) signum, (int) abort_control_pid);
+#endif
+					kill(abort_control_pid, signum);
+			}
+
+#ifdef Libburn_signal_handler_verbouS
+					fprintf(stderr, "libburn_ABORT: pid %d signum %d returning -2\n", (int) getpid(), (int) signum);
+#endif
+
+			return -2;
+		} else {
+			usleep(1000000); /* calm down */
+			return -2;
+		}
 
 #else
 		usleep(1000000); /* calm down */
 		return -2;
-#endif /* ! Not_yeT */
+#endif /* ! Libburn_new_thread_signal_handleR */
 
 	}
+	burn_global_abort_level = -1;
 	Cleanup_set_handlers(NULL, NULL, 2);
+
 	fprintf(stderr,"%sABORT : Trying to shut down drive and library\n",
 		abort_message_prefix);
 	fprintf(stderr,
@@ -268,29 +477,76 @@ int burn_builtin_abort_handler(void *handle, int signum, int flag)
 		abort_message_prefix);
 	close(0); /* somehow stdin as input blocks abort until EOF */
 	burn_abort(4440, burn_abort_pacifier, abort_message_prefix);
+
 	fprintf(stderr,
 	"\n%sABORT : Program done. Even if you do not see a shell prompt.\n\n",
 		abort_message_prefix);
+	burn_global_abort_level = -2;
 	return(1);
 }
 
+
+/* ts A61002 : API */
 void burn_set_signal_handling(void *handle, burn_abort_handler_t handler,
-			     int mode)
+				int mode)
 {
-	if(handler == NULL && mode == 0) {
+
+/*
+	fprintf(stderr, "libburn_experimental: burn_set_signal_handling, handler==%lx  mode=%d\n", (unsigned long) handler, mode);
+*/
+
+	if(handler == NULL) {
 		handler = burn_builtin_abort_handler;
 /*
-		fprintf(stderr, "libburn_experimental: activated burn_builtin_abort_handler() with handle '%s'\n",(handle==NULL ? "libburn : " : (char *) handle));
+		if ((mode & ~4) == 0)
+			fprintf(stderr, "libburn_experimental: activated burn_builtin_abort_handler() with handle '%s'\n",(handle==NULL ? "libburn : " : (char *) handle));
 */
 
 	}
 	strcpy(abort_message_prefix, "libburn : ");
-	if(handle != NULL)
+	abort_message_prefix[0] = 0;
+	if(handle != NULL && handler == burn_builtin_abort_handler)
 		strncpy(abort_message_prefix, (char *) handle,
 			sizeof(abort_message_prefix)-1);
 	abort_message_prefix[sizeof(abort_message_prefix)-1] = 0;
-	abort_control_pid= getpid();
-	Cleanup_set_handlers(handle, (Cleanup_app_handler_T) handler, mode|4);
+	abort_control_pid = getpid();
+	abort_control_thread = pthread_self();
+	burn_builtin_signal_action = (mode >> 4) & 15;
+	if((mode & 11) != 0)
+		burn_builtin_signal_action = 0;
+	if(burn_builtin_signal_action > 1)
+		burn_builtin_triggered_action = 0;
+	if(burn_builtin_signal_action == 0)
+		burn_builtin_signal_action = 1;
+	Cleanup_set_handlers(handle, (Cleanup_app_handler_T) handler,
+				 (mode & 15) | 4);
+	burn_global_signal_handle = handle;
+	burn_global_signal_handler = handler;
+}
+
+
+/* ts B00304 : API */
+int burn_is_aborting(int flag)
+{
+	return burn_builtin_triggered_action;
+}
+
+
+/* ts B00225 */
+/* @return 0= no abort action 2 pending , 1= not control thread
+*/
+int burn_init_catch_on_abort(int flag)
+{
+	if (burn_builtin_triggered_action != 2)
+		return 0;
+	if (abort_control_pid != getpid() ||
+		abort_control_thread != pthread_self())
+		return 1;
+	burn_abort(4440, burn_abort_pacifier, abort_message_prefix);
+	fprintf(stderr,
+	"\n%sABORT : Program done. Even if you do not see a shell prompt.\n\n",
+		abort_message_prefix);
+	exit(1);
 }
 
 
@@ -300,3 +556,44 @@ void burn_allow_untested_profiles(int yes)
 	burn_support_untested_profiles = !!yes;
 }
 
+
+/* ts A70915 : API */
+int burn_set_messenger(void *messenger)
+{
+	struct libdax_msgs *pt;
+
+	if (libdax_msgs_refer(&pt, messenger, 0) <= 0)
+		return 0;
+	libdax_msgs_destroy(&libdax_messenger, 0);
+	libdax_messenger = (struct libdax_msgs *) pt;
+	return 1;
+}
+
+
+/* ts A91111 API */
+void burn_set_scsi_logging(int flag)
+{
+	burn_sg_log_scsi = flag & 7;
+}
+
+
+/* ts B10312 API */
+void burn_allow_drive_role_4(int allowed)
+{
+	burn_drive_role_4_allowed = (allowed & 0xf);
+}
+
+
+/* ts B10606 */
+void *burn_alloc_mem(size_t size, size_t count, int flag)
+{
+	void *pt;
+
+	pt = calloc(size, count);
+	if(pt == NULL)
+		libdax_msgs_submit(libdax_messenger, -1, 0x00000003,
+				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+				"Out of virtual memory", 0, 0);
+	return pt;
+}
+

libburn/init.h

@@ -5,4 +5,47 @@
 
 extern int burn_running;
 
+/** Indicator for burn_drive_get_status() wether a signal hit parts of the
+    thread team. 
+    0= all works well ,
+    1 to 5 = waiting for eventual signal on control thread
+    > 5 = do abort now
+    -1 = control thread has been informed
+*/
+extern volatile int burn_global_abort_level;
+extern int burn_global_abort_signum;
+extern void *burn_global_signal_handle;
+extern burn_abort_handler_t burn_global_signal_handler;
+
+extern int burn_builtin_signal_action;         /* burn_set_signal_handling() */
+extern volatile int burn_builtin_triggered_action;    /*  burn_is_aborting() */
+
+
+/* ts B00225 */
+/* @return 0= no abort pending , 1= not control thread ,
+          -1= surprisingly burn_abort returned
+*/
+int burn_init_catch_on_abort(int flag);
+
+/* ts B10606 */
+void *burn_alloc_mem(size_t size, size_t count, int flag);
+
+#define BURN_ALLOC_MEM(pt, typ, count) { \
+	pt= (typ *) burn_alloc_mem(sizeof(typ), (size_t) (count), 0); \
+	if(pt == NULL) { \
+		ret= -1; goto ex; \
+	} }
+
+#define BURN_ALLOC_MEM_VOID(pt, typ, count) { \
+	pt= (typ *) burn_alloc_mem(sizeof(typ), (size_t) (count), 0); \
+	if(pt == NULL) { \
+		goto ex; \
+	} }
+
+#define BURN_FREE_MEM(pt) { \
+	if(pt != NULL) \
+		free((char *) pt); \
+	}
+
+
 #endif /* BURN__INIT_H */

libburn/lec.c

@@ -1,451 +0,0 @@
-/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
-
-/* borrowed HEAVILY from cdrdao */
-
-#include <string.h>
-#include "lec.h"
-
-#define LEC_HEADER_OFFSET 12
-#define LEC_MODE1_P_PARITY_OFFSET 2076
-#define LEC_MODE1_Q_PARITY_OFFSET 2248
-
-static unsigned char gf8_ilog[255] = {
-	1, 2, 4, 8, 16, 32, 64, 128, 29, 58, 116, 232, 205, 135, 19, 38, 76,
-	152, 45, 90, 180, 117, 234, 201, 143, 3, 6, 12, 24, 48, 96,
-	192, 157, 39, 78, 156, 37, 74, 148, 53, 106, 212, 181, 119,
-	238, 193, 159, 35, 70, 140, 5, 10, 20, 40, 80, 160, 93, 186,
-	105, 210, 185, 111, 222, 161, 95, 190, 97, 194, 153, 47, 94,
-	188, 101, 202, 137, 15, 30, 60, 120, 240, 253, 231, 211, 187,
-	107, 214, 177, 127, 254, 225, 223, 163, 91, 182, 113, 226, 217,
-	175, 67, 134, 17, 34, 68, 136, 13, 26, 52, 104, 208, 189, 103,
-	206, 129, 31, 62, 124, 248, 237, 199, 147, 59, 118, 236, 197,
-	151, 51, 102, 204, 133, 23, 46, 92, 184, 109, 218, 169, 79,
-	158, 33, 66, 132, 21, 42, 84, 168, 77, 154, 41, 82, 164, 85,
-	170, 73, 146, 57, 114, 228, 213, 183, 115, 230, 209, 191, 99,
-	198, 145, 63, 126, 252, 229, 215, 179, 123, 246, 241, 255, 227,
-	219, 171, 75, 150, 49, 98, 196, 149, 55, 110, 220, 165, 87,
-	174, 65, 130, 25, 50, 100, 200, 141, 7, 14, 28, 56, 112, 224,
-	221, 167, 83, 166, 81, 162, 89, 178, 121, 242, 249, 239, 195,
-	155, 43, 86, 172, 69, 138, 9, 18, 36, 72, 144, 61, 122, 244,
-	245, 247, 243, 251, 235, 203, 139, 11, 22, 44, 88, 176, 125,
-	250, 233, 207, 131, 27, 54, 108, 216, 173, 71, 142,
-};
-static unsigned char gf8_log[256] = {
-	0, 0, 1, 25, 2, 50, 26, 198, 3, 223, 51, 238, 27, 104, 199, 75, 4, 100,
-	224, 14, 52, 141, 239, 129, 28, 193, 105, 248, 200, 8, 76, 113,
-	5, 138, 101, 47, 225, 36, 15, 33, 53, 147, 142, 218, 240, 18,
-	130, 69, 29, 181, 194, 125, 106, 39, 249, 185, 201, 154, 9,
-	120, 77, 228, 114, 166, 6, 191, 139, 98, 102, 221, 48, 253,
-	226, 152, 37, 179, 16, 145, 34, 136, 54, 208, 148, 206, 143,
-	150, 219, 189, 241, 210, 19, 92, 131, 56, 70, 64, 30, 66, 182,
-	163, 195, 72, 126, 110, 107, 58, 40, 84, 250, 133, 186, 61,
-	202, 94, 155, 159, 10, 21, 121, 43, 78, 212, 229, 172, 115,
-	243, 167, 87, 7, 112, 192, 247, 140, 128, 99, 13, 103, 74, 222,
-	237, 49, 197, 254, 24, 227, 165, 153, 119, 38, 184, 180, 124,
-	17, 68, 146, 217, 35, 32, 137, 46, 55, 63, 209, 91, 149, 188,
-	207, 205, 144, 135, 151, 178, 220, 252, 190, 97, 242, 86, 211,
-	171, 20, 42, 93, 158, 132, 60, 57, 83, 71, 109, 65, 162, 31,
-	45, 67, 216, 183, 123, 164, 118, 196, 23, 73, 236, 127, 12,
-	111, 246, 108, 161, 59, 82, 41, 157, 85, 170, 251, 96, 134,
-	177, 187, 204, 62, 90, 203, 89, 95, 176, 156, 169, 160, 81, 11,
-	245, 22, 235, 122, 117, 44, 215, 79, 174, 213, 233, 230, 231,
-	173, 232, 116, 214, 244, 234, 168, 80, 88, 175,
-};
-static unsigned char gf8_q_coeffs[2][45] = {
-	{97, 251, 133, 60, 82, 160, 155, 201, 8, 112, 246, 11, 21, 42, 157,
-	 169, 80, 174, 232, 230, 172, 211, 241, 18, 68, 216, 44, 121, 9, 200,
-	 75, 103, 221, 252, 96, 176, 88, 167, 114, 76, 199, 26, 1, 0, 0},
-	{190, 96, 250, 132, 59, 81, 159, 154, 200, 7, 111, 245, 10, 20, 41,
-	 156, 168, 79, 173, 231, 229, 171, 210, 240, 17, 67, 215, 43, 120, 8,
-	 199, 74, 102, 220, 251, 95, 175, 87, 166, 113, 75, 198, 25, 0, 0}
-};
-static unsigned char gf8_p_coeffs[2][26] = {
-	{230, 172, 211, 241, 18, 68, 216, 44, 121, 9, 200, 75, 103, 221, 252,
-	 96, 176, 88, 167, 114, 76, 199, 26, 1, 0, 0},
-	{231, 229, 171, 210, 240, 17, 67, 215, 43, 120, 8, 199, 74, 102, 220,
-	 251, 95, 175, 87, 166, 113, 75, 198, 25, 0, 0}
-};
-
-static unsigned char yellowbook_scrambler[2340] = {
-	1, 128, 0, 96, 0, 40, 0, 30, 128, 8, 96, 6, 168, 2, 254, 129, 128, 96,
-	96, 40, 40, 30, 158,
-	136, 104, 102, 174, 170, 252, 127, 1, 224, 0, 72, 0, 54, 128, 22, 224,
-	14, 200, 4, 86, 131, 126, 225,
-	224, 72, 72, 54, 182, 150, 246, 238, 198, 204, 82, 213, 253, 159, 1,
-	168, 0, 126, 128, 32, 96, 24, 40,
-	10, 158, 135, 40, 98, 158, 169, 168, 126, 254, 160, 64, 120, 48, 34,
-	148, 25, 175, 74, 252, 55, 1, 214,
-	128, 94, 224, 56, 72, 18, 182, 141, 182, 229, 182, 203, 54, 215, 86,
-	222, 190, 216, 112, 90, 164, 59, 59,
-	83, 83, 125, 253, 225, 129, 136, 96, 102, 168, 42, 254, 159, 0, 104, 0,
-	46, 128, 28, 96, 9, 232, 6,
-	206, 130, 212, 97, 159, 104, 104, 46, 174, 156, 124, 105, 225, 238,
-	200, 76, 86, 181, 254, 247, 0, 70, 128,
-	50, 224, 21, 136, 15, 38, 132, 26, 227, 75, 9, 247, 70, 198, 178, 210,
-	245, 157, 135, 41, 162, 158, 249,
-	168, 66, 254, 177, 128, 116, 96, 39, 104, 26, 174, 139, 60, 103, 81,
-	234, 188, 79, 49, 244, 20, 71, 79,
-	114, 180, 37, 183, 91, 54, 187, 86, 243, 126, 197, 224, 83, 8, 61, 198,
-	145, 146, 236, 109, 141, 237, 165,
-	141, 187, 37, 179, 91, 53, 251, 87, 3, 126, 129, 224, 96, 72, 40, 54,
-	158, 150, 232, 110, 206, 172, 84,
-	125, 255, 97, 128, 40, 96, 30, 168, 8, 126, 134, 160, 98, 248, 41, 130,
-	158, 225, 168, 72, 126, 182, 160,
-	118, 248, 38, 194, 154, 209, 171, 28, 127, 73, 224, 54, 200, 22, 214,
-	142, 222, 228, 88, 75, 122, 183, 99,
-	54, 169, 214, 254, 222, 192, 88, 80, 58, 188, 19, 49, 205, 212, 85,
-	159, 127, 40, 32, 30, 152, 8, 106,
-	134, 175, 34, 252, 25, 129, 202, 224, 87, 8, 62, 134, 144, 98, 236, 41,
-	141, 222, 229, 152, 75, 42, 183,
-	95, 54, 184, 22, 242, 142, 197, 164, 83, 59, 125, 211, 97, 157, 232,
-	105, 142, 174, 228, 124, 75, 97, 247,
-	104, 70, 174, 178, 252, 117, 129, 231, 32, 74, 152, 55, 42, 150, 159,
-	46, 232, 28, 78, 137, 244, 102, 199,
-	106, 210, 175, 29, 188, 9, 177, 198, 244, 82, 199, 125, 146, 161, 173,
-	184, 125, 178, 161, 181, 184, 119, 50,
-	166, 149, 186, 239, 51, 12, 21, 197, 207, 19, 20, 13, 207, 69, 148, 51,
-	47, 85, 220, 63, 25, 208, 10,
-	220, 7, 25, 194, 138, 209, 167, 28, 122, 137, 227, 38, 201, 218, 214,
-	219, 30, 219, 72, 91, 118, 187, 102,
-	243, 106, 197, 239, 19, 12, 13, 197, 197, 147, 19, 45, 205, 221, 149,
-	153, 175, 42, 252, 31, 1, 200, 0,
-	86, 128, 62, 224, 16, 72, 12, 54, 133, 214, 227, 30, 201, 200, 86, 214,
-	190, 222, 240, 88, 68, 58, 179,
-	83, 53, 253, 215, 1, 158, 128, 104, 96, 46, 168, 28, 126, 137, 224,
-	102, 200, 42, 214, 159, 30, 232, 8,
-	78, 134, 180, 98, 247, 105, 134, 174, 226, 252, 73, 129, 246, 224, 70,
-	200, 50, 214, 149, 158, 239, 40, 76,
-	30, 181, 200, 119, 22, 166, 142, 250, 228, 67, 11, 113, 199, 100, 82,
-	171, 125, 191, 97, 176, 40, 116, 30,
-	167, 72, 122, 182, 163, 54, 249, 214, 194, 222, 209, 152, 92, 106, 185,
-	239, 50, 204, 21, 149, 207, 47, 20,
-	28, 15, 73, 196, 54, 211, 86, 221, 254, 217, 128, 90, 224, 59, 8, 19,
-	70, 141, 242, 229, 133, 139, 35,
-	39, 89, 218, 186, 219, 51, 27, 85, 203, 127, 23, 96, 14, 168, 4, 126,
-	131, 96, 97, 232, 40, 78, 158,
-	180, 104, 119, 110, 166, 172, 122, 253, 227, 1, 137, 192, 102, 208, 42,
-	220, 31, 25, 200, 10, 214, 135, 30,
-	226, 136, 73, 166, 182, 250, 246, 195, 6, 209, 194, 220, 81, 153, 252,
-	106, 193, 239, 16, 76, 12, 53, 197,
-	215, 19, 30, 141, 200, 101, 150, 171, 46, 255, 92, 64, 57, 240, 18,
-	196, 13, 147, 69, 173, 243, 61, 133,
-	209, 163, 28, 121, 201, 226, 214, 201, 158, 214, 232, 94, 206, 184, 84,
-	114, 191, 101, 176, 43, 52, 31, 87,
-	72, 62, 182, 144, 118, 236, 38, 205, 218, 213, 155, 31, 43, 72, 31,
-	118, 136, 38, 230, 154, 202, 235, 23,
-	15, 78, 132, 52, 99, 87, 105, 254, 174, 192, 124, 80, 33, 252, 24, 65,
-	202, 176, 87, 52, 62, 151, 80,
-	110, 188, 44, 113, 221, 228, 89, 139, 122, 231, 99, 10, 169, 199, 62,
-	210, 144, 93, 172, 57, 189, 210, 241,
-	157, 132, 105, 163, 110, 249, 236, 66, 205, 241, 149, 132, 111, 35,
-	108, 25, 237, 202, 205, 151, 21, 174, 143,
-	60, 100, 17, 235, 76, 79, 117, 244, 39, 7, 90, 130, 187, 33, 179, 88,
-	117, 250, 167, 3, 58, 129, 211,
-	32, 93, 216, 57, 154, 146, 235, 45, 143, 93, 164, 57, 187, 82, 243,
-	125, 133, 225, 163, 8, 121, 198, 162,
-	210, 249, 157, 130, 233, 161, 142, 248, 100, 66, 171, 113, 191, 100,
-	112, 43, 100, 31, 107, 72, 47, 118, 156,
-	38, 233, 218, 206, 219, 20, 91, 79, 123, 116, 35, 103, 89, 234, 186,
-	207, 51, 20, 21, 207, 79, 20, 52,
-	15, 87, 68, 62, 179, 80, 117, 252, 39, 1, 218, 128, 91, 32, 59, 88, 19,
-	122, 141, 227, 37, 137, 219,
-	38, 219, 90, 219, 123, 27, 99, 75, 105, 247, 110, 198, 172, 82, 253,
-	253, 129, 129, 160, 96, 120, 40, 34,
-	158, 153, 168, 106, 254, 175, 0, 124, 0, 33, 192, 24, 80, 10, 188, 7,
-	49, 194, 148, 81, 175, 124, 124,
-	33, 225, 216, 72, 90, 182, 187, 54, 243, 86, 197, 254, 211, 0, 93, 192,
-	57, 144, 18, 236, 13, 141, 197,
-	165, 147, 59, 45, 211, 93, 157, 249, 169, 130, 254, 225, 128, 72, 96,
-	54, 168, 22, 254, 142, 192, 100, 80,
-	43, 124, 31, 97, 200, 40, 86, 158, 190, 232, 112, 78, 164, 52, 123, 87,
-	99, 126, 169, 224, 126, 200, 32,
-	86, 152, 62, 234, 144, 79, 44, 52, 29, 215, 73, 158, 182, 232, 118,
-	206, 166, 212, 122, 223, 99, 24, 41,
-	202, 158, 215, 40, 94, 158, 184, 104, 114, 174, 165, 188, 123, 49, 227,
-	84, 73, 255, 118, 192, 38, 208, 26,
-	220, 11, 25, 199, 74, 210, 183, 29, 182, 137, 182, 230, 246, 202, 198,
-	215, 18, 222, 141, 152, 101, 170, 171,
-	63, 63, 80, 16, 60, 12, 17, 197, 204, 83, 21, 253, 207, 1, 148, 0, 111,
-	64, 44, 48, 29, 212, 9,
-	159, 70, 232, 50, 206, 149, 148, 111, 47, 108, 28, 45, 201, 221, 150,
-	217, 174, 218, 252, 91, 1, 251, 64,
-	67, 112, 49, 228, 20, 75, 79, 119, 116, 38, 167, 90, 250, 187, 3, 51,
-	65, 213, 240, 95, 4, 56, 3,
-	82, 129, 253, 160, 65, 184, 48, 114, 148, 37, 175, 91, 60, 59, 81, 211,
-	124, 93, 225, 249, 136, 66, 230,
-	177, 138, 244, 103, 7, 106, 130, 175, 33, 188, 24, 113, 202, 164, 87,
-	59, 126, 147, 96, 109, 232, 45, 142,
-	157, 164, 105, 187, 110, 243, 108, 69, 237, 243, 13, 133, 197, 163, 19,
-	57, 205, 210, 213, 157, 159, 41, 168,
-	30, 254, 136, 64, 102, 176, 42, 244, 31, 7, 72, 2, 182, 129, 182, 224,
-	118, 200, 38, 214, 154, 222, 235,
-	24, 79, 74, 180, 55, 55, 86, 150, 190, 238, 240, 76, 68, 53, 243, 87,
-	5, 254, 131, 0, 97, 192, 40,
-	80, 30, 188, 8, 113, 198, 164, 82, 251, 125, 131, 97, 161, 232, 120,
-	78, 162, 180, 121, 183, 98, 246, 169,
-	134, 254, 226, 192, 73, 144, 54, 236, 22, 205, 206, 213, 148, 95, 47,
-	120, 28, 34, 137, 217, 166, 218, 250,
-	219, 3, 27, 65, 203, 112, 87, 100, 62, 171, 80, 127, 124, 32, 33, 216,
-	24, 90, 138, 187, 39, 51, 90,
-	149, 251, 47, 3, 92, 1, 249, 192, 66, 208, 49, 156, 20, 105, 207, 110,
-	212, 44, 95, 93, 248, 57, 130,
-	146, 225, 173, 136, 125, 166, 161, 186, 248, 115, 2, 165, 193, 187, 16,
-	115, 76, 37, 245, 219, 7, 27, 66,
-	139, 113, 167, 100, 122, 171, 99, 63, 105, 208, 46, 220, 28, 89, 201,
-	250, 214, 195, 30, 209, 200, 92, 86,
-	185, 254, 242, 192, 69, 144, 51, 44, 21, 221, 207, 25, 148, 10, 239,
-	71, 12, 50, 133, 213, 163, 31, 57,
-	200, 18, 214, 141, 158, 229, 168, 75, 62, 183, 80, 118, 188, 38, 241,
-	218, 196, 91, 19, 123, 77, 227, 117,
-	137, 231, 38, 202, 154, 215, 43, 30, 159, 72, 104, 54, 174, 150, 252,
-	110, 193, 236, 80, 77, 252, 53, 129,
-	215, 32, 94, 152, 56, 106, 146, 175, 45, 188, 29, 177, 201, 180, 86,
-	247, 126, 198, 160, 82, 248, 61, 130,
-	145, 161, 172, 120, 125, 226, 161, 137, 184, 102, 242, 170, 197, 191,
-	19, 48, 13, 212, 5, 159, 67, 40, 49,
-	222, 148, 88, 111, 122, 172, 35, 61, 217, 209, 154, 220, 107, 25, 239,
-	74, 204, 55, 21, 214, 143, 30, 228,
-	8, 75, 70, 183, 114, 246, 165, 134, 251, 34, 195, 89, 145, 250, 236,
-	67, 13, 241, 197, 132, 83, 35, 125,
-	217, 225, 154, 200, 107, 22, 175, 78, 252, 52, 65, 215, 112, 94, 164,
-	56, 123, 82, 163, 125, 185, 225, 178,
-	200, 117, 150, 167, 46, 250, 156, 67, 41, 241, 222, 196, 88, 83, 122,
-	189, 227, 49, 137, 212, 102, 223, 106,
-	216, 47, 26, 156, 11, 41, 199, 94, 210, 184, 93, 178, 185, 181, 178,
-	247, 53, 134, 151, 34, 238, 153, 140,
-	106, 229, 239, 11, 12, 7, 69, 194, 179, 17, 181, 204, 119, 21, 230,
-	143, 10, 228, 7, 11, 66, 135, 113,
-	162, 164, 121, 187, 98, 243, 105, 133, 238, 227, 12, 73, 197, 246, 211,
-	6, 221, 194, 217, 145, 154, 236, 107,
-	13, 239, 69, 140, 51, 37, 213, 219, 31, 27, 72, 11, 118, 135, 102, 226,
-	170, 201, 191, 22, 240, 14, 196,
-	4, 83, 67, 125, 241, 225, 132, 72, 99, 118, 169, 230, 254, 202, 192,
-	87, 16, 62, 140, 16, 101, 204, 43,
-	21, 223, 79, 24, 52, 10, 151, 71, 46, 178, 156, 117, 169, 231, 62, 202,
-	144, 87, 44, 62, 157, 208, 105,
-	156, 46, 233, 220, 78, 217, 244, 90, 199, 123, 18, 163, 77, 185, 245,
-	178, 199, 53, 146, 151, 45, 174, 157,
-	188, 105, 177, 238, 244, 76, 71, 117, 242, 167, 5, 186, 131, 51, 33,
-	213, 216, 95, 26, 184, 11, 50, 135,
-	85, 162, 191, 57, 176, 18, 244, 13, 135, 69, 162, 179, 57, 181, 210,
-	247, 29, 134, 137, 162, 230, 249, 138,
-	194, 231, 17, 138, 140, 103, 37, 234, 155, 15, 43, 68, 31, 115, 72, 37,
-	246, 155, 6, 235, 66, 207, 113,
-	148, 36, 111, 91, 108, 59, 109, 211, 109, 157, 237, 169, 141, 190, 229,
-	176, 75, 52, 55, 87, 86, 190, 190,
-	240, 112, 68, 36, 51, 91, 85, 251, 127, 3, 96, 1, 232, 0, 78, 128, 52,
-	96, 23, 104, 14, 174, 132,
-	124, 99, 97, 233, 232, 78, 206, 180, 84, 119, 127, 102, 160, 42, 248,
-	31, 2, 136, 1, 166, 128, 122, 224,
-	35, 8, 25, 198, 138, 210, 231, 29, 138, 137, 167, 38, 250, 154, 195,
-	43, 17, 223, 76, 88, 53, 250, 151,
-	3, 46, 129, 220, 96, 89, 232, 58, 206, 147, 20, 109, 207, 109, 148, 45,
-	175, 93, 188, 57, 177, 210, 244,
-	93, 135, 121, 162, 162, 249, 185, 130, 242, 225, 133, 136, 99, 38, 169,
-	218, 254, 219, 0, 91, 64, 59, 112,
-	19, 100, 13, 235, 69, 143, 115, 36, 37, 219, 91, 27, 123, 75, 99, 119,
-	105, 230, 174, 202, 252, 87, 1,
-	254, 128, 64, 96, 48, 40, 20, 30, 143, 72, 100, 54, 171, 86, 255, 126,
-	192, 32, 80, 24, 60, 10, 145,
-	199, 44, 82, 157, 253, 169, 129, 190, 224, 112, 72, 36, 54, 155, 86,
-	235, 126, 207, 96, 84, 40, 63, 94,
-	144, 56, 108, 18, 173, 205, 189, 149, 177, 175, 52, 124, 23, 97, 206,
-	168, 84, 126, 191, 96, 112, 40, 36,
-	30, 155, 72, 107, 118, 175, 102, 252, 42, 193, 223, 16, 88, 12, 58,
-	133, 211, 35, 29, 217, 201, 154, 214,
-	235, 30, 207, 72, 84, 54, 191, 86, 240, 62, 196, 16, 83, 76, 61, 245,
-	209, 135, 28, 98, 137, 233, 166,
-	206, 250, 212, 67, 31, 113, 200, 36, 86, 155, 126, 235, 96, 79, 104,
-	52, 46, 151, 92, 110, 185, 236, 114,
-	205, 229, 149, 139, 47, 39, 92, 26, 185, 203, 50, 215, 85, 158, 191,
-	40, 112, 30, 164, 8, 123, 70, 163,
-	114, 249, 229, 130, 203, 33, 151, 88, 110, 186, 172, 115, 61, 229, 209,
-	139, 28, 103, 73, 234, 182, 207, 54,
-	212, 22, 223, 78, 216, 52, 90, 151, 123, 46, 163, 92, 121, 249, 226,
-	194, 201, 145, 150, 236, 110, 205, 236,
-	85, 141, 255, 37, 128, 27, 32, 11, 88, 7, 122, 130, 163, 33, 185, 216,
-	114, 218, 165, 155, 59, 43, 83,
-	95, 125, 248, 33, 130, 152, 97, 170, 168, 127, 62, 160, 16, 120, 12,
-	34, 133, 217, 163, 26, 249, 203, 2,
-	215, 65, 158, 176, 104, 116, 46, 167, 92, 122, 185, 227, 50, 201, 213,
-	150, 223, 46, 216, 28, 90, 137, 251,
-	38, 195, 90, 209, 251, 28, 67, 73, 241, 246, 196, 70, 211, 114, 221,
-	229, 153,
-};
-
-void scramble(unsigned char *inout)
-{
-	unsigned char *r = inout + 12;
-	unsigned char *s = yellowbook_scrambler;
-	unsigned int i;
-
-	for (i = 2340; i; i--) {
-		*r++ ^= *s++;
-	}
-}
-
-/* Calculate the P parities for the sector.
- * The 43 P vectors of length 24 are combined with the GF8_P_COEFFS.
- */
-void parity_p(unsigned char *sector)
-{
-	int i, j;
-	unsigned char p0_msb, p1_msb;
-	unsigned char p0_lsb, p1_lsb;
-	unsigned char *p_msb_start, *p_lsb_start;
-	unsigned char *p_msb, *p_lsb;
-	unsigned char *coeffs0, *coeffs1;
-	unsigned char *p0, *p1;
-	unsigned char d;
-	unsigned short c;
-
-	p_lsb_start = sector + LEC_HEADER_OFFSET;
-	p_msb_start = sector + LEC_HEADER_OFFSET + 1;
-
-	p1 = sector + LEC_MODE1_P_PARITY_OFFSET;
-	p0 = sector + LEC_MODE1_P_PARITY_OFFSET + 2 * 43;
-
-	for (i = 0; i <= 42; i++) {
-		p_lsb = p_lsb_start;
-		p_msb = p_msb_start;
-
-		coeffs0 = gf8_p_coeffs[0];
-		coeffs1 = gf8_p_coeffs[1];
-
-		p0_lsb = p1_lsb = p0_msb = p1_msb = 0;
-
-		for (j = 0; j <= 23; j++) {
-			d = *p_lsb;
-
-			if (d != 0) {
-				c = gf8_log[d] + *coeffs0;
-				if (c >= 255)
-					c -= 255;
-				p0_lsb ^= gf8_ilog[c];
-
-				c = gf8_log[d] + *coeffs1;
-				if (c >= 255)
-					c -= 255;
-				p1_lsb ^= gf8_ilog[c];
-			}
-
-			d = *p_msb;
-
-			if (d != 0) {
-				c = gf8_log[d] + *coeffs0;
-				if (c >= 255)
-					c -= 255;
-				p0_msb ^= gf8_ilog[c];
-
-				c = gf8_log[d] + *coeffs1;
-				if (c >= 255)
-					c -= 255;
-				p1_msb ^= gf8_ilog[c];
-			}
-
-			coeffs0++;
-			coeffs1++;
-
-			p_lsb += 2 * 43;
-			p_msb += 2 * 43;
-		}
-
-		*p0 = p0_lsb;
-		*(p0 + 1) = p0_msb;
-
-		*p1 = p1_lsb;
-		*(p1 + 1) = p1_msb;
-
-		p0 += 2;
-		p1 += 2;
-
-		p_lsb_start += 2;
-		p_msb_start += 2;
-	}
-}
-
-/* Calculate the Q parities for the sector.
- * The 26 Q vectors of length 43 are combined with the GF8_Q_COEFFS.
- */
-void parity_q(unsigned char *sector)
-{
-	int i, j;
-	unsigned char q0_msb, q1_msb;
-	unsigned char q0_lsb, q1_lsb;
-	unsigned char *q_msb_start, *q_lsb_start;
-	unsigned char *q_msb, *q_lsb;
-	unsigned char *coeffs0, *coeffs1;
-	unsigned char *q0, *q1, *q_start;
-	unsigned char d;
-	unsigned short c;
-
-	q_lsb_start = sector + LEC_HEADER_OFFSET;
-	q_msb_start = sector + LEC_HEADER_OFFSET + 1;
-
-	q_start = sector + LEC_MODE1_Q_PARITY_OFFSET;
-	q1 = sector + LEC_MODE1_Q_PARITY_OFFSET;
-	q0 = sector + LEC_MODE1_Q_PARITY_OFFSET + 2 * 26;
-
-	for (i = 0; i <= 25; i++) {
-		q_lsb = q_lsb_start;
-		q_msb = q_msb_start;
-
-		coeffs0 = gf8_q_coeffs[0];
-		coeffs1 = gf8_q_coeffs[1];
-
-		q0_lsb = q1_lsb = q0_msb = q1_msb = 0;
-
-		for (j = 0; j <= 42; j++) {
-			d = *q_lsb;
-
-			if (d != 0) {
-				c = gf8_log[d] + *coeffs0;
-				if (c >= 255)
-					c -= 255;
-				q0_lsb ^= gf8_ilog[c];
-
-				c = gf8_log[d] + *coeffs1;
-				if (c >= 255)
-					c -= 255;
-				q1_lsb ^= gf8_ilog[c];
-			}
-
-			d = *q_msb;
-
-			if (d != 0) {
-				c = gf8_log[d] + *coeffs0;
-				if (c >= 255)
-					c -= 255;
-				q0_msb ^= gf8_ilog[c];
-
-				c = gf8_log[d] + *coeffs1;
-				if (c >= 255)
-					c -= 255;
-				q1_msb ^= gf8_ilog[c];
-			}
-
-			coeffs0++;
-			coeffs1++;
-
-			q_lsb += 2 * 44;
-			q_msb += 2 * 44;
-
-			if (q_lsb >= q_start) {
-				q_msb -= 2 * 1118;
-				q_lsb -= 2 * 1118;
-			}
-		}
-
-		*q0 = q0_lsb;
-		*(q0 + 1) = q0_msb;
-
-		*q1 = q1_lsb;
-		*(q1 + 1) = q1_msb;
-
-		q0 += 2;
-		q1 += 2;
-
-		q_lsb_start += 2 * 43;
-		q_msb_start += 2 * 43;
-	}
-}

libburn/lec.h

@@ -1,12 +0,0 @@
-/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
-
-#ifndef __LEC
-#define __LEC
-
-#define RS_L12_BITS 8
-
-void scramble(unsigned char *);
-void parity_p(unsigned char *in);
-void parity_q(unsigned char *in);
-
-#endif /* __LEC */

libburn/libburn.ver

@@ -0,0 +1,173 @@
+LIBBURN4 {
+global:
+burn_abort;
+burn_abort_pacifier;
+burn_allow_drive_role_4;
+burn_allow_untested_profiles;
+burn_disc_add_session;
+burn_disc_available_space;
+burn_disc_close_damaged;
+burn_disc_create;
+burn_disc_erasable;
+burn_disc_erase;
+burn_disc_format;
+burn_disc_free;
+burn_disc_free_multi_caps;
+burn_disc_get_bd_spare_info;
+burn_disc_get_cd_info;
+burn_disc_get_format_descr;
+burn_disc_get_formats;
+burn_disc_get_media_id;
+burn_disc_get_msc1;
+burn_disc_get_multi_caps;
+burn_disc_get_phys_format_info;
+burn_disc_get_profile;
+burn_disc_get_sectors;
+burn_disc_get_sessions;
+burn_disc_get_status;
+burn_disc_next_track_is_damaged;
+burn_disc_pretend_blank;
+burn_disc_pretend_full;
+burn_disc_read;
+burn_disc_read_atip;
+burn_disc_remove_session;
+burn_disc_track_lba_nwa;
+burn_disc_write;
+burn_drive_add_whitelist;
+burn_drive_cancel;
+burn_drive_clear_whitelist;
+burn_drive_convert_fs_adr;
+burn_drive_convert_scsi_adr;
+burn_drive_d_get_adr;
+burn_drive_equals_adr;
+burn_drive_free_speedlist;
+burn_drive_get_adr;
+burn_drive_get_all_profiles;
+burn_drive_get_best_speed;
+burn_drive_get_disc;
+burn_drive_get_drive_role;
+burn_drive_get_min_write_speed;
+burn_drive_get_read_speed;
+burn_drive_get_speedlist;
+burn_drive_get_start_end_lba;
+burn_drive_get_status;
+burn_drive_get_write_speed;
+burn_drive_grab;
+burn_drive_info_forget;
+burn_drive_info_free;
+burn_drive_is_enumerable_adr;
+burn_drive_leave_locked;
+burn_drive_obtain_scsi_adr;
+burn_drive_probe_cd_write_modes;
+burn_drive_re_assess;
+burn_drive_release;
+burn_drive_scan;
+burn_drive_scan_and_grab;
+burn_drive_set_buffer_waiting;
+burn_drive_set_speed;
+burn_drive_set_stream_recording;
+burn_drive_snooze;
+burn_drive_wrote_well;
+burn_fd_source_new;
+burn_fifo_fill;
+burn_fifo_get_statistics;
+burn_fifo_inquire_status;
+burn_fifo_next_interval;
+burn_fifo_peek_data;
+burn_fifo_source_new;
+burn_file_source_new;
+burn_finish;
+burn_get_read_capacity;
+burn_guess_cd_manufacturer;
+burn_guess_manufacturer;
+burn_initialize;
+burn_is_aborting;
+burn_lba_to_msf;
+burn_lookup_device_link;
+burn_msf_to_lba;
+burn_msf_to_sectors;
+burn_msgs_obtain;
+burn_msgs_set_severities;
+burn_msgs_submit;
+burn_obtain_profile_name;
+burn_offst_source_new;
+burn_os_alloc_buffer;
+burn_os_free_buffer;
+burn_os_open_track_src;
+burn_precheck_write;
+burn_preset_device_open;
+burn_random_access_write;
+burn_read_data;
+burn_read_opts_free;
+burn_read_opts_new;
+burn_read_opts_read_subcodes_audio;
+burn_read_opts_read_subcodes_data;
+burn_read_opts_report_recovered_errors;
+burn_read_opts_set_c2errors;
+burn_read_opts_set_hardware_error_recovery;
+burn_read_opts_set_hardware_error_retries;
+burn_read_opts_set_raw;
+burn_read_opts_transfer_damaged_blocks;
+burn_scsi_transport_id;
+burn_sectors_to_msf;
+burn_session_add_track;
+burn_session_create;
+burn_session_free;
+burn_session_get_hidefirst;
+burn_session_get_leadout_entry;
+burn_session_get_sectors;
+burn_session_get_tracks;
+burn_session_hide_first_track;
+burn_session_remove_track;
+burn_set_messenger;
+burn_set_scsi_logging;
+burn_set_signal_handling;
+burn_set_verbosity;
+burn_sev_to_text;
+burn_source_free;
+burn_structure_print_disc;
+burn_structure_print_session;
+burn_structure_print_track;
+burn_text_to_sev;
+burn_track_clear_isrc;
+burn_track_create;
+burn_track_define_data;
+burn_track_free;
+burn_track_get_counters;
+burn_track_get_entry;
+burn_track_get_mode;
+burn_track_get_sectors;
+burn_track_set_byte_swap;
+burn_track_set_cdxa_conv;
+burn_track_set_default_size;
+burn_track_set_isrc;
+burn_track_set_size;
+burn_track_set_source;
+burn_version;
+burn_write_opts_auto_write_type;
+burn_write_opts_free;
+burn_write_opts_get_drive;
+burn_write_opts_new;
+burn_write_opts_set_dvd_obs;
+burn_write_opts_set_fillup;
+burn_write_opts_set_force;
+burn_write_opts_set_format;
+burn_write_opts_set_has_mediacatalog;
+burn_write_opts_set_mediacatalog;
+burn_write_opts_set_multi;
+burn_write_opts_set_perform_opc;
+burn_write_opts_set_simulate;
+burn_write_opts_set_start_byte;
+burn_write_opts_set_stdio_fsync;
+burn_write_opts_set_stream_recording;
+burn_write_opts_set_toc_entries;
+burn_write_opts_set_underrun_proof;
+burn_write_opts_set_write_type;
+libdax_audioxtr_destroy;
+libdax_audioxtr_detach_fd;
+libdax_audioxtr_get_id;
+libdax_audioxtr_get_size;
+libdax_audioxtr_new;
+libdax_audioxtr_read;
+local: *;
+};

libburn/libdax_audioxtr.c

@@ -1,9 +1,13 @@
 
 /* libdax_audioxtr 
    Audio track data extraction facility of libdax and libburn.
-   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
+   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
 */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <stdio.h>
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -21,7 +25,8 @@ extern struct libdax_msgs *libdax_messenger;
 /* Only this single source module is entitled to do this */
 #define LIBDAX_AUDIOXTR_H_INTERNAL 1
 
-/* All clients of the extraction facility must do this */
+/* All clients of the extraction facility must do this or include libburn.h */
+#define LIBDAX_AUDIOXTR_H_PUBLIC 1
 #include "libdax_audioxtr.h"
 
 
@@ -30,11 +35,11 @@ int libdax_audioxtr_new(struct libdax_audioxtr **xtr, char *path, int flag)
  int ret= -1;
  struct libdax_audioxtr *o;
 
- o= *xtr= (struct libdax_audioxtr *) malloc(sizeof(struct libdax_audioxtr));
+ o= *xtr= (struct libdax_audioxtr *) calloc(1, sizeof(struct libdax_audioxtr));
  if(o==NULL)
    return(-1);
  strncpy(o->path,path,LIBDAX_AUDIOXTR_STRLEN-1);
- o->path[LIBDAX_AUDIOXTR_STRLEN]= 0;
+ o->path[LIBDAX_AUDIOXTR_STRLEN-1]= 0;
  o->fd= -1;
  strcpy(o->fmt,"unidentified");
  o->fmt_info[0]= 0;

libburn/libdax_audioxtr.h

@@ -1,12 +1,19 @@
 
 /* libdax_audioxtr
    Audio track data extraction facility of libdax and libburn.
-   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
+   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
 */
 
 #ifndef LIBDAX_AUDIOXTR_H_INCLUDED
 #define LIBDAX_AUDIOXTR_H_INCLUDED 1
 
+
+/* Normally this public API is defined in <libburn/libburn.h>
+   Macro LIBDAX_AUDIOXTR_H_PUBLIC enables the definition for programs
+   which only include this file.
+*/
+#ifdef LIBDAX_AUDIOXTR_H_PUBLIC
+
                             /* Public Macros */
 
 /* Maximum size for address paths and fmt_info strings */
@@ -110,15 +117,16 @@ int libdax_audioxtr_detach_fd(struct libdax_audioxtr *o, int *fd, int flag);
 */
 int libdax_audioxtr_destroy(struct libdax_audioxtr **xtr, int flag);
 
+#endif /* LIBDAX_AUDIOXTR_H_PUBLIC */
 
 
-#ifdef LIDBAX_AUDIOXTR________________
+#ifdef LIBDAX_AUDIOXTR________________
 
 
 -- place documentation text here ---
 
 
-#endif /* LIDBAX_AUDIOXTR_________________ */
+#endif /* LIBDAX_AUDIOXTR_________________ */
 
 
 

libburn/libdax_msgs.c

@@ -1,9 +1,14 @@
 
 /* libdax_msgs
    Message handling facility of libdax.
-   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
+   Copyright (C) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>,
+   provided under GPL version 2 or later.
 */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -11,6 +16,7 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <sys/time.h>
+#include <pthread.h>
 
 /* Only this single source module is entitled to do this */ 
 #define LIBDAX_MSGS_H_INTERNAL 1
@@ -31,7 +37,7 @@ static int libdax_msgs_item_new(struct libdax_msgs_item **item,
  struct timezone tz;
 
  (*item)= o= 
-           (struct libdax_msgs_item *) malloc(sizeof(struct libdax_msgs_item));
+        (struct libdax_msgs_item *) calloc(1, sizeof(struct libdax_msgs_item));
  if(o==NULL)
    return(-1);
  o->timestamp= 0.0;
@@ -39,7 +45,7 @@ static int libdax_msgs_item_new(struct libdax_msgs_item **item,
  if(ret==0)
    o->timestamp= tv.tv_sec+0.000001*tv.tv_usec;
  o->process_id= getpid();
- o->driveno= -1;
+ o->origin= -1;
  o->severity= LIBDAX_MSGS_SEV_ALL;
  o->priority= LIBDAX_MSGS_PRIO_ZERO;
  o->error_code= 0;
@@ -108,12 +114,12 @@ int libdax_msgs_item_get_msg(struct libdax_msgs_item *item,
 
 
 int libdax_msgs_item_get_origin(struct libdax_msgs_item *item,
-                   double *timestamp, pid_t *process_id, int *driveno,
+                   double *timestamp, pid_t *process_id, int *origin,
                    int flag)
 {
  *timestamp= item->timestamp;
  *process_id= item->process_id;
- *driveno= item->driveno;
+ *origin= item->origin;
  return(1);
 }
 
@@ -134,9 +140,10 @@ int libdax_msgs_new(struct libdax_msgs **m, int flag)
 {
  struct libdax_msgs *o;
 
- (*m)= o= (struct libdax_msgs *) malloc(sizeof(struct libdax_msgs));
+ (*m)= o= (struct libdax_msgs *) calloc(1, sizeof(struct libdax_msgs));
  if(o==NULL)
    return(-1);
+ o->refcount= 1;
  o->oldest= NULL;
  o->youngest= NULL;
  o->count= 0;
@@ -152,43 +159,6 @@ int libdax_msgs_new(struct libdax_msgs **m, int flag)
 }
 
 
-int libdax_msgs_destroy(struct libdax_msgs **m, int flag)
-{
- struct libdax_msgs *o;
- struct libdax_msgs_item *item, *next_item;
-
- o= *m;
- if(o==NULL)
-   return(0);
-
-#ifndef LIBDAX_MSGS_SINGLE_THREADED
- if(pthread_mutex_destroy(&(o->lock_mutex))!=0) {
-   pthread_mutex_unlock(&(o->lock_mutex));
-   pthread_mutex_destroy(&(o->lock_mutex));
- }
-#endif
-
- for(item= o->oldest; item!=NULL; item= next_item) {
-   next_item= item->next;
-   libdax_msgs_item_destroy(&item,0);
- }
- free((char *) o);
- *m= NULL;
- return(1);
-}
-
-
-int libdax_msgs_set_severities(struct libdax_msgs *m, int queue_severity,
-                               int print_severity, char *print_id, int flag)
-{
- m->queue_severity= queue_severity;
- m->print_severity= print_severity;
- strncpy(m->print_id,print_id,80);
- m->print_id[80]= 0;
- return(1);
-}
-
-
 static int libdax_msgs_lock(struct libdax_msgs *m, int flag)
 {
 
@@ -219,6 +189,65 @@ static int libdax_msgs_unlock(struct libdax_msgs *m, int flag)
 }
 
 
+int libdax_msgs_destroy(struct libdax_msgs **m, int flag)
+{
+ struct libdax_msgs *o;
+ struct libdax_msgs_item *item, *next_item;
+
+ o= *m;
+ if(o==NULL)
+   return(0);
+ if(o->refcount > 1) {
+   if(libdax_msgs_lock(*m,0)<=0)
+     return(-1);
+   o->refcount--;
+   libdax_msgs_unlock(*m,0);
+   *m= NULL;
+   return(1);
+ }
+
+#ifndef LIBDAX_MSGS_SINGLE_THREADED
+ if(pthread_mutex_destroy(&(o->lock_mutex))!=0) {
+   pthread_mutex_unlock(&(o->lock_mutex));
+   pthread_mutex_destroy(&(o->lock_mutex));
+ }
+#endif
+
+ for(item= o->oldest; item!=NULL; item= next_item) {
+   next_item= item->next;
+   libdax_msgs_item_destroy(&item,0);
+ }
+ free((char *) o);
+ *m= NULL;
+ return(1);
+}
+
+
+int libdax_msgs_refer(struct libdax_msgs **pt, struct libdax_msgs *m, int flag)
+{
+ if(libdax_msgs_lock(m,0)<=0)
+   return(0);
+ m->refcount++;
+ *pt= m;
+ libdax_msgs_unlock(m,0);
+ return(1);
+}
+
+
+int libdax_msgs_set_severities(struct libdax_msgs *m, int queue_severity,
+                               int print_severity, char *print_id, int flag)
+{
+ if(libdax_msgs_lock(m,0)<=0)
+   return(0);
+ m->queue_severity= queue_severity;
+ m->print_severity= print_severity;
+ strncpy(m->print_id,print_id,80);
+ m->print_id[80]= 0;
+ libdax_msgs_unlock(m,0);
+ return(1);
+}
+
+
 int libdax_msgs__text_to_sev(char *severity_name, int *severity,
                              int flag)
 {
@@ -228,6 +257,10 @@ int libdax_msgs__text_to_sev(char *severity_name, int *severity,
    *severity= LIBDAX_MSGS_SEV_ABORT;
  else if(strncmp(severity_name,"FATAL",5)==0)
    *severity= LIBDAX_MSGS_SEV_FATAL;
+ else if(strncmp(severity_name,"FAILURE",7)==0)
+   *severity= LIBDAX_MSGS_SEV_FAILURE;
+ else if(strncmp(severity_name,"MISHAP",6)==0)
+   *severity= LIBDAX_MSGS_SEV_MISHAP;
  else if(strncmp(severity_name,"SORRY",5)==0)
    *severity= LIBDAX_MSGS_SEV_SORRY;
  else if(strncmp(severity_name,"WARNING",7)==0)
@@ -240,10 +273,12 @@ int libdax_msgs__text_to_sev(char *severity_name, int *severity,
    *severity= LIBDAX_MSGS_SEV_UPDATE;
  else if(strncmp(severity_name,"DEBUG",5)==0)
    *severity= LIBDAX_MSGS_SEV_DEBUG;
+ else if(strncmp(severity_name,"ERRFILE",7)==0)
+   *severity= LIBDAX_MSGS_SEV_ERRFILE;
  else if(strncmp(severity_name,"ALL",3)==0)
    *severity= LIBDAX_MSGS_SEV_ALL;
  else {
-   *severity= LIBDAX_MSGS_SEV_NEVER;
+   *severity= LIBDAX_MSGS_SEV_ALL;
    return(0);
  }
  return(1);
@@ -254,8 +289,7 @@ int libdax_msgs__sev_to_text(int severity, char **severity_name,
                              int flag)
 {
  if(flag&1) {
-   *severity_name= 
-         "NEVER\nABORT\nFATAL\nSORRY\nWARNING\nHINT\nNOTE\nUPDATE\nDEBUG\nALL";
+   *severity_name= "NEVER\nABORT\nFATAL\nFAILURE\nMISHAP\nSORRY\nWARNING\nHINT\nNOTE\nUPDATE\nDEBUG\nERRFILE\nALL";
    return(1);
  }
  *severity_name= "";
@@ -265,6 +299,10 @@ int libdax_msgs__sev_to_text(int severity, char **severity_name,
    *severity_name= "ABORT";
  else if(severity>=LIBDAX_MSGS_SEV_FATAL)
    *severity_name= "FATAL";
+ else if(severity>=LIBDAX_MSGS_SEV_FAILURE)
+   *severity_name= "FAILURE";
+ else if(severity>=LIBDAX_MSGS_SEV_MISHAP)
+   *severity_name= "MISHAP";
  else if(severity>=LIBDAX_MSGS_SEV_SORRY)
    *severity_name= "SORRY";
  else if(severity>=LIBDAX_MSGS_SEV_WARNING)
@@ -277,6 +315,8 @@ int libdax_msgs__sev_to_text(int severity, char **severity_name,
    *severity_name= "UPDATE";
  else if(severity>=LIBDAX_MSGS_SEV_DEBUG)
    *severity_name= "DEBUG";
+ else if(severity>=LIBDAX_MSGS_SEV_ERRFILE)
+   *severity_name= "ERRFILE";
  else if(severity>=LIBDAX_MSGS_SEV_ALL)
    *severity_name= "ALL";
  else {
@@ -287,7 +327,7 @@ int libdax_msgs__sev_to_text(int severity, char **severity_name,
 }
 
 
-int libdax_msgs_submit(struct libdax_msgs *m, int driveno, int error_code,
+int libdax_msgs_submit(struct libdax_msgs *m, int origin, int error_code,
                        int severity, int priority, char *msg_text,
                        int os_errno, int flag)
 {
@@ -325,12 +365,12 @@ int libdax_msgs_submit(struct libdax_msgs *m, int driveno, int error_code,
  ret= libdax_msgs_item_new(&item,m->youngest,0);
  if(ret<=0)
    goto failed;
- item->driveno= driveno;
+ item->origin= origin;
  item->error_code= error_code;
  item->severity= severity;
  item->priority= priority;
  if(msg_text!=NULL) {
-   item->msg_text= malloc(strlen(msg_text)+1);
+   item->msg_text= calloc(1, strlen(msg_text)+1);
    if(item->msg_text==NULL)
      goto failed;
    strcpy(item->msg_text,msg_text);

libburn/libdax_msgs.h

@@ -1,8 +1,8 @@
 
 /* libdax_msgs
-   Message handling facility of libdax.
-   Copyright (C) 2006-2007 Thomas Schmitt <scdbackup@gmx.net>,
-   provided under GPL
+   Message handling facility of libburn and libisofs.
+   Copyright (C) 2006-2011 Thomas Schmitt <scdbackup@gmx.net>,
+   provided under GPL version 2 or later.
 */
 
 
@@ -23,7 +23,7 @@ struct libdax_msgs_item {
 
  double timestamp;
  pid_t process_id;
- int driveno;
+ int origin;
 
  int severity;
  int priority;
@@ -43,6 +43,8 @@ struct libdax_msgs_item {
 
 struct libdax_msgs {
 
+ int refcount;
+
  struct libdax_msgs_item *oldest;
  struct libdax_msgs_item *youngest;
  int count;
@@ -68,6 +70,31 @@ struct libdax_msgs {
 #ifndef LIBDAX_MSGS_H_INTERNAL
 
 
+                          /* Architectural aspects */
+/* 
+  libdax_msgs is designed to serve in libraries which want to offer their
+  applications a way to control the output of library messages. It shall be
+  incorporated by an owner, i.e. a software entity which encloses the code
+  of the .c file.
+
+  Owner of libdax_msgs is libburn. A fully compatible variant named libiso_msgs
+  is owned by libisofs and can get generated by a script of the libburn
+  project: libburn/libdax_msgs_to_xyz_msgs.sh .
+
+  Reason: One cannot link two owners of the same variant together because
+  both would offer the same functions to the linker. For that situation one
+  has to create a compatible variant as it is done for libisofs.
+
+  Compatible variants may get plugged together by call combinations like
+    burn_set_messenger(iso_get_messenger());
+  A new variant would demand a _set_messenger() function if it has to work
+  with libisofs. If only libburn is planned as link partner then a simple
+  _get_messenger() does suffice.
+  Take care to shutdown libburn before its provider of the *_msgs object
+  gets shut down.
+
+*/
+
                           /* Public Opaque Handles */
 
 /** A pointer to this is a opaque handle to a message handling facility */
@@ -86,13 +113,26 @@ struct libdax_msgs_item;
 
 /* It is well advisable to let applications select severities via strings and
    forwarded functions libdax_msgs__text_to_sev(), libdax_msgs__sev_to_text().
-   These macros are for use by libdax/libburn only.
+   These macros are for use by the owner of libdax_msgs.
 */
 
 /** Use this to get messages of any severity. Do not use for submitting.
 */
 #define LIBDAX_MSGS_SEV_ALL                                          0x00000000
 
+
+/** Messages of this severity shall transport plain disk file paths
+    whenever an event of severity SORRY or above is related with an
+    individual disk file.
+    No message text shall be added to the file path. The ERRFILE message
+    shall be issued before the human readable message which carries the
+    true event severity. That message should contain the file path so it
+    can be found by strstr(message, path)!=NULL.
+    The error code shall be the same as with the human readable message.
+*/ 
+#define LIBDAX_MSGS_SEV_ERRFILE                                      0x08000000
+
+
 /** Debugging messages not to be visible to normal users by default
 */
 #define LIBDAX_MSGS_SEV_DEBUG                                        0x10000000
@@ -113,15 +153,70 @@ struct libdax_msgs_item;
 */
 #define LIBDAX_MSGS_SEV_WARNING                                      0x50000000
 
-/** Non-fatal error messages indicating that parts of the action failed
-    but processing will/should go on
+
+/** Non-fatal error messages indicating that parts of an action failed but
+    processing may go on if one accepts deviations from the desired result.
+
+    SORRY may also be the severity for incidents which are severe enough
+    for FAILURE but happen within already started irrevocable actions,
+    like ISO image generation. A precondition for such a severity ease is
+    that the action can be continued after the incident.
+    See below MISHAP for what xorriso would need instead of this kind of SORRY
+    and generates for itself in case of libisofs image generation.
+
+    E.g.: A pattern yields no result.
+          A speed setting cannot be made.
+          A libisofs input file is inaccessible during image generation.
+
+    After SORRY a function should try to go on if that makes any sense
+    and if no threshold prescribes abort on SORRY. The function should
+    nevertheless indicate some failure in its return value. 
+    It should - but it does not have to.
 */
 #define LIBDAX_MSGS_SEV_SORRY                                        0x60000000
 
-/** An error message which puts the whole operation of libdax in question
+
+/** A FAILURE (see below) which can be tolerated during long lasting
+    operations just because they cannot simply be stopped or revoked.
+
+    xorriso converts libisofs SORRY messages issued during image generation
+    into MISHAP messages in order to allow its evaluators to distinguish
+    image generation problems from minor image composition problems.
+    E.g.:
+      A libisofs input file is inaccessible during image generation.
+
+    After a MISHAP a function should behave like after SORRY.
+*/
+#define LIBDAX_MSGS_SEV_MISHAP                                       0x64000000
+
+
+/** Non-fatal error indicating that an important part of an action failed and
+    that only a new setup of preconditions will give hope for sufficient
+    success.
+
+    E.g.: No media is inserted in the output drive.
+          No write mode can be found for inserted media.
+          A libisofs input file is inaccessible during grafting.
+
+    After FAILURE a function should end with a return value indicating failure.
+    It is at the discretion of the function whether it ends immediately in any
+    case or whether it tries to go on if the eventual threshold allows.
+*/
+#define LIBDAX_MSGS_SEV_FAILURE                                      0x68000000
+
+
+/** An error message which puts the whole operation of the program in question
+
+    E.g.: Not enough memory for essential temporary objects.
+          Irregular errors from resources.
+          Programming errors (soft assert).
+
+    After FATAL a function should end very soon with a return value
+    indicating severe failure.
 */
 #define LIBDAX_MSGS_SEV_FATAL                                        0x70000000
 
+
 /** A message from an abort handler which will finally finish libburn
 */
 #define LIBDAX_MSGS_SEV_ABORT                                        0x71000000
@@ -134,7 +229,7 @@ struct libdax_msgs_item;
 
 /* Registered Priorities */
 
-/* Priorities are to be used by libburn/libdax only. */
+/* Priorities are to be selected by the programmers and not by the user. */
 
 #define LIBDAX_MSGS_PRIO_ZERO                                        0x00000000 
 #define LIBDAX_MSGS_PRIO_LOW                                         0x10000000 
@@ -146,12 +241,23 @@ struct libdax_msgs_item;
 #define LIBDAX_MSGS_PRIO_NEVER                                       0x7fffffff
 
 
+/* Origin numbers of libburn drives may range from 0 to 1048575 */
+#define LIBDAX_MSGS_ORIGIN_DRIVE_BASE          0
+#define LIBDAX_MSGS_ORIGIN_DRIVE_TOP     0xfffff
+
+/* Origin numbers of libisofs images may range from 1048575 to 2097152 */
+#define LIBDAX_MSGS_ORIGIN_IMAGE_BASE   0x100000
+#define LIBDAX_MSGS_ORIGIN_IMAGE_TOP    0x1fffff
+
+
+
                             /* Public Functions */
 
-               /* Calls initiated from inside libdax/libburn */
+       /* Calls initiated from inside the direct owner (e.g. from libburn) */
 
 
-/** Create new empty message handling facility with queue.
+/** Create new empty message handling facility with queue and issue a first
+    official reference to it.
     @param flag Bitfield for control purposes (unused yet, submit 0)
     @return >0 success, <=0 failure
 */
@@ -160,18 +266,37 @@ int libdax_msgs_new(struct libdax_msgs **m, int flag);
 
 /** Destroy a message handling facility and all its eventual messages.
     The submitted pointer gets set to NULL.
+    Actually only the last destroy call of all offical references to the object
+    will really dispose it. All others just decrement the reference counter.
+    Call this function only with official reference pointers obtained by
+    libdax_msgs_new() or libdax_msgs_refer(), and only once per such pointer.
     @param flag Bitfield for control purposes (unused yet, submit 0)
-    @return 1 for success, 0 for pointer to NULL
+    @return 1 for success, 0 for pointer to NULL, -1 for fatal error
 */
 int libdax_msgs_destroy(struct libdax_msgs **m, int flag);
 
 
+/** Create an official reference to an existing libdax_msgs object. The
+    references keep the object alive at least until it is released by
+    a matching number of destroy calls. So each reference MUST be revoked
+    by exactly one call to libdax_msgs_destroy().
+    @param pt The pointer to be set and registered
+    @param m  A pointer to the existing object
+    @param flag Bitfield for control purposes (unused yet, submit 0)
+    @return 1 for success, 0 for failure
+*/
+int libdax_msgs_refer(struct libdax_msgs **pt, struct libdax_msgs *o, int flag);
+
+
 /** Submit a message to a message handling facility.
-    @param driveno libdax drive number. Use -1 if no number is known.
+    @param origin  program specific identification number of the originator of
+                   a message. E.g. drive number. Programs should have an own
+                   range of origin numbers. See above LIBDAX_MSGS_ORIGIN_*_BASE
+                   Use -1 if no number is known.
     @param error_code  Unique error code. Use only registered codes. See below.
                    The same unique error_code may be issued at different
                    occasions but those should be equivalent out of the view
-                   of a libdax application. (E.g. "cannot open ATA drive"
+                   of a libdax_msgs application. (E.g. "cannot open ATA drive"
                    versus "cannot open SCSI drive" would be equivalent.)
     @param severity The LIBDAX_MSGS_SEV_* of the event.
     @param priority The LIBDAX_MSGS_PRIO_* number of the event.
@@ -180,12 +305,13 @@ int libdax_msgs_destroy(struct libdax_msgs **m, int flag);
     @param flag Bitfield for control purposes (unused yet, submit 0)
     @return 1 on success, 0 on rejection, <0 for severe errors
 */
-int libdax_msgs_submit(struct libdax_msgs *m, int driveno, int error_code,
+int libdax_msgs_submit(struct libdax_msgs *m, int origin, int error_code,
                        int severity, int priority, char *msg_text, 
                        int os_errno, int flag);
 
 
-     /* Calls from applications (to be forwarded by libdax/libburn) */
+
+     /* Calls from applications (to be forwarded by direct owner) */
 
 
 /** Convert a registered severity number into a severity name
@@ -256,7 +382,7 @@ int libdax_msgs_item_get_msg(struct libdax_msgs_item *item,
     @return 1 on success, 0 on invalid item, <0 for servere errors
 */
 int libdax_msgs_item_get_origin(struct libdax_msgs_item *item, 
-                            double *timestamp, pid_t *process_id, int *driveno,
+                            double *timestamp, pid_t *process_id, int *origin,
                             int flag);
 
 
@@ -269,14 +395,14 @@ int libdax_msgs_item_get_rank(struct libdax_msgs_item *item,
                               int *severity, int *priority, int flag);
 
 
-#ifdef LIDBAX_MSGS_________________
+#ifdef LIBDAX_MSGS_________________
 
 
                       /* Registered Error Codes */
 
 
 Format: error_code  (LIBDAX_MSGS_SEV_*,LIBDAX_MSGS_PRIO_*) = explanation
-If no severity or priority are fixely associates, use "(,)".
+If no severity or priority are fixely associated, use "(,)".
 
 ------------------------------------------------------------------------------
 Range "libdax_msgs"        :  0x00000000 to 0x0000ffff
@@ -284,6 +410,7 @@ Range "libdax_msgs"        :  0x00000000 to 0x0000ffff
  0x00000000 (ALL,ZERO)     = Initial setting in new libdax_msgs_item
  0x00000001 (DEBUG,ZERO)   = Test error message
  0x00000002 (DEBUG,ZERO)   = Debugging message
+ 0x00000003 (FATAL,HIGH)   = Out of virtual memory
 
 
 ------------------------------------------------------------------------------
@@ -304,6 +431,11 @@ Range "scdbackup"          :  0x00020000 to 0x0002ffff
  0x00020006 (FATAL,HIGH)   = Too many scsi siblings
  0x00020007 (NOTE,HIGH)    = Closed O_EXCL scsi siblings
  0x00020008 (SORRY,HIGH)   = Device busy. Failed to fcntl-lock
+ 0x00020009 (SORRY,HIGH)   = Neither stdio-path nor its directory exist
+ 0x0002000a (FAILURE,HIGH) = Cannot accept '...' as SG_IO CDROM drive
+ 0x0002000b (FAILURE,HIGH) = File object '...' not found
+ 0x0002000c (FAILURE,HIGH) = Cannot start device file enumeration
+ 0x0002000d (FAILURE,HIGH) = Cannot enumerate next device
            
  General library operations:
 
@@ -313,7 +445,7 @@ Range "scdbackup"          :  0x00020000 to 0x0002ffff
  0x00020104 (SORRY,HIGH)   = NULL pointer caught
  0x00020105 (SORRY,HIGH)   = Drive is already released
  0x00020106 (SORRY,HIGH)   = Drive is busy on attempt to close
- 0x00020107 (SORRY,HIGH)   = Drive is busy on attempt to shut down library
+ 0x00020107 (WARNING,HIGH) = A drive is still busy on shutdown of library
  0x00020108 (SORRY,HIGH)   = Drive is not grabbed on disc status inquiry
  0x00020108 (FATAL,HIGH)   = Could not allocate new drive object
  0x00020109 (FATAL,HIGH)   = Library not running
@@ -366,18 +498,204 @@ Range "scdbackup"          :  0x00020000 to 0x0002ffff
  0x00020138 (FATAL,HIGH)   = Cannot reserve track
  0x00020139 (SORRY,HIGH)   = Write job parameters are unsuitable
  0x0002013a (FATAL,HIGH)   = No suitable media detected
- 0x0002013b
+ 0x0002013b (DEBUG,HIGH)   = SCSI command indicates host or driver error
  0x0002013c (SORRY,HIGH)   = Malformed capabilities page 2Ah received
+ 0x0002013d (DEBUG,LOW)    = Waiting for free buffer space takes long time
+ 0x0002013e (SORRY,HIGH)   = Timeout with waiting for free buffer. Now disabled
+ 0x0002013f (DEBUG,LOW)    = Reporting total time spent with waiting for buffer
+ 0x00020140 (FATAL,HIGH)   = Drive is busy on attempt to write random access
+ 0x00020141 (SORRY,HIGH)   = Write data count not properly aligned
+ 0x00020142 (FATAL,HIGH)   = Drive is not grabbed on random access write
+ 0x00020143 (SORRY,HIGH)   = Read start address not properly aligned
+ 0x00020144 (SORRY,HIGH)   = SCSI error on read
+ 0x00020145 (FATAL,HIGH)   = Drive is busy on attempt to read data
+ 0x00020146 (FATAL,HIGH)   = Drive is a virtual placeholder
+ 0x00020147 (SORRY,HIGH)   = Cannot address start byte
+ 0x00020148 (SORRY,HIGH)   = Cannot write desired amount of data
+ 0x00020149 (SORRY,HIGH)   = Unsuitable filetype for pseudo-drive
+ 0x0002014a (SORRY,HIGH)   = Cannot read desired amount of data
+ 0x0002014b (SORRY,HIGH)   = Drive is already registered resp. scanned
+ 0x0002014c (FATAL,HIGH)   = Emulated drive caught in SCSI function
+ 0x0002014d (SORRY,HIGH)   = Asynchromous SCSI error
+ 0x0002014f (SORRY,HIGH)   = Timeout with asynchromous SCSI command
+ 0x00020150 (DEBUG,LOW)    = Reporting asynchronous waiting time
+ 0x00020151 (FAILURE,HIGH) = Read attempt on write-only drive
+ 0x00020152 (FATAL,HIGH)   = Cannot start fifo thread
+ 0x00020153 (SORRY,HIGH)   = Read error on fifo input
+ 0x00020154 (NOTE,HIGH)    = Forwarded input error ends output
+ 0x00020155 (SORRY,HIGH)   = Desired fifo buffer too large
+ 0x00020156 (SORRY,HIGH)   = Desired fifo buffer too small
+ 0x00020157 (FATAL,HIGH)   = burn_source is not a fifo object
+ 0x00020158 (DEBUG,LOW)    = Reporting thread disposal precautions
+ 0x00020159 (DEBUG,HIGH)   = TOC Format 0 returns inconsistent data
+ 0x0002015a (NOTE,HIGH)    = Could not examine busy device
+ 0x0002015b (HINT,HIGH)    = Busy '...' seems to be a hard disk, as '...1' exists
+ 0x0002015c (FAILURE,HIGH) = Fifo size too small for desired peek buffer
+ 0x0002015d (FAILURE,HIGH) = Fifo input ended short of desired peek buffer size
+ 0x0002015e (FATAL,HIGH)   = Fifo is already under consumption when peeking
+ 0x0002015f (MISHAP,HIGH)  = Damaged CD table-of-content detected and truncated
+ 0x00020160 (WARNING,HIGH) = Session without leadout encountered
+ 0x00020161 (WARNING,HIGH) = Empty session deleted
+ 0x00020162 (SORRY,HIGH)   = BD-R not unformatted blank any more. Cannot format
+ 0x00020163 (NOTE,HIGH)    = Blank BD-R left unformatted for zero spare capacity
+ 0x00020164 (SORRY,HIGH)   = Drive does not format BD-RE without spares
+ 0x00020165 (WARNING,HIGH) = Drive does not support fast formatting
+ 0x00020166 (WARNING,HIGH) = Drive does not support full formatting
+ 0x00020167 (SORRY,HIGH)   = Drive does not support non-default formatting
+ 0x00020168 (FAILURE,HIGH) = Media not properly formatted. Cannot write.
+ 0x00020169 (WARNING,HIGH) = Last session on media is still open
+ 0x0002016a (FAILURE,HIGH) = No MMC transport adapter is present
+ 0x0002016b (WARNING,HIGH) = No MMC transport adapter is present
+ 0x0002016c (DEBUG,HIGH)   = No MMC transport adapter is present
+ 0x0002016e (DEBUG,HIGH)   = MODE SENSE page 2A too short
+ 0x0002016f (DEBUG,HIGH)   = Unable to grab scanned drive
+ 0x00020170 (NOTE,HIGH)    = Closing open session before writing new one
+ 0x00020171 (NOTE,HIGH)    = Closing BD-R with accidently open session
+ 0x00020172 (SORRY,HIGH)   = Read start address larger than number of readable blocks
+ 0x00020173 (FAILURE,HIGH) = Drive tells NWA smaller than last written address
+ 0x00020174 (SORRY,HIGH)   = Fifo alignment does not allow desired read size
+ 0x00020175 (FATAL,HIGH)   = Supporting library is too old
+ 0x00020176 (NOTE,HIGH)    = Stream recording disabled because of small OS buffer
+ 0x00020177 (ABORT,HIGH)   = Urged drive worker threads to do emergency halt
+ 0x00020178 (DEBUG,HIGH)   = Write thread ended
+ 0x00020179 (FAILURE,HIGH) = Offset source start address is before end of previous source
+ 0x0002017a (FAILURE,HIGH) = Expected offset source object as parameter
+ 0x0002017b (WARNING,HIGH) = Sequential BD-R media likely to soon fail writing
+ 0x0002017c (FAILURE,HIGH) = No valid write type selected
+ 0x0002017d (FATAL,HIGH)   = Invalid file descriptor with stdio pseudo-drive
+ 0x0002017e (FAILURE,HIGH) = Failed to close track, session, or disc
+ 0x0002017f (FAILURE,HIGH) = Failed to synchronize drive cache
+ 0x00020180 (FAILURE,HIGH) = Premature end of input encountered
+ 0x00020181 (FAILURE,HIGH) = Pseudo-drive is a read-only file. Cannot write.
+ 0x00020182 (FAILURE,HIGH) = Cannot truncate disk file for pseudo blanking
+ 0x00020183 (WARNING,HIGH) = Failed to open device (a pseudo-drive) for reading
+ 0x00020184 (WARNING,HIGH) = No Next-Writable-Address
+ 0x00020185 (WARNING,HIGH) = Track damaged, not closed and not writable
+ 0x00020186 (WARNING,HIGH) = Track damaged and not closed
+ 0x00020187 (NOTE,HIGH)    = Track not marked as damaged. No action taken.
+ 0x00020188 (FAILURE,HIGH) = Cannot close damaged track on given media type
+ 0x00020189 (FATAL,HIGH)   = Drive is already grabbed by libburn
 
  libdax_audioxtr:
  0x00020200 (SORRY,HIGH)   = Cannot open audio source file
  0x00020201 (SORRY,HIGH)   = Audio source file has unsuitable format
  0x00020202 (SORRY,HIGH)   = Failed to prepare reading of audio data
- 
+
+
+
+------------------------------------------------------------------------------
+Range "vreixo"              :  0x00030000 to 0x0003ffff
+
+ 0x0003ffff (FAILURE,HIGH) = Operation canceled
+ 0x0003fffe (FATAL,HIGH)   = Unknown or unexpected fatal error
+ 0x0003fffd (FAILURE,HIGH) = Unknown or unexpected error
+ 0x0003fffc (FATAL,HIGH)   = Internal programming error
+ 0x0003fffb (FAILURE,HIGH) = NULL pointer where NULL not allowed
+ 0x0003fffa (FATAL,HIGH)   = Memory allocation error
+ 0x0003fff9 (FATAL,HIGH)   = Interrupted by a signal
+ 0x0003fff8 (FAILURE,HIGH) = Invalid parameter value
+ 0x0003fff7 (FATAL,HIGH)   = Cannot create a needed thread
+ 0x0003fff6 (FAILURE,HIGH) = Write error
+ 0x0003fff5 (FAILURE,HIGH) = Buffer read error
+ 0x0003ffc0 (FAILURE,HIGH) = Trying to add a node already added to another dir
+ 0x0003ffbf (FAILURE,HIGH) = Node with same name already exist
+ 0x0003ffbe (FAILURE,HIGH) = Trying to remove a node that was not added to dir
+ 0x0003ffbd (FAILURE,HIGH) = A requested node does not exist
+ 0x0003ffbc (FAILURE,HIGH) = Image already bootable
+ 0x0003ffbb (FAILURE,HIGH) = Trying to use an invalid file as boot image
+ 0x0003ff80 (FAILURE,HIGH) = Error on file operation
+ 0x0003ff7f (FAILURE,HIGH) = Trying to open an already openned file
+ 0x0003ff7e (FAILURE,HIGH) = Access to file is not allowed
+ 0x0003ff7d (FAILURE,HIGH) = Incorrect path to file
+ 0x0003ff7c (FAILURE,HIGH) = The file does not exist in the filesystem
+ 0x0003ff7b (FAILURE,HIGH) = Trying to read or close a file not openned
+ 0x0003ff7a (FAILURE,HIGH) = Directory used where no dir is expected
+ 0x0003ff79 (FAILURE,HIGH) = File read error
+ 0x0003ff78 (FAILURE,HIGH) = Not dir used where a dir is expected
+ 0x0003ff77 (FAILURE,HIGH) = Not symlink used where a symlink is expected
+ 0x0003ff76 (FAILURE,HIGH) = Cannot seek to specified location
+ 0x0003ff75 (HINT,MEDIUM)  = File not supported in ECMA-119 tree and ignored
+ 0x0003ff74 (HINT,MEDIUM)  = File bigger than supported by used standard
+ 0x0003ff73 (MISHAP,HIGH)  = File read error during image creation
+ 0x0003ff72 (HINT,MEDIUM)  = Cannot convert filename to requested charset
+ 0x0003ff71 (SORRY,HIGH)   = File cannot be added to the tree
+ 0x0003ff70 (HINT,MEDIUM)  = File path breaks specification constraints
+ 0x0003ff00 (FAILURE,HIGH) = Charset conversion error
+ 0x0003feff (FAILURE,HIGH) = Too much files to mangle
+ 0x0003fec0 (FAILURE,HIGH) = Wrong or damaged Primary Volume Descriptor
+ 0x0003febf (SORRY,HIGH)   = Wrong or damaged RR entry
+ 0x0003febe (SORRY,HIGH)   = Unsupported RR feature
+ 0x0003febd (FAILURE,HIGH) = Wrong or damaged ECMA-119
+ 0x0003febc (FAILURE,HIGH) = Unsupported ECMA-119 feature
+ 0x0003febb (SORRY,HIGH)   = Wrong or damaged El-Torito catalog
+ 0x0003feba (SORRY,HIGH)   = Unsupported El-Torito feature
+ 0x0003feb9 (SORRY,HIGH)   = Cannot patch isolinux boot image
+ 0x0003feb8 (SORRY,HIGH)   = Unsupported SUSP feature
+ 0x0003feb7 (WARNING,HIGH) = Error on a RR entry that can be ignored
+ 0x0003feb6 (HINT,MEDIUM)  = Error on a RR entry that can be ignored
+ 0x0003feb5 (WARNING,HIGH) = Multiple ER SUSP entries found
+ 0x0003feb4 (HINT,MEDIUM)  = Unsupported volume descriptor found
+ 0x0003feb3 (WARNING,HIGH) = El-Torito related warning
+ 0x0003feb2 (MISHAP,HIGH)  = Image write cancelled
+ 0x0003feb1 (WARNING,HIGH) = El-Torito image is hidden
+
+Outdated codes which may not be re-used for other purposes than
+re-instating them, if ever:
+
+X 0x00031001 (SORRY,HIGH)    = Cannot read file (ignored)
+X 0x00031002 (FATAL,HIGH)    = Cannot read file (operation canceled)
+X 0x00031000 (FATAL,HIGH)    = Unsupported ISO-9660 image
+X 0x00031001 (HINT,MEDIUM)   = Unsupported Vol Desc that will be ignored
+X 0x00031002 (FATAL,HIGH)    = Damaged ISO-9660 image
+X 0x00031003 (SORRY,HIGH)    = Cannot read previous image file
+X 0x00030101 (HINT,MEDIUM)   = Unsupported SUSP entry that will be ignored
+X 0x00030102 (SORRY,HIGH)    = Wrong/damaged SUSP entry
+X 0x00030103 (WARNING,MEDIUM)= Multiple SUSP ER entries where found
+X 0x00030111 (SORRY,HIGH)    = Unsupported RR feature
+X 0x00030112 (SORRY,HIGH)    = Error in a Rock Ridge entry
+X 0x00030201 (HINT,MEDIUM)   = Unsupported Boot Vol Desc that will be ignored
+X 0x00030202 (SORRY,HIGH)    = Wrong El-Torito catalog
+X 0x00030203 (HINT,MEDIUM)   = Unsupported El-Torito feature
+X 0x00030204 (SORRY,HIGH)    = Invalid file to be an El-Torito image
+X 0x00030205 (WARNING,MEDIUM)= Cannot properly patch isolinux image
+X 0x00030206 (WARNING,MEDIUM)= Copying El-Torito from a previous image without
+X                              enought info about it
+X 0x00030301 (NOTE,MEDIUM)   = Unsupported file type for Joliet tree
+
+
+------------------------------------------------------------------------------
+Range "application"         :  0x00040000 to 0x0004ffff
+
+ 0x00040000 (ABORT,HIGH)    : Application supplied message
+ 0x00040001 (FATAL,HIGH)    : Application supplied message
+ 0x00040002 (SORRY,HIGH)    : Application supplied message
+ 0x00040003 (WARNING,HIGH)  : Application supplied message
+ 0x00040004 (HINT,HIGH)     : Application supplied message
+ 0x00040005 (NOTE,HIGH)     : Application supplied message
+ 0x00040006 (UPDATE,HIGH)   : Application supplied message
+ 0x00040007 (DEBUG,HIGH)    : Application supplied message
+ 0x00040008 (*,HIGH)        : Application supplied message
+
+
+------------------------------------------------------------------------------
+Range "libisofs-xorriso"    :  0x00050000 to 0x0005ffff
+
+This is an alternative representation of libisofs.so.6 error codes in xorriso.
+If values returned by iso_error_get_code() do not fit into 0x30000 to 0x3ffff
+then they get truncated to 16 bit and mapped into this range.
+(This should never need to happen, of course.)
+
+------------------------------------------------------------------------------
+Range "libisoburn"          :  0x00060000 to 0x00006ffff
+
+ 0x00060000 (*,*)           : Message which shall be attributed to libisoburn
+
+ >>> the messages of libisoburn need to be registered individually
+
 
 ------------------------------------------------------------------------------
 
-#endif /* LIDBAX_MSGS_________________ */
+#endif /* LIBDAX_MSGS_________________ */
 
 
 

libburn/libdax_msgs_to_xyz_msgs.sh

@@ -0,0 +1,37 @@
+#!/bin/sh
+
+# libdax_msgs_to_iso_msgs.sh
+# generates ${xyz}_msgs.[ch] from libdax_msgs.[ch]
+# To be executed within  ./libburn-*  resp ./cdrskin-*
+
+# The module name for the generated sourcecode in several
+# uppercase-lowercase forms
+xyz="libiso"
+Xyz="Libiso"
+XYZ="LIBISO"
+
+# The project name for which the generated code shall serve
+project="libisofs"
+
+
+for i in libburn/libdax_msgs.[ch]
+do
+  target_adr=$(echo "$i" | sed -e "s/libdax_/${xyz}_/")
+
+  echo "$target_adr"
+
+  sed \
+    -e "s/^\/\* libdax_msgs/\/* ${xyz}_msgs   (generated from XYZ_msgs : $(date))/" \
+    -e "s/Message handling facility of libdax/Message handling facility of ${project}/" \
+    -e "s/libdax_/${xyz}_/g" \
+    -e "s/libdax:/${xyz}:/g" \
+    -e "s/Libdax_/${Xyz}_/g" \
+    -e "s/LIBDAX_/${XYZ}_/g" \
+    -e "s/generated from XYZ_msgs/generated from libdax_msgs/" \
+    -e "s/${xyz}_msgs is designed to serve in libraries/libdax_msgs is designed to serve in libraries/" \
+    -e "s/Owner of ${xyz}_msgs is libburn/Owner of libdax_msgs is libburn/" \
+  \
+  <"$i" >"$target_adr"
+
+done
+

libburn/mmc.h

@@ -1,5 +1,11 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
 #ifndef __MMC
 #define __MMC
 
@@ -68,8 +74,45 @@ int mmc_compose_mode_page_5(struct burn_drive *d,
                             const struct burn_write_opts *o,
                             unsigned char *pd);
 
+/* ts A70201 */
+int mmc_four_char_to_int(unsigned char *data);
+
+/* ts A70812 : return 0 = ok , return BE_CANCELLED = error occured */
+int mmc_read_10(struct burn_drive *d, int start, int amount,
+                struct buffer *buf);
+
+/* ts A81210 : Determine the upper limit of readable data size */
+int mmc_read_capacity(struct burn_drive *d);
+
+/* ts A61201 */
+char *mmc_obtain_profile_name(int profile_number);
+
 
 /* mmc5r03c.pdf 4.3.4.4.1 d) "The maximum number of RZones is 2 302." */
 #define BURN_MMC_FAKE_TOC_MAX_SIZE 2302
 
+
+/* ts A90903 */
+/* MMC backend of API call burn_get_media_product_id()
+*/
+int mmc_get_media_product_id(struct burn_drive *d,
+        char **product_id, char **media_code1, char **media_code2,
+	char **book_type, int flag);
+
+
+/* ts A60910 (estimated) */
+int mmc_function_spy(struct burn_drive *d, char * text);
+
+/* ts A91118 */
+int mmc_start_if_needed(struct burn_drive *d, int flag);
+
+/* ts B00924 */
+int mmc_get_bd_spare_info(struct burn_drive *d,
+                                int *alloc_blocks, int *free_blocks, int flag);
+
+/* ts B10801 */
+int mmc_get_phys_format_info(struct burn_drive *d, int *disk_category,
+                        char **book_name, int *part_version, int *num_layers,
+                        int *num_blocks, int flag);
+
 #endif /*__MMC*/

libburn/null.c

@@ -1,5 +1,14 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Provided under GPL version 2 or later.
+*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include "null.h"
 #include "libburn.h"
 #include <stdlib.h>
@@ -15,7 +24,7 @@ struct burn_source *burn_null_source_new(void)
 {
 	struct burn_source *src;
 
-	src = malloc(sizeof(struct burn_source));
+	src = calloc(1, sizeof(struct burn_source));
 	src->refcount = 1;
 	src->read = null_read;
 	src->read_sub = NULL;

libburn/options.c

@@ -1,3 +1,13 @@
+
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include "libburn.h"
 #include "options.h"
 #include "drive.h"
@@ -17,7 +27,7 @@ struct burn_write_opts *burn_write_opts_new(struct burn_drive *drive)
 {
 	struct burn_write_opts *opts;
 
-	opts = malloc(sizeof(struct burn_write_opts));
+	opts = calloc(1, sizeof(struct burn_write_opts));
 	if (opts == NULL) {
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020111,
 			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
@@ -38,6 +48,9 @@ struct burn_write_opts *burn_write_opts_new(struct burn_drive *drive)
 	opts->start_byte = -1;
 	opts->fill_up_media = 0;
 	opts->force_is_set = 0;
+	opts->do_stream_recording = 0;
+	opts->dvd_obs_override = 0;
+	opts->stdio_fsync_size = Libburn_stdio_fsync_limiT;
 	opts->has_mediacatalog = 0;
 	opts->format = BURN_CDROM;
 	opts->multi = 0;
@@ -55,7 +68,7 @@ struct burn_read_opts *burn_read_opts_new(struct burn_drive *drive)
 {
 	struct burn_read_opts *opts;
 
-	opts = malloc(sizeof(struct burn_read_opts));
+	opts = calloc(1, sizeof(struct burn_read_opts));
 	opts->drive = drive;
 	opts->refcount = 1;
 	opts->raw = 0;
@@ -112,7 +125,7 @@ void burn_write_opts_set_toc_entries(struct burn_write_opts *opts, int count,
 				     struct burn_toc_entry *toc_entries)
 {
 	opts->toc_entries = count;
-	opts->toc_entry = malloc(count * sizeof(struct burn_toc_entry));
+	opts->toc_entry = calloc(count, sizeof(struct burn_toc_entry));
 	memcpy(opts->toc_entry, &toc_entries,
 	       sizeof(struct burn_toc_entry) * count);
 }
@@ -124,16 +137,26 @@ void burn_write_opts_set_format(struct burn_write_opts *opts, int format)
 
 int burn_write_opts_set_simulate(struct burn_write_opts *opts, int sim)
 {
+/* <<< ts A70529 :
+       One cannot predict the ability to simulate from page 05h
+       information alone. This check is now done later in 
+       function  burn_write_opts_auto_write_type().
+
 	if (opts->drive->mdata->simulate) {
 		opts->simulate = sim;
 		return 1;
 	}
 	return 0;
+*/
+	opts->simulate = !!sim;
+	return 1;
 }
 
 int burn_write_opts_set_underrun_proof(struct burn_write_opts *opts,
 				       int underrun_proof)
 {
+	if (opts->drive->mdata->valid <= 0)
+		return 0;
 	if (opts->drive->mdata->underrun_proof) {
 		opts->underrun_proof = underrun_proof;
 		return 1;
@@ -265,6 +288,8 @@ no_caps:;
 	} else if (caps->might_do_sao >= 3 && !(flag & 1))
 		goto try_tao;
 do_sao:;
+	if (caps->might_simulate == 0 && opts->simulate && !opts->force_is_set)
+		goto no_simulate;
 	if (!(flag & 1))
 		burn_write_opts_set_write_type(
 					opts, BURN_WRITE_SAO, BURN_BLOCK_SAO);
@@ -296,6 +321,8 @@ try_tao:;
 	if (strcmp(reason_pt, "TAO: ") != 0)
 		goto no_tao;
 	/* ( TAO data/audio block size will be handled automatically ) */
+	if (caps->might_simulate == 0 && opts->simulate && !opts->force_is_set)
+		goto no_simulate;
 	if (!(flag & 1))
 		burn_write_opts_set_write_type(
 				opts, BURN_WRITE_TAO, BURN_BLOCK_MODE1);
@@ -323,13 +350,21 @@ try_raw:;
 		strcat(reasons, "drive dislikes block type, ");
 	if (strcmp(reason_pt, "RAW: ") != 0)
 		goto no_write_mode;
+	if (!opts->force_is_set)
+		goto no_simulate;
 
 	/*  For now: no setting of raw write modes */
 
 	{wt = BURN_WRITE_RAW; goto ex;}
 
 no_write_mode:;
-	wt = BURN_WRITE_NONE;
+	{wt = BURN_WRITE_NONE; goto ex;}
+
+no_simulate:;
+	strcat(reasons,
+	       "simulation of write job not supported by drive and media, ");
+	{wt = BURN_WRITE_NONE; goto ex;}
+	
 ex:;
 	burn_disc_free_multi_caps(&caps);
 	if (wt == BURN_WRITE_NONE && !(flag & 3)) {
@@ -358,6 +393,42 @@ void burn_write_opts_set_force(struct burn_write_opts *opts, int use_force)
 }
 
 
+/* ts A80412: API */
+void burn_write_opts_set_stream_recording(struct burn_write_opts *opts,
+					 int value)
+{
+	opts->do_stream_recording = value;
+}
+
+
+/* ts A91115: API */
+void burn_write_opts_set_dvd_obs(struct burn_write_opts *opts, int obs)
+{
+	if (obs != 0 && obs != 32 * 1024 && obs != 64 * 1024)
+		return;
+	opts->dvd_obs_override = obs;
+}
+
+
+/* ts A91115: API */
+void burn_write_opts_set_stdio_fsync(struct burn_write_opts *opts, int rythm)
+{
+	if (rythm == -1)
+		opts->stdio_fsync_size = 0;
+	else if (rythm == 0)
+		opts->stdio_fsync_size = Libburn_stdio_fsync_limiT;
+	else if (rythm >= 32)
+		opts->stdio_fsync_size = rythm;
+}
+
+
+/* ts A70901: API */
+struct burn_drive *burn_write_opts_get_drive(struct burn_write_opts *opts)
+{
+	return opts->drive;
+}
+
+
 void burn_read_opts_set_raw(struct burn_read_opts *opts, int raw)
 {
 	opts->raw = raw;

libburn/options.h

@@ -1,3 +1,9 @@
+
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
 #ifndef BURN__OPTIONS_H
 #define BURN__OPTIONS_H
 
@@ -49,6 +55,21 @@ struct burn_write_opts
 	*/
 	int force_is_set;
 
+	/* ts A80412 : whether to use WRITE12 with Streaming bit set
+	   rather than WRITE10. Speeds up DVD-RAM. Might help with BD-RE.
+	   This gets transferred to burn_drive.do_stream_recording
+	*/
+	int do_stream_recording;
+
+	/* ts A91115 : override value for .obs on DVD media.
+	   Only values 0, 32K and 64K are allowed for now. */
+	int dvd_obs_override;
+
+	/* ts A91115 : size of the fsync() interval for stdio writing.
+	   Values 0 or >= 32 counted in 2 KB blocks. */
+	int stdio_fsync_size;
+
+
 	/** A disc can have a media catalog number */
 	int has_mediacatalog;
 	unsigned char mediacatalog[13];
@@ -59,6 +80,11 @@ struct burn_write_opts
 	unsigned char multi;
 };
 
+/* Default value for burn_write_opts.stdio_flush_size
+*/
+#define Libburn_stdio_fsync_limiT 8192
+
+
 /** Options for disc reading operations. This should be created with
     burn_read_opts_new() and freed with burn_read_opts_free(). */
 struct burn_read_opts

libburn/os-dummy.h

@@ -0,0 +1,88 @@
+
+/* os-dummy.h
+   Operating system specific libburn definitions and declarations. Included
+   by os.h in case of compilation for
+           Unknown POSIX like systems
+           with the dummy MMC transport adapter sg-dummy.c
+
+   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
+*/
+
+
+/** List of all signals which shall be caught by signal handlers and trigger
+    a graceful abort of libburn. (See man 7 signal.)
+*/
+/* Once as system defined macros */
+#define BURN_OS_SIGNAL_MACRO_LIST \
+ SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGABRT, \
+ SIGFPE, SIGSEGV, SIGPIPE, SIGALRM, SIGTERM, \
+ SIGUSR1, SIGUSR2, SIGXCPU, SIGTSTP, SIGTTIN, \
+ SIGTTOU
+
+/* Once as text 1:1 list of strings for messages and interpreters */
+#define BURN_OS_SIGNAL_NAME_LIST \
+ "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGABRT", \
+ "SIGFPE", "SIGSEGV", "SIGPIPE", "SIGALRM", "SIGTERM", \
+ "SIGUSR1", "SIGUSR2", "SIGXCPU", "SIGTSTP", "SIGTTIN", \
+ "SIGTTOU"
+
+/* The number of above list items */
+#define BURN_OS_SIGNAL_COUNT 16
+
+/** The list of all signals which shall surely not be caught.
+    It depends on the particular signal whether it can be ignored or whether
+    it will lead to sudden death of the process.
+    Some signals are not POSIX,
+    but nevertheless ought to be ignored if they are defined.
+*/
+
+#ifdef SIGWINCH
+#define BURN_OS_SIG_WINCH ,SIGWINCH
+#define BURN_OS_SIG_WINCH_CNT 1
+#else
+#define BURN_OS_SIG_WINCH 
+#define BURN_OS_SIG_WINCH_CNT 0
+#endif
+
+#ifdef SIGURG
+#define BURN_OS_SIG_URG ,SIGURG
+#define BURN_OS_SIG_URG_CNT 1
+#else
+#define BURN_OS_SIG_URG 
+#define BURN_OS_SIG_URG_CNT 0
+#endif
+
+/** The combined list of all signals which shall not be caught.
+ */
+#define BURN_OS_NON_SIGNAL_MACRO_LIST \
+SIGKILL, SIGCHLD, SIGSTOP BURN_OS_SIG_WINCH BURN_OS_SIG_URG
+
+/* The number of above list items */
+#define BURN_OS_NON_SIGNAL_COUNT \
+( 3 + BURN_OS_SIG_WINCH_CNT + BURN_OS_SIG_URG_CNT )
+
+
+/* The maximum size for a (SCSI) i/o transaction */
+/* Important : MUST be at least 32768 ! */
+#define BURN_OS_TRANSPORT_BUFFER_SIZE 65536
+
+
+/* To hold the position of the most recently delivered address from
+   device enumeration.
+*/
+struct burn_drive_enumerator_struct {
+	int pos;
+	int info_count;
+	char **info_list;
+};
+
+#define BURN_OS_DEFINE_DRIVE_ENUMERATOR_T \
+typedef struct burn_drive_enumerator_struct burn_drive_enumerator_t;
+
+
+/* The list of operating system dependent elements in struct burn_drive.
+   Usually they are initialized in  sg-*.c:enumerate_common().
+*/
+#define BURN_OS_TRANSPORT_DRIVE_ELEMENTS \
+	int just_a_dummy;
+

libburn/os-freebsd.h

@@ -4,7 +4,8 @@
    by os.h in case of compilation for
                                   FreeBSD with CAM
 
-   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
+   Copyright (C) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>,
+   provided under GPLv2+
 */
 
 /** List of all signals which shall be caught by signal handlers and trigger
@@ -41,7 +42,11 @@ SIGKILL, SIGCHLD, SIGSTOP, SIGURG, SIGWINCH
 
 /* The maximum size for a (SCSI) i/o transaction */
 /* Important : MUST be at least 32768 ! */
-#define BURN_OS_TRANSPORT_BUFFER_SIZE 32768
+/* Older BSD info says that 32 kB is maximum. But 64 kB seems to work well
+   on 8-STABLE. It is by default only used with BD in streaming mode.
+   So older systems should still be quite safe with this buffer max size.
+*/
+#define BURN_OS_TRANSPORT_BUFFER_SIZE 65536
 
 
 /** To hold all state information of BSD device enumeration
@@ -57,5 +62,8 @@ typedef struct burn_drive_enumeration_state *burn_drive_enumerator_t;
    To be initialized and used within sg-*.c .
 */
 #define BURN_OS_TRANSPORT_DRIVE_ELEMENTS \
-struct cam_device* cam;
+struct cam_device* cam; \
+int lock_fd; \
+int is_ahci; \
+
 

libburn/os-libcdio.h

@@ -0,0 +1,95 @@
+
+/* os-libcdio.h
+   Operating system specific libburn definitions and declarations. Included
+   by os.h in case of compilation for
+           Unknown X/Open-like systems
+           with GNU libcdio MMC transport adapter sg-libcdio.c
+
+   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
+*/
+
+
+/** List of all signals which shall be caught by signal handlers and trigger
+    a graceful abort of libburn. (See man 7 signal.)
+*/
+/* Once as system defined macros */
+#define BURN_OS_SIGNAL_MACRO_LIST \
+ SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGABRT, \
+ SIGFPE, SIGSEGV, SIGPIPE, SIGALRM, SIGTERM, \
+ SIGUSR1, SIGUSR2, SIGXCPU, SIGTSTP, SIGTTIN, \
+ SIGTTOU
+
+/* Once as text 1:1 list of strings for messages and interpreters */
+#define BURN_OS_SIGNAL_NAME_LIST \
+ "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGABRT", \
+ "SIGFPE", "SIGSEGV", "SIGPIPE", "SIGALRM", "SIGTERM", \
+ "SIGUSR1", "SIGUSR2", "SIGXCPU", "SIGTSTP", "SIGTTIN", \
+ "SIGTTOU"
+
+/* The number of above list items */
+#define BURN_OS_SIGNAL_COUNT 16
+
+
+/** The list of all signals which shall surely not be caught.
+    It depends on the particular signal whether it can be ignored or whether
+    it will lead to sudden death of the process.
+    Some signals are not POSIX,
+    but nevertheless ought to be ignored if they are defined.
+*/
+
+#ifdef SIGWINCH
+#define BURN_OS_SIG_WINCH ,SIGWINCH
+#define BURN_OS_SIG_WINCH_CNT 1
+#else
+#define BURN_OS_SIG_WINCH 
+#define BURN_OS_SIG_WINCH_CNT 0
+#endif
+
+#ifdef SIGURG
+#define BURN_OS_SIG_URG ,SIGURG
+#define BURN_OS_SIG_URG_CNT 1
+#else
+#define BURN_OS_SIG_URG 
+#define BURN_OS_SIG_URG_CNT 0
+#endif
+
+/** The combined list of all signals which shall not be caught.
+ */
+#define BURN_OS_NON_SIGNAL_MACRO_LIST \
+SIGKILL, SIGCHLD, SIGSTOP BURN_OS_SIG_WINCH BURN_OS_SIG_URG
+
+/* The number of above list items */
+#define BURN_OS_NON_SIGNAL_COUNT \
+( 3 + BURN_OS_SIG_WINCH_CNT + BURN_OS_SIG_URG_CNT )
+
+
+/* The maximum size for a (SCSI) i/o transaction */
+/* My Blu-ray burner LG GGW-H20 writes junk if stream recording is combined
+   with buffer size 32 kB. So stream recording is allowed only with size 64k.
+   Older BSD info says that 32 kB is maximum. But 64 kB seems to work well
+   on 8-STABLE. It is by default only used with BD in streaming mode.
+   So older systems should still be quite safe with this buffer max size.
+*/
+/* Important : MUST be at least 32768 ! */
+#define BURN_OS_TRANSPORT_BUFFER_SIZE 65536
+
+
+/* To hold the position of the most recently delivered address from
+   device enumeration.
+*/
+struct burn_drive_enumerator_struct {
+	char **ppsz_cd_drives;
+	char **pos;
+};
+
+#define BURN_OS_DEFINE_DRIVE_ENUMERATOR_T \
+typedef struct burn_drive_enumerator_struct burn_drive_enumerator_t;
+
+
+/* The list of operating system dependent elements in struct burn_drive.
+   Usually they are initialized in  sg-*.c:enumerate_common().
+*/
+#define BURN_OS_TRANSPORT_DRIVE_ELEMENTS \
+	void *p_cdio; /* actually a pointer to CdIo_t */ \
+	char libcdio_name[4096]; /* The drive path as used by libcdio */ \
+

libburn/os-linux.h

@@ -2,9 +2,10 @@
 /* os-linux.h
    Operating system specific libburn definitions and declarations. Included
    by os.h in case of compilation for
-           Linux kernels 2.4 and 2.6 with Linux SCSI Generic (sg)
+           Linux kernels 2.4 and 2.6, GNU/Linux SCSI Generic (sg)
 
-   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
+   Copyright (C) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
 */
 
 
@@ -42,14 +43,26 @@ SIGKILL, SIGCHLD, SIGSTOP, SIGURG, SIGWINCH
 
 /* The maximum size for a (SCSI) i/o transaction */
 /* Important : MUST be at least 32768 ! */
+/* ts A70523 : >32k seems not good with kernel 2.4 USB drivers and audio
+   #define BURN_OS_TRANSPORT_BUFFER_SIZE 32768
+*/
+/* ts A80414 : curbed in write.c CD media to Libburn_cd_obS = 32 kiB
+               re-enlarged transport to 64 kiB for BD-RE experiments
+*/
 #define BURN_OS_TRANSPORT_BUFFER_SIZE 65536
 
 
-/* To hold the index number of the most recently delivered address from
+/* To hold the position of the most recently delivered address from
    device enumeration.
 */
+struct burn_drive_enumerator_struct {
+	int pos;
+	int info_count;
+	char **info_list;
+};
+
 #define BURN_OS_DEFINE_DRIVE_ENUMERATOR_T \
-typedef int burn_drive_enumerator_t;
+typedef struct burn_drive_enumerator_struct burn_drive_enumerator_t;
 
 
 /* Parameters for sibling list. See sibling_fds, sibling_fnames */

libburn/os-solaris.h

@@ -0,0 +1,66 @@
+
+/* os-solaris.h
+   Operating system specific libburn definitions and declarations. Included
+   by os.h in case of compilation for
+           Solaris based systems, e.g. SunOS 5.11
+           with Solaris uscsi MMC transport adapter sg-solaris.c
+
+   Copyright (C) 2010 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
+*/
+
+
+/** List of all signals which shall be caught by signal handlers and trigger
+    a graceful abort of libburn. (See man signal.h)
+*/
+/* Once as system defined macros */
+#define BURN_OS_SIGNAL_MACRO_LIST \
+ SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGABRT, \
+ SIGFPE, SIGSEGV, SIGPIPE, SIGALRM, SIGTERM, \
+ SIGUSR1, SIGUSR2, SIGXCPU, SIGTSTP, SIGTTIN, \
+ SIGTTOU
+
+/* Once as text 1:1 list of strings for messages and interpreters */
+#define BURN_OS_SIGNAL_NAME_LIST \
+ "SIGHUP", "SIGINT", "SIGQUIT", "SIGILL", "SIGABRT", \
+ "SIGFPE", "SIGSEGV", "SIGPIPE", "SIGALRM", "SIGTERM", \
+ "SIGUSR1", "SIGUSR2", "SIGXCPU", "SIGTSTP", "SIGTTIN", \
+ "SIGTTOU"
+
+/* The number of above list items */
+#define BURN_OS_SIGNAL_COUNT 16
+
+/** To list all signals which shall surely not be caught */
+#define BURN_OS_NON_SIGNAL_MACRO_LIST \
+SIGKILL, SIGCHLD, SIGSTOP, SIGURG, SIGWINCH
+
+/* The number of above list items */
+#define BURN_OS_NON_SIGNAL_COUNT 5
+
+
+/* The maximum size for a (SCSI) i/o transaction */
+/* Important : MUST be at least 32768 ! */
+/* My Blu-ray burner LG GGW-H20 writes junk if stream recording is combined
+   with buffer size 32 kB. So stream recording is allowed only with size 64k.
+*/
+#define BURN_OS_TRANSPORT_BUFFER_SIZE 65536
+
+
+/* >>> */
+
+/* To hold the position of the most recently delivered address from
+   device enumeration.
+*/
+struct burn_drive_enumerator_struct {
+	void *dir;
+};
+
+#define BURN_OS_DEFINE_DRIVE_ENUMERATOR_T \
+typedef struct burn_drive_enumerator_struct burn_drive_enumerator_t;
+
+
+/* The list of operating system dependent elements in struct burn_drive.
+   Usually they are initialized in  sg-*.c:enumerate_common().
+*/
+#define BURN_OS_TRANSPORT_DRIVE_ELEMENTS \
+	int fd;
+

libburn/os.h

@@ -3,7 +3,7 @@
    Operating system specific libburn definitions and declarations.
    The macros defined here are used by libburn modules in order to
    avoid own system dependent case distinctions.
-   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
+   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
 */
 
 #ifndef BURN_OS_H_INCLUDED
@@ -13,6 +13,23 @@
    Operating system case distinction
 */
 
+
+#ifdef Libburn_use_sg_dummY
+
+
+/* --------- Any other system. With dummy MMC transport sg-dummy.c --------- */
+#include "os-dummy.h"
+
+
+#else
+#ifdef Libburn_use_libcdiO
+
+
+/* -------------------------- X/Open with GNU libcdio ---------------------- */
+#include "os-libcdio.h"
+
+
+#else
 #ifdef __FreeBSD__
 
 
@@ -20,14 +37,43 @@
 #include "os-freebsd.h"
 
 
-#else  /* operating system case distinction */
+#else
+#ifdef __FreeBSD_kernel__
 
 
-/* --------- Linux kernels 2.4 and 2.6 with Linux SCSI Generic (sg) -------- */
+/* ----------------------- FreeBSD with CAM under Debian ------------------- */
+#include "os-freebsd.h"
+
+
+#else
+#ifdef __linux
+
+
+/* ------- Linux kernels 2.4 and 2.6 with GNU/Linux SCSI Generic (sg) ------ */
 #include "os-linux.h"
 
 
-#endif /* End of operating system case distinction */
+#else
+#ifdef __sun
+
+
+/* ------- Solaris (e.g. SunOS 5.11) with uscsi ------ */
+#include "os-solaris.h"
+
+
+#else
+
+
+/* --------- Any other system. With dummy MMC transport sg-dummy.c --------- */
+#include "os-dummy.h"
+
+
+#endif /* ! __sun*/
+#endif /* ! __linux */
+#endif /* ! __FreeBSD__kernel__ */
+#endif /* ! __FreeBSD__ */
+#endif /* ! Libburn_use_libcdiO */
+#endif /* ! Libburn_use_sg_dummY */
 
 
 #endif /* ! BURN_OS_H_INCLUDED */

libburn/read.c

@@ -1,6 +1,13 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* #include <m alloc.h>  ts A61013 : not in Linux man 3 malloc */
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
 
 #include <stdlib.h>
 #include <unistd.h>
@@ -12,6 +19,9 @@
 #include <stdio.h>
 #include <string.h>
 #include <ctype.h>
+#include <fcntl.h>
+#include <errno.h>
+
 #include "sector.h"
 #include "libburn.h"
 #include "drive.h"
@@ -24,13 +34,18 @@
 #include "crc.h"
 #include "debug.h"
 #include "init.h"
-#include "lec.h"
 #include "toc.h"
 #include "util.h"
 #include "sg.h"
 #include "read.h"
 #include "options.h"
 
+/* ts A70812 */
+#include "error.h"
+#include "libdax_msgs.h"
+extern struct libdax_msgs *libdax_messenger;
+
+
 void burn_disc_read(struct burn_drive *d, const struct burn_read_opts *o)
 {
 #if 0
@@ -39,7 +54,7 @@ void burn_disc_read(struct burn_drive *d, const struct burn_read_opts *o)
 	int drive_lba;
 	unsigned short crc;
 	unsigned char fakesub[96];
-	struct buffer page;
+	struct buffer page;  <- needs to become dynamic memory
 	int speed;
 
 	/* ts A61007 : if this function gets revived, then these
@@ -86,7 +101,13 @@ drive, or only store a subset of the _opts structs in drives */
 		fakesub[20] = 2;
 		fakesub[12] = (d->toc->toc_entry[0].control << 4) +
 			d->toc->toc_entry[0].adr;
+
+#ifdef Libburn_no_crc_C
+		crc = 0; /* dummy */
+#else
 		crc = crc_ccitt(fakesub + 12, 10);
+#endif
+
 		fakesub[22] = crc >> 8;
 		fakesub[23] = crc & 0xFF;
 		write(o->subfd, fakesub, 96);
@@ -94,7 +115,6 @@ drive, or only store a subset of the _opts structs in drives */
 	while (1) {
 		seclen = burn_sector_length_read(d, o);
 
-		burn_print(12, "received %d blocks\n", page.sectors);
 		for (i = 0; i < page.sectors; i++) {
 			burn_packet_process(d, page.data + seclen * i, o);
 			d->track_end--;
@@ -102,7 +122,6 @@ drive, or only store a subset of the _opts structs in drives */
 		}
 
 		if ((d->cancel) || (drive_lba == LAST_SESSION_END(d))) {
-			burn_print(1, "finished or cancelled\n");
 			d->busy = BURN_DRIVE_IDLE;
 			if (!d->cancel)
 				d->toc->complete = 1;
@@ -116,16 +135,14 @@ drive, or only store a subset of the _opts structs in drives */
 			if (d->currtrack >
 			    d->toc->session[d->currsession].lasttrack) {
 				d->currsession++;
-				burn_print(12, "session switch to %d\n",
-					   d->currsession);
-				burn_print(12, "skipping a lead out\n");
+				/* session switch to d->currsession */
+				/* skipping a lead out */
 				drive_lba = CURRENT_SESSION_START(d);
-				burn_print(12, "new lba %d\n", drive_lba);
 /* XXX more of the same
 				end = burn_track_end(d, d->currsession,
 							d->currtrack);
-*/ }
-			burn_print(12, "track switch to %d\n", d->currtrack);
+*/
+			}
 		}
 
 		page.sectors = 0;
@@ -180,23 +197,21 @@ static int bitcount(unsigned char *data, int n)
 	return count;
 }
 
+
 void burn_packet_process(struct burn_drive *d, unsigned char *data,
 			 const struct burn_read_opts *o)
 {
 	unsigned char sub[96];
-	unsigned short crc;
 	int ptr = 2352, i, j, code, fb;
 	int audio = 1;
+#ifndef Libburn_no_crc_C
+	unsigned short crc;
+#endif
 
 	if (o->c2errors) {
 		fb = bitcount(data + ptr, 294);
 		if (fb) {
-			burn_print(1, "%d damaged bits\n",
-				   bitcount(data + ptr, 294));
-			burn_print(1, "sending error on %s %s\n",
-				   d->idata->vendor, d->idata->product);
-			/* XXX send a burn_message! burn_message_error(d,
-			   something); */
+			/* bitcount(data + ptr, 294) damaged bits */;
 		}
 		ptr += 294;
 	}
@@ -232,15 +247,20 @@ void burn_packet_process(struct burn_drive *d, unsigned char *data,
 				}
 			}
 		}
+
+#ifndef Libburn_no_crc_C
 		crc = (*(sub + 22) << 8) + *(sub + 23);
 		if (crc != crc_ccitt(sub + 12, 10)) {
+/*
 			burn_print(1, "sending error on %s %s\n",
 				   d->idata->vendor, d->idata->product);
-/*			e = burn_error();
+			e = burn_error();
 			e->drive = d;
-*/
 			burn_print(1, "crc mismatch in Q\n");
+*/;
 		}
+#endif
+
 		/* else process_q(d, sub + 12); */
 		/* 
 		   if (o->subfd != -1) write(o->subfd, sub, 96); */
@@ -261,8 +281,12 @@ void burn_packet_process(struct burn_drive *d, unsigned char *data,
 /*  so yeah, when you uncomment these, make them write zeros insted of crap
 static void write_empty_sector(int fd)
 {
-	char sec[2352];
+	static char sec[2352], initialized = 0;
 
+	if (!initialized) {
+		memset(sec, 0, 2352);
+		initialized = 1;
+	}
 	burn_print(1, "writing an 'empty' sector\n");
 	write(fd, sec, 2352);
 }
@@ -280,3 +304,227 @@ static void flipq(unsigned char *sub)
 	*(sub + 12 + 11) = ~*(sub + 12 + 11);
 }
 */
+
+
+/* ts A70904 */
+/** @param flag bit0=be silent on data shortage */
+int burn_stdio_read(int fd, char *buf, int bufsize, struct burn_drive *d,
+			int flag)
+{
+	int todo, count = 0;
+
+	for(todo = bufsize; todo > 0; ) {
+		count = read(fd, buf + (bufsize - todo), todo);
+		if(count <= 0)
+	break;
+		todo -= count;
+	}
+	if(todo > 0 && !(flag & 1)) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x0002014a,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			"Cannot read desired amount of data", errno, 0);
+	}
+	if (count < 0)
+		return -1;
+	return (bufsize - todo);
+}
+
+
+/* ts A70812 : API function */
+int burn_read_data(struct burn_drive *d, off_t byte_address,
+                   char data[], off_t data_size, off_t *data_count, int flag)
+{
+	int alignment = 2048, start, upto, chunksize = 1, err, cpy_size, i;
+	int sose_mem = 0, fd = -1, ret;
+	char msg[81], *wpt;
+	struct buffer *buf = NULL, *buffer_mem = d->buffer;
+
+/*
+#define Libburn_read_data_adr_logginG 1
+*/
+#ifdef Libburn_read_data_adr_logginG
+	static FILE *log_fp= NULL;
+
+	if(log_fp == NULL)
+		log_fp = fopen("/tmp/burn_read_data_log", "a");
+	if(log_fp!=NULL)
+		fprintf(log_fp, "%d\n", (int) (byte_address / 2048));
+#endif /* Libburn_read_data_logginG */
+
+	BURN_ALLOC_MEM(buf, struct buffer, 1);
+	*data_count = 0;
+	sose_mem = d->silent_on_scsi_error;
+
+	if (d->released) {
+		libdax_msgs_submit(libdax_messenger,
+			d->global_index, 0x00020142,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+			"Drive is not grabbed on random access read", 0, 0);
+		{ret = 0; goto ex;}
+	}
+	if (d->drive_role == 0) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020146,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+			"Drive is a virtual placeholder (null-drive)", 0, 0);
+		{ret = 0; goto ex;}
+	} else if (d->drive_role == 3) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020151,
+			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+			"Read attempt on write-only drive", 0, 0);
+		{ret = 0; goto ex;}
+	}
+	if ((byte_address % alignment) != 0) {
+		sprintf(msg,
+			"Read start address not properly aligned (%d bytes)",
+			alignment);
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020143,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			msg, 0, 0);
+		{ret = 0; goto ex;}
+	}
+	if (d->media_read_capacity != 0x7fffffff && byte_address >=
+		((off_t) d->media_read_capacity + (off_t) 1) * (off_t) 2048) {
+		if (!(flag & 2)) {
+			sprintf(msg,
+			  "Read start address %ds larger than number of readable blocks %d",
+			  (int) (byte_address / 2048 + !!(byte_address % 2048)),
+			  d->media_read_capacity);
+			libdax_msgs_submit(libdax_messenger, d->global_index,
+				0x00020172,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				msg, 0, 0);
+		}
+		{ret = 0; goto ex;}
+	}
+
+	if (d->busy != BURN_DRIVE_IDLE) {
+		libdax_msgs_submit(libdax_messenger,
+			d->global_index, 0x00020145,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+			"Drive is busy on attempt to read data", 0, 0);
+		{ret = 0; goto ex;}
+	}
+
+	if (d->drive_role != 1) {
+
+/* <<< We need _LARGEFILE64_SOURCE defined by the build system.
+*/
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0
+#endif
+
+		fd = d->stdio_fd;
+		if (fd < 0)
+			d->stdio_fd = fd =
+				open(d->devname, O_RDONLY | O_LARGEFILE);
+		if (fd == -1) {
+			if (errno == EACCES && (flag & 2)) {
+				if (!(flag & 8))
+					libdax_msgs_submit(libdax_messenger,
+					  d->global_index, 0x00020183,
+					  LIBDAX_MSGS_SEV_WARNING,
+					  LIBDAX_MSGS_PRIO_HIGH,
+			  "Failed to open device (a pseudo-drive) for reading",
+					  errno, 0);
+			} else if (errno!= ENOENT || !(flag & 2))
+				libdax_msgs_submit(libdax_messenger,
+				  d->global_index, 0x00020005,
+				  LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			  "Failed to open device (a pseudo-drive) for reading",
+				   errno, 0);
+			ret = 0;
+			if (errno == EACCES && (flag & 8))
+				ret= -2;
+			goto ex;
+		}
+		if (lseek(fd, byte_address, SEEK_SET) == -1) {
+			if (!(flag & 2)) {
+				sprintf(msg, "Cannot address start byte %.f",
+					(double) byte_address);
+				libdax_msgs_submit(libdax_messenger,
+				  d->global_index,
+				  0x00020147,
+				  LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				  msg, errno, 0);
+			}
+			ret = 0; goto ex;
+		}
+	}
+
+	d->busy = BURN_DRIVE_READING_SYNC;
+	d->buffer = buf;
+
+	start = byte_address / 2048;
+	upto = start + data_size / 2048;
+	if (data_size % 2048)
+		upto++;
+	wpt = data;
+	for (; start < upto; start += chunksize) {
+		chunksize = upto - start;
+		if (chunksize > 16) {
+			chunksize = 16;
+			cpy_size = 16 * 2048;
+		} else
+			cpy_size = data_size - *data_count;
+		if (flag & 2)
+			d->silent_on_scsi_error = 1;
+		if (d->drive_role == 1) {
+			err = d->read_10(d, start, chunksize, d->buffer);
+		} else {
+			ret = burn_stdio_read(fd, (char *) d->buffer->data,
+						 cpy_size, d, !!(flag & 2));
+			err = 0;
+			if (ret <= 0)
+				err = BE_CANCELLED;
+		}
+		if (flag & 2) 
+			d->silent_on_scsi_error = sose_mem;
+		if (err == BE_CANCELLED) {
+			/* Try to read a smaller part of the chunk */
+			if(!(flag & 4))
+			  for (i = 0; i < chunksize - 1; i++) {
+				if (flag & 2)
+					d->silent_on_scsi_error = 1;
+				if (d->drive_role == 1) {
+					err = d->read_10(d, start + i, 1,
+							 d->buffer);
+				} else {
+					ret = burn_stdio_read(fd,
+						(char *) d->buffer->data,
+						2048, d, 1);
+					if (ret <= 0)
+						err = BE_CANCELLED;
+				}
+				if (flag & 2) 
+					d->silent_on_scsi_error = sose_mem;
+				if (err == BE_CANCELLED)
+			break;
+				memcpy(wpt, d->buffer->data, 2048);
+				wpt += 2048;
+				*data_count += 2048;
+			}
+			if (!(flag & 2))
+				libdax_msgs_submit(libdax_messenger,
+				  d->global_index,
+				  0x00020000,
+				  LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+				  "burn_read_data() returns 0",
+				  0, 0);
+			ret = 0; goto ex;
+		}
+		memcpy(wpt, d->buffer->data, cpy_size);
+		wpt += cpy_size;
+		*data_count += cpy_size;
+	}
+
+	ret = 1;
+ex:;
+	BURN_FREE_MEM(buf);
+	d->buffer = buffer_mem;
+	d->busy = BURN_DRIVE_IDLE;
+	return ret;
+}

libburn/sbc.c

@@ -2,6 +2,15 @@
 
 /* scsi block commands */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <string.h>
 #include <unistd.h>
 
@@ -10,52 +19,155 @@
 #include "spc.h"
 #include "options.h"
 
-/* spc command set */
-static char SBC_LOAD[] = { 0x1b, 0, 0, 0, 3, 0 };
-static char SBC_UNLOAD[] = { 0x1b, 0, 0, 0, 2, 0 };
-static char SBC_START_UNIT[] = { 0x1b, 0, 0, 0, 1, 0 };
+
+/* ts A70910
+   debug: for tracing calls which might use open drive fds
+          or for catching SCSI usage of emulated drives. */
+int mmc_function_spy(struct burn_drive *d, char * text);
+
+
+/* START STOP UNIT as of SBC-1 and SBC-2
+   0:  Opcode 0x1B
+   1:  bit0= Immed
+       bit1-7= reserved 
+   2:  reserved
+   3:  reserved
+   4:  bit0= Start (else Stop unit)
+       bit1= Load/Eject (according to Start resp. Stop)
+       bit2-3= reserved
+       bit4-7= Power Condition
+               0= Start Valid: process Start and Load/Eject bits
+               1= assume Active state
+               2= assume Idle state
+               3= assume Stanby state
+              (5= SBC-1 only: assume Sleep state)
+               7= transfer control of power conditions to logical unit
+              10= force idle condition timer to 0
+              11= force standby condition timer to 0
+              All others are reserved.
+   5:  Control (set to 0)
+*/
+static unsigned char SBC_LOAD[] = { 0x1b, 0, 0, 0, 3, 0 };
+static unsigned char SBC_UNLOAD[] = { 0x1b, 0, 0, 0, 2, 0 };
+static unsigned char SBC_START_UNIT[] = { 0x1b, 0, 0, 0, 1, 0 };
+static unsigned char SBC_STOP_UNIT[] = { 0x1b, 0, 0, 0, 0, 0 };
 
 void sbc_load(struct burn_drive *d)
 {
-	struct command c;
+	struct command *c;
 
-	memcpy(c.opcode, SBC_LOAD, sizeof(SBC_LOAD));
-	c.retry = 1;
-	c.oplen = sizeof(SBC_LOAD);
-	c.dir = NO_TRANSFER;
-	c.page = NULL;
-	d->issue_command(d, &c);
-	spc_wait_unit_attention(d, 60);
+	c = &(d->casual_command);
+	if (mmc_function_spy(d, "load") <= 0)
+		return;
+
+	scsi_init_command(c, SBC_LOAD, sizeof(SBC_LOAD));
+	c->retry = 1;
+
+	/* ts A70921 : Had to revoke Immed because of LG GSA-4082B */
+	/* c->opcode[1] |= 1; / * ts A70918 : Immed */
+
+	c->dir = NO_TRANSFER;
+	d->issue_command(d, c);
+	if (c->error)
+		return;
+	/* ts A70923 : Needed regardless of Immed bit. Was once 1 minute, now
+           5 minutes for loading. If this does not suffice then other commands
+	   shall fail righteously. */
+	spc_wait_unit_attention(d, 300, "waiting after START UNIT (+ LOAD)",0);
 }
 
 void sbc_eject(struct burn_drive *d)
 {
-	struct command c;
+	struct command *c;
 
-	c.page = NULL;
-	memcpy(c.opcode, SBC_UNLOAD, sizeof(SBC_UNLOAD));
-	c.oplen = 1;
-	c.oplen = sizeof(SBC_UNLOAD);
-	c.page = NULL;
-	c.dir = NO_TRANSFER;
-	d->issue_command(d, &c);
+	c = &(d->casual_command);
+	if (mmc_function_spy(d, "eject") <= 0)
+		return;
+
+	scsi_init_command(c, SBC_UNLOAD, sizeof(SBC_UNLOAD));
+	/* c->opcode[1] |= 1; / * ts A70918 : Immed , ts B00109 : revoked */
+	c->page = NULL;
+	c->dir = NO_TRANSFER;
+	d->issue_command(d, c);
+	/* ts A70918 : Wait long. A late eject could surprise or hurt user.
+	   ts B00109 : Asynchronous eject revoked, as one cannot reliably
+	               distinguish out from unready.
+	if (c->error)
+		return;
+	spc_wait_unit_attention(d, 1800, "STOP UNIT (+ EJECT)", 0);
+	*/
 }
 
-/* ts A61118 : is it necessary to tell the drive to get ready for use ? */
+
+/* ts A91112 : Now with flag */
+/* @param flag bit0= asynchronous waiting
+*/
+int sbc_start_unit_flag(struct burn_drive *d, int flag)
+{
+	struct command *c;
+	int ret;
+
+	c = &(d->casual_command);
+	if (mmc_function_spy(d, "start_unit") <= 0)
+		return 0;
+
+	scsi_init_command(c, SBC_START_UNIT, sizeof(SBC_START_UNIT));
+	c->retry = 1;
+	c->opcode[1] |= (flag & 1); /* ts A70918 : Immed */
+	c->dir = NO_TRANSFER;
+	d->issue_command(d, c);
+	if (c->error)
+		return 0;
+	if (!(flag & 1))
+		return 1;
+	/* ts A70918 : asynchronous */
+	ret = spc_wait_unit_attention(d, 1800, "START UNIT", 0);
+	return ret;
+}
+
+
 int sbc_start_unit(struct burn_drive *d)
 {
-	struct command c;
+	int ret;
 
-	memcpy(c.opcode, SBC_START_UNIT, sizeof(SBC_START_UNIT));
-	c.retry = 1;
-	c.oplen = sizeof(SBC_START_UNIT);
-	c.dir = NO_TRANSFER;
-	c.page = NULL;
-	d->issue_command(d, &c);
-	return (c.error==0);
+	d->is_stopped = 0; /* no endless starting attempts */
+
+	/* Asynchronous, not to block controller by waiting */
+	ret = sbc_start_unit_flag(d, 1);
+	if (ret <= 0)
+		return ret;
+	/* Synchronous to catch Pioneer DVR-216D which is ready too early.
+	   A pending START UNIT can prevent ejecting of the tray.
+	*/
+	ret = sbc_start_unit_flag(d, 0);
+	return ret;
 }
 
 
+/* ts A90824 : Trying to reduce drive noise */
+int sbc_stop_unit(struct burn_drive *d)
+{
+	struct command *c;
+	int ret;
+
+	c = &(d->casual_command);
+	if (mmc_function_spy(d, "stop_unit") <= 0)
+		return 0;
+
+	scsi_init_command(c, SBC_STOP_UNIT, sizeof(SBC_STOP_UNIT));
+	c->retry = 0;
+	c->opcode[1] |= 1; /* Immed */
+	c->dir = NO_TRANSFER;
+	d->issue_command(d, c);
+	if (c->error)
+		return 0;
+	ret = spc_wait_unit_attention(d, 1800, "STOP UNIT", 0);
+	d->is_stopped = 1;
+	return ret;
+}
+
+
+
 /* ts A61021 : the sbc specific part of sg.c:enumerate_common()
 */
 int sbc_setup_drive(struct burn_drive *d)
@@ -63,6 +175,8 @@ int sbc_setup_drive(struct burn_drive *d)
 	d->eject = sbc_eject;
 	d->load = sbc_load;
 	d->start_unit = sbc_start_unit;
+	d->stop_unit = sbc_stop_unit;
+	d->is_stopped = 0;
 	return 1;
 }
 

libburn/sbc.h

@@ -1,5 +1,11 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
 #ifndef __SBC
 #define __SBC
 

libburn/sector.c

@@ -1,5 +1,14 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <stdio.h>
 
 /* ts A61010 */
@@ -15,13 +24,17 @@
 #include "sector.h"
 #include "crc.h"
 #include "debug.h"
-#include "lec.h"
 #include "toc.h"
 #include "write.h"
 
+#include "libdax_msgs.h"
+extern struct libdax_msgs *libdax_messenger;
+
+#include "ecma130ab.h"
+
 
 #ifdef Libburn_log_in_and_out_streaM
-/* <<< ts A61031 */
+/* ts A61031 */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -92,7 +105,7 @@ static void get_bytes(struct burn_track *track, int count, unsigned char *data)
 	int valid, shortage, curr, i, tr;
 
 #ifdef Libburn_log_in_and_out_streaM 
-        /* <<< ts A61031 */
+        /* ts A61031 */
         static int tee_fd= -1;
         if(tee_fd==-1)
                 tee_fd= open("/tmp/libburn_sg_readin",
@@ -123,7 +136,12 @@ static void get_bytes(struct burn_track *track, int count, unsigned char *data)
 /* Next we use source data */
 	curr = valid;
 	if (!track->eos) {
-		valid = track->source->read(track->source, data + curr, count - curr);
+		if (track->source->read != NULL)
+			valid = track->source->read(track->source,
+						data + curr, count - curr);
+		else
+			valid = track->source->read_xt(track->source,
+						data + curr, count - curr);
 	} else valid = 0;
 
 	if (valid <= 0) { /* ts A61031 : extended from (valid == -1) */
@@ -133,7 +151,7 @@ static void get_bytes(struct burn_track *track, int count, unsigned char *data)
 	track->sourcecount += valid;
 
 #ifdef Libburn_log_in_and_out_streaM
-	/* <<< ts A61031 */
+	/* ts A61031 */
         if(tee_fd!=-1 && valid>0) {
                 write(tee_fd, data + curr, valid);
         }
@@ -161,10 +179,22 @@ static void get_bytes(struct burn_track *track, int count, unsigned char *data)
 	if (!shortage)
 		goto ex;
 
-	/* ts A61031 */
+	/* ts A61031 - B10103 */
 	if (shortage >= count)
 		track->track_data_done = 1;
-	if (track->open_ended)
+	if (track->end_on_premature_eoi && shortage >= count &&
+	    !track->open_ended) {
+		char msg[80];
+		/* Memorize that premature end of input happened */
+		sprintf(msg,
+		    "Premature end of input encountered. Missing: %d bytes",
+		    shortage);
+		libdax_msgs_submit(libdax_messenger, -1, 0x00020180,
+				LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+				msg, 0,0);
+		track->end_on_premature_eoi = 2;
+	}
+	if (track->open_ended || track->end_on_premature_eoi)
 		goto ex;
 
 /* If we're still short, and there's a "next" pointer, we pull from that.
@@ -201,8 +231,7 @@ static unsigned char *get_sector(struct burn_write_opts *opts,
 {
 	struct burn_drive *d = opts->drive;
 	struct buffer *out = d->buffer;
-	int outmode;
-	int seclen;
+	int outmode, seclen;
 	unsigned char *ret;
 
 	outmode = get_outmode(opts);
@@ -218,7 +247,9 @@ static unsigned char *get_sector(struct burn_write_opts *opts,
 	seclen += burn_subcode_length(outmode);
 
 	/* ts A61219 : opts->obs is eventually a 32k trigger for DVD */
-	if (out->bytes + (seclen) > BUFFER_SIZE || out->bytes == opts->obs) {
+	/* (there is enough buffer size reserve for track->cdxa_conversion) */
+	if (out->bytes + seclen > BUFFER_SIZE ||
+	    (opts->obs > 0 && out->bytes + seclen > opts->obs)) {
 		int err;
 		err = d->write(d, d->nwa, out);
 		if (err == BE_CANCELLED)
@@ -236,7 +267,6 @@ static unsigned char *get_sector(struct burn_write_opts *opts,
 		out->bytes = 0;
 		out->sectors = 0;
 	}
-
 	ret = out->data + out->bytes;
 	out->bytes += seclen;
 	out->sectors++;
@@ -293,7 +323,17 @@ static int convert_data(struct burn_write_opts *o, struct burn_track *track,
 		return 0;
 
 	if ((outmode & BURN_MODE_BITS) == (inmode & BURN_MODE_BITS)) {
+		/* see MMC-5 4.2.3.8.5.3 Block Format for Mode 2 form 1 Data
+		            Table 24  Mode 2 Formed Sector Sub-header Format */
+		if (track != NULL)
+			if (track->cdxa_conversion == 1)
+				inlen += 8;
+
 		get_bytes(track, inlen, data);
+
+		if (track != NULL)
+			if (track->cdxa_conversion == 1)
+				memmove(data, data + 8, inlen - 8);
 		return 1;
 	}
 
@@ -386,7 +426,13 @@ a2 - lout ctrl
 	q[7] = dec_to_bcd(d->toc_entry[track].pmin);
 	q[8] = dec_to_bcd(d->toc_entry[track].psec);
 	q[9] = dec_to_bcd(d->toc_entry[track].pframe);
+
+#ifdef Libburn_no_crc_C
+	crc = 0; /* dummy */
+#else
 	crc = crc_ccitt(q, 10);
+#endif
+
 	q[10] = crc >> 8;
 	q[11] = crc & 0xFF;
 	d->toc_temp++;
@@ -407,7 +453,8 @@ int sector_toc(struct burn_write_opts *o, int mode)
 		return 0;
 	subcode_toc(d, mode, subs);
 	convert_subs(o, mode, subs, data);
-	sector_headers(o, data, mode, 1);
+	if (sector_headers(o, data, mode, 1) <= 0)
+		return 0;
 	sector_common(++)
 	return 1;
 }
@@ -427,7 +474,8 @@ int sector_pregap(struct burn_write_opts *o,
 		return 0;
 	subcode_user(o, subs, tno, control, 0, NULL, 1);
 	convert_subs(o, mode, subs, data);
-	sector_headers(o, data, mode, 0);
+	if (sector_headers(o, data, mode, 0) <= 0)
+		return 0;
 	sector_common(--)
 	return 1;
 }
@@ -444,11 +492,12 @@ int sector_postgap(struct burn_write_opts *o,
 		return 0;
 	/* ts A61010 */
 	if (convert_data(o, NULL, mode, data) <= 0)
-		return 0;;
+		return 0;
 /* use last index in track */
 	subcode_user(o, subs, tno, control, 1, NULL, 1);
 	convert_subs(o, mode, subs, data);
-	sector_headers(o, data, mode, 0);
+	if (sector_headers(o, data, mode, 0) <= 0)
+		return 0;
 	sector_common(++)
 	return 1;
 }
@@ -480,7 +529,13 @@ static void subcode_lout(struct burn_write_opts *o, unsigned char control,
 	q[7] = dec_to_bcd(min);
 	q[8] = dec_to_bcd(sec);
 	q[9] = dec_to_bcd(frame);
+
+#ifdef Libburn_no_crc_C
+	crc = 0; /* dummy */
+#else
 	crc = crc_ccitt(q, 10);
+#endif
+
 	q[10] = crc >> 8;
 	q[11] = crc & 0xFF;
 }
@@ -600,7 +655,13 @@ void subcode_user(struct burn_write_opts *o, unsigned char *subcodes,
 	}
 	q[0] = (control << 4) + qmode;
 
+
+#ifdef Libburn_no_crc_C
+	crc = 0; /* dummy */
+#else
 	crc = crc_ccitt(q, 10);
+#endif
+
 	q[10] = crc >> 8;
 	q[11] = crc & 0xff;
 }
@@ -619,7 +680,8 @@ int sector_lout(struct burn_write_opts *o, unsigned char control, int mode)
 		return 0;
 	subcode_lout(o, control, subs);
 	convert_subs(o, mode, subs, data);
-	sector_headers(o, data, mode, 0);
+	if (sector_headers(o, data, mode, 0) <= 0)
+		return 0;
 	sector_common(++)
 	return 1;
 }
@@ -631,14 +693,14 @@ int sector_data(struct burn_write_opts *o, struct burn_track *t, int psub)
 	unsigned char *data;
 
 	data = get_sector(o, t, t->mode);
-	if (!data)
+	if (data == NULL)
 		return 0;
 	/* ts A61010 */
 	if (convert_data(o, t, t->mode, data) <= 0)
 		return 0;
 
 	/* ts A61031 */
-	if (t->open_ended && t->track_data_done) {
+	if ((t->open_ended || t->end_on_premature_eoi) && t->track_data_done) {
 		unget_sector(o, t->mode);
 		return 2;
 	}
@@ -654,7 +716,8 @@ int sector_data(struct burn_write_opts *o, struct burn_track *t, int psub)
 			     t->entry->control, 1, &t->isrc, psub);
 	convert_subs(o, t->mode, subs, data);
 
-	sector_headers(o, data, t->mode, 0);
+	if (sector_headers(o, data, t->mode, 0) <= 0)
+		return 0;
 	sector_common(++)
 	return 1;
 }
@@ -705,42 +768,27 @@ int sector_headers_is_ok(struct burn_write_opts *o, int mode)
 	return 0;
 }
 
-void sector_headers(struct burn_write_opts *o, unsigned char *out,
+/* ts A90830 : changed return type to int
+   @return 0= failure
+           1= success
+*/
+int sector_headers(struct burn_write_opts *o, unsigned char *out,
 		    int mode, int leadin)
 {
+
+#ifdef Libburn_ecma130ab_includeD
+
 	struct burn_drive *d = o->drive;
 	unsigned int crc;
 	int min, sec, frame;
 	int modebyte = -1;
-
-	/* ts A61009 */
-#if 1
 	int ret;
 
 	ret = sector_headers_is_ok(o, mode);
 	if (ret != 2)
-		return;
+		return !!ret;
 	modebyte = 1;
 
-#else
-
-	if (mode & BURN_AUDIO)	/* no headers for "audio" */
-		return;
-	if (o->write_type == BURN_WRITE_SAO)
-		return;
-
-	/* ts A61031 */
-	if (o->write_type == BURN_WRITE_TAO)
-		return;
-
-	if (mode & BURN_MODE1)
-		modebyte = 1;
-
-#endif
-
-	/* ts A61009 : now ensured by burn_disc_write_is_ok() */
-	/* a ssert(modebyte == 1); */
-
 	out[0] = 0;
 	memset(out + 1, 0xFF, 10);	/* sync */
 	out[11] = 0;
@@ -759,7 +807,13 @@ void sector_headers(struct burn_write_opts *o, unsigned char *out,
 		out[15] = modebyte;
 	}
 	if (mode & BURN_MODE1) {
+
+#ifdef Libburn_no_crc_C
+		crc = 0; /* dummy */
+#else
 		crc = crc_32(out, 2064);
+#endif
+
 		out[2064] = crc & 0xFF;
 		crc >>= 8;
 		out[2065] = crc & 0xFF;
@@ -770,10 +824,33 @@ void sector_headers(struct burn_write_opts *o, unsigned char *out,
 	}
 	if (mode & BURN_MODE1) {
 		memset(out + 2068, 0, 8);
-		parity_p(out);
-		parity_q(out);
+		burn_rspc_parity_p(out);
+		burn_rspc_parity_q(out);
 	}
-	scramble(out);
+	burn_ecma130_scramble(out);
+	return 1;
+
+#else /* Libburn_ecma130ab_includeD */
+
+	int ret;
+
+	ret = sector_headers_is_ok(o, mode);
+	if (ret != 2)
+		return (!! ret);
+
+	/* ts A90830 : lec.c is copied from cdrdao.
+	   I have no idea yet how lec.c implements the Reed-Solomon encoding
+	   which is described in ECMA-130 for CD-ROM.
+	   So this got removed for now.
+	*/
+	libdax_msgs_submit(libdax_messenger, o->drive->global_index,
+				0x0002010a,
+				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+				"Raw CD write modes are not supported", 0, 0);
+	return 0;
+
+#endif /* ! Libburn_ecma130ab_includeD */
+
 }
 
 #if 0
@@ -829,12 +906,14 @@ void process_q(struct burn_drive *d, unsigned char *q)
 */
 int sector_identify(unsigned char *data)
 {
-	scramble(data);
+
 /*
+	burn_ecma130_scramble(data);
 check mode byte for 1 or 2
 test parity to see if it's a valid sector
 if invalid, return BURN_MODE_AUDIO;
 else return mode byte  (what about mode 2 formless?  heh)
 */
+
 	return BURN_MODE1;
 }

libburn/sector.h

@@ -1,5 +1,10 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
 #ifndef __SECTOR
 #define __SECTOR
 
@@ -22,7 +27,7 @@ int sector_data(struct burn_write_opts *, struct burn_track *t, int psub);
 /* ts A61009 */
 int sector_headers_is_ok(struct burn_write_opts *o, int mode);
 
-void sector_headers(struct burn_write_opts *, unsigned char *,
+int sector_headers(struct burn_write_opts *, unsigned char *,
 		    int mode, int leadin);
 void subcode_user(struct burn_write_opts *, unsigned char *s,
 		  unsigned char tno, unsigned char control,

libburn/sg-dummy.c

@@ -0,0 +1,354 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+/* 
+   Copyright (c) 2009 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+
+/*
+
+This is the main operating system dependent SCSI part of libburn. It implements
+the transport level aspects of SCSI control and command i/o.
+
+Present implementation: default dummy which enables libburn only to work
+                        with stdio: pseudo drive addresses.
+                        For real implementations see sg-linux.c, sg-freebsd.c,
+                        sg-libcdio.c
+*/
+
+
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef Libburn_os_has_statvfS
+#include <sys/statvfs.h>
+#endif /* Libburn_os_has_stavtfS */
+
+#include "transport.h"
+#include "drive.h"
+#include "sg.h"
+#include "spc.h"
+#include "mmc.h"
+#include "sbc.h"
+#include "debug.h"
+#include "toc.h"
+#include "util.h"
+#include "init.h"
+
+#include "libdax_msgs.h"
+extern struct libdax_msgs *libdax_messenger;
+
+
+/** Returns the id string  of the SCSI transport adapter and eventually
+    needed operating system facilities.
+    This call is usable even if sg_initialize() was not called yet. In that
+    case a preliminary constant message might be issued if detailed info is
+    not available yet.
+    @param msg   returns id string
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_id_string(char msg[1024], int flag)
+{
+	strcpy(msg, "internal X/Open adapter sg-dummy");
+	return 1;
+}
+
+
+/** Performs global initialization of the SCSI transport adapter and eventually
+    needed operating system facilities. Checks for compatibility supporting
+    software components.
+    @param msg   returns ids and/or error messages of eventual helpers
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_initialize(char msg[1024], int flag)
+{
+	return sg_id_string(msg, 0);
+}
+
+
+/** Performs global finalization of the SCSI transport adapter and eventually
+    needed operating system facilities. Releases globally aquired resources.
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/  
+int sg_shutdown(int flag)
+{
+	return 1;
+}
+
+
+/** Finalizes BURN_OS_TRANSPORT_DRIVE_ELEMENTS, the components of
+    struct burn_drive which are defined in os-*.h.
+    This will be called when a burn_drive gets disposed.
+    @param d     the drive to be finalized
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_dispose_drive(struct burn_drive *d, int flag)
+{
+        return 1;
+}
+
+
+/** Returns the next index number and the next enumerated drive address.
+    The enumeration has to cover all available and accessible drives. It is
+    allowed to return addresses of drives which are not available but under
+    some (even exotic) circumstances could be available. It is on the other
+    hand allowed, only to hand out addresses which can really be used right
+    in the moment of this call. (This implementation chooses the former.)
+    @param idx An opaque handle. Make no own theories about it.
+    @param adr Takes the reply
+    @param adr_size Gives maximum size of reply including final 0
+    @param initialize  1 = start new,
+                       0 = continue, use no other values for now
+                      -1 = finish
+    @return 1 = reply is a valid address , 0 = no further address available
+           -1 = severe error (e.g. adr_size too small)
+*/
+int sg_give_next_adr(burn_drive_enumerator_t *idx,
+		     char adr[], int adr_size, int initialize)
+{
+	return 0;
+}
+
+
+/** Brings all available, not-whitelist-banned, and accessible drives into
+    libburn's list of drives.
+*/
+/* ts A61115: replacing call to sg-implementation internals from drive.c */
+int scsi_enumerate_drives(void)
+{
+	libdax_msgs_submit(libdax_messenger, -1, 0x0002016b,
+		LIBDAX_MSGS_SEV_WARNING, LIBDAX_MSGS_PRIO_HIGH,
+		"No MMC transport adapter is present. Running on sg-dummy.c.",
+		0, 0);
+	return 1;
+}
+
+
+/** Tells wether libburn has the given drive in use or exclusively reserved.
+    If it is "open" then libburn will eventually call sg_release() on it when
+    it is time to give up usage resp. reservation.
+*/
+/** Published as burn_drive.drive_is_open() */
+int sg_drive_is_open(struct burn_drive * d)
+{
+	return 0;
+}
+
+
+/** Opens the drive for SCSI commands and - if burn activities are prone
+    to external interference on your system - obtains an exclusive access lock
+    on the drive. (Note: this is not physical tray locking.)
+    A drive that has been opened with sg_grab() will eventually be handed
+    over to sg_release() for closing and unreserving.
+*/
+int sg_grab(struct burn_drive *d)
+{
+	libdax_msgs_submit(libdax_messenger, d->global_index, 0x0002016a,
+		LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+		"No MMC transport adapter is present. Running on sg-dummy.c.",
+		0, 0);
+	return 0;
+}
+
+
+/** Gives up the drive for SCSI commands and releases eventual access locks.
+    (Note: this is not physical tray locking.)
+*/
+int sg_release(struct burn_drive *d)
+{
+	return 0;
+}
+
+
+/** Sends a SCSI command to the drive, receives reply and evaluates wether
+    the command succeeded or shall be retried or finally failed.
+    Returned SCSI errors shall not lead to a return value indicating failure.
+    The callers get notified by c->error. An SCSI failure which leads not to
+    a retry shall be notified via scsi_notify_error().
+    The Libburn_log_sg_commandS facility might be of help when problems with
+    a drive have to be examined. It shall stay disabled for normal use.
+    @return: 1 success , <=0 failure
+*/
+int sg_issue_command(struct burn_drive *d, struct command *c)
+{
+	libdax_msgs_submit(libdax_messenger, d->global_index, 0x0002016a,
+		LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+		"No MMC transport adapter is present. Running on sg-dummy.c.",
+		0, 0);
+	return -1;
+}
+
+
+/** Tries to obtain SCSI address parameters.
+    @return  1 is success , 0 is failure
+*/
+int sg_obtain_scsi_adr(char *path, int *bus_no, int *host_no, int *channel_no,
+                       int *target_no, int *lun_no)
+{
+        libdax_msgs_submit(libdax_messenger, -1, 0x0002016c,
+                LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+                "No MMC transport adapter is present. Running on sg-dummy.c.",
+                0, 0);
+	return 0;
+}
+
+
+/** Tells wether a text is a persistent address as listed by the enumeration
+    functions.
+*/
+int sg_is_enumerable_adr(char *adr)
+{
+	return(0);
+}
+
+
+/* Return 1 if the given path leads to a regular file or a device that can be
+   seeked, read, and possibly written with 2 kB granularity. 
+*/
+int burn_os_is_2k_seekrw(char *path, int flag)
+{
+	struct stat stbuf;
+
+	if (stat(path, &stbuf) == -1)
+		return 0;
+	if (S_ISREG(stbuf.st_mode))
+		return 1;
+	if (S_ISBLK(stbuf.st_mode))
+		return 1;
+	return 0;
+}
+
+
+/** Estimate the potential payload capacity of a file address.
+    @param path  The address of the file to be examined. If it does not
+                 exist yet, then the directory will be inquired.
+    @param bytes The pointed value gets modified, but only if an estimation is
+                 possible.
+    @return      -2 = cannot perform necessary operations on file object
+                 -1 = neither path nor dirname of path exist
+                  0 = could not estimate size capacity of file object
+                  1 = estimation has been made, bytes was set
+*/
+int burn_os_stdio_capacity(char *path, off_t *bytes)
+{
+	struct stat stbuf;
+
+#ifdef Libburn_os_has_statvfS
+	struct statvfs vfsbuf;
+#endif
+
+	char *testpath = NULL, *cpt;
+	off_t add_size = 0;
+	int ret;
+
+	BURN_ALLOC_MEM(testpath, char, 4096);
+
+	testpath[0] = 0;
+	if (stat(path, &stbuf) == -1) {
+		strcpy(testpath, path);
+		cpt = strrchr(testpath, '/');
+		if(cpt == NULL)
+			strcpy(testpath, ".");
+		else if(cpt == testpath)
+			testpath[1] = 0;
+		else
+			*cpt = 0;
+		if (stat(testpath, &stbuf) == -1)
+			{ret = -1; goto ex;}
+
+#ifdef Libburn_if_this_was_linuX
+
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		long blocks;
+
+		blocks = *bytes / 512;
+		fd = open(path, open_mode);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		ret = ioctl(fd, BLKGETSIZE, &blocks);
+		close(fd);
+		if (ret == -1)
+			{ret = -2; goto ex;}
+		*bytes = ((off_t) blocks) * (off_t) 512;
+
+#endif /* Libburn_if_this_was_linuX */
+
+	} else if(S_ISREG(stbuf.st_mode)) {
+		add_size = stbuf.st_blocks * (off_t) 512;
+		strcpy(testpath, path);
+	} else
+		{ret = 0; goto ex;}
+
+	if (testpath[0]) {	
+
+#ifdef Libburn_os_has_statvfS
+
+		if (statvfs(testpath, &vfsbuf) == -1)
+			{ret = -2; goto ex;}
+		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
+						(off_t) vfsbuf.f_bavail;
+
+#else /* Libburn_os_has_statvfS */
+
+		{ret = 0; goto ex;}
+
+#endif /* ! Libburn_os_has_stavtfS */
+
+	}
+	ret = 1;
+ex:;
+	BURN_FREE_MEM(testpath);
+	return ret;
+}
+
+
+/* ts A91122 : an interface to open(O_DIRECT) or similar OS tricks. */
+
+#ifdef Libburn_read_o_direcT
+
+	/* No special O_DIRECT-like precautions are implemented here */
+
+#endif /* Libburn_read_o_direcT */
+
+
+int burn_os_open_track_src(char *path, int open_flags, int flag)
+{
+	int fd;
+
+	fd = open(path, open_flags);
+	return fd;
+}
+
+
+void *burn_os_alloc_buffer(size_t amount, int flag)
+{
+	void *buf = NULL;
+
+	buf = calloc(1, amount);
+	return buf;
+}
+
+
+int burn_os_free_buffer(void *buffer, size_t amount, int flag)
+{
+	if (buffer == NULL)
+		return 0;
+	free(buffer);
+	return 1;
+}
+

libburn/sg-freebsd-port.c

@@ -1,5 +1,14 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/*
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
+                  /* THIS CODE IS NOT FUNCTIONAL YET !!! */
+
+
 /*
 
 This is the main operating system dependent SCSI part of libburn. It implements
@@ -29,12 +38,28 @@ and of deriving the following system specific files from existing examples:
 Said sg-*.c operations are defined by a public function interface, which has
 to be implemented in a way that provides libburn with the desired services:
  
+sg_id_string()          returns an id string of the SCSI transport adapter.
+                        It may be called before initialization but then may
+                        return only a preliminary id.
+
+sg_initialize()         performs global initialization of the SCSI transport
+                        adapter and eventually needed operating system
+                        facilities. Checks for compatibility of supporting
+                        software components.
+
+sg_shutdown()           performs global finalizations and releases golbally
+                        aquired resources.
+
 sg_give_next_adr()      iterates over the set of potentially useful drive 
                         address strings.
 
 scsi_enumerate_drives() brings all available, not-whitelist-banned, and
                         accessible drives into libburn's list of drives.
 
+sg_dispose_drive()      finalizes adapter specifics of struct burn_drive
+                        on destruction. Releases resources which were aquired
+                        underneath scsi_enumerate_drives().
+
 sg_drive_is_open()      tells wether libburn has the given drive in use.
 
 sg_grab()               opens the drive for SCSI commands and ensures
@@ -49,11 +74,34 @@ sg_issue_command()      sends a SCSI command to the drive, receives reply,
 sg_obtain_scsi_adr()    tries to obtain SCSI address parameters.
 
 
+burn_os_is_2k_seekrw()  tells whether the given path leads to a file object
+                        that can be used in 2 kB granularity by lseek(2),
+                        read(2), and possibly write(2) if not read-only.
+                        E.g. a USB stick or a hard disk.
+
+burn_os_stdio_capacity()  estimates the emulated media space of stdio-drives.
+
+burn_os_open_track_src()  opens a disk file in a way that allows best
+                        throughput with file reading and/or SCSI write command
+                        transmission.
+
+burn_os_alloc_buffer()  allocates a memory area that is suitable for file
+                        descriptors issued by burn_os_open_track_src().
+                        The buffer size may be rounded up for alignment
+                        reasons.
+
+burn_os_free_buffer()   delete a buffer obtained by burn_os_alloc_buffer().
+
+
 Porting hints are marked by the text "PORTING:".
 Send feedback to libburn-hackers@pykix.org .
 
 */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 
 /** PORTING : ------- OS dependent headers and definitions ------ */
 
@@ -74,6 +122,10 @@ Send feedback to libburn-hackers@pykix.org .
 #include <err.h> /* XXX */
 
 
+/* ts A70909 */
+#include <sys/statvfs.h>
+
+
 /** PORTING : ------ libburn portable headers and definitions ----- */
 
 #include "transport.h"
@@ -111,7 +163,7 @@ static int sg_init_enumerator(burn_drive_enumerator_t *idx)
 		return -1;
 	}
 
-	bzero(&(idx->ccb), sizeof(union ccb));
+	memset(&(idx->ccb), 0, sizeof(union ccb));
 
 	idx->ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
 	idx->ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
@@ -120,9 +172,10 @@ static int sg_init_enumerator(burn_drive_enumerator_t *idx)
 	idx->ccb.ccb_h.func_code = XPT_DEV_MATCH;
 	idx->bufsize = sizeof(struct dev_match_result) * 100;
 	idx->ccb.cdm.match_buf_len = idx->bufsize;
-	idx->ccb.cdm.matches = (struct dev_match_result *)malloc(idx->bufsize);
+	idx->ccb.cdm.matches = (struct dev_match_result *)
+						calloc(1, idx->bufsize);
 	if (idx->ccb.cdm.matches == NULL) {
-		warnx("can't malloc memory for matches");
+		warnx("cannot allocate memory for matches");
 		close(idx->fd);
 		return -1;
 	}
@@ -224,6 +277,61 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 /* ------------------------------------------------------------------------ */
 
 
+/** Returns the id string  of the SCSI transport adapter and eventually
+    needed operating system facilities.
+    This call is usable even if sg_initialize() was not called yet. In that
+    case a preliminary constant message might be issued if detailed info is
+    not available yet.
+    @param msg   returns id string
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_id_string(char msg[1024], int flag)
+{
+	strcpy(msg, "internal FreeBSD CAM adapter sg-freebsd-port");
+	return 1;
+}
+
+
+/** Performs global initialization of the SCSI transport adapter and eventually
+    needed operating system facilities. Checks for compatibility supporting
+    software components.
+    @param msg   returns ids and/or error messages of eventual helpers
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_initialize(char msg[1024], int flag)
+{
+	return sg_id_string(msg, 0);
+}
+
+
+/** Performs global finalization of the SCSI transport adapter and eventually
+    needed operating system facilities. Releases globally aquired resources.
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/  
+int sg_shutdown(int flag)
+{
+	return 1;
+}
+
+
+/** Finalizes BURN_OS_TRANSPORT_DRIVE_ELEMENTS, the components of
+    struct burn_drive which are defined in os-*.h.
+    The eventual initialization of those components was made underneath
+    scsi_enumerate_drives().
+    This will be called when a burn_drive gets disposed.
+    @param d     the drive to be finalized
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_dispose_drive(struct burn_drive *d, int flag)
+{
+        return 1;
+}
+
+
 /** Returns the next index number and the next enumerated drive address.
     The enumeration has to cover all available and accessible drives. It is
     allowed to return addresses of drives which are not available but under
@@ -293,7 +401,7 @@ try_item:; /* This spaghetti loop keeps the number of tabs small  */
 			break;
 		snprintf(buf, sizeof (buf), "/dev/%s%d",
 			 result->periph_name, result->unit_number);
-		if(adr_size <= strlen(buf)
+		if(adr_size <= strlen(buf))
 			return -1;
 		strcpy(adr, buf);
 
@@ -317,7 +425,7 @@ try_item:; /* This spaghetti loop keeps the number of tabs small  */
 int scsi_enumerate_drives(void)
 {
 	burn_drive_enumerator_t idx;
-	int initialize = 1;
+	int initialize = 1, ret;
 	char buf[64];
 
 	while(1) {
@@ -332,6 +440,7 @@ int scsi_enumerate_drives(void)
 				idx.result->target_lun);
 	}
 	sg_give_next_adr(&idx, buf, sizeof(buf), -1);
+	return 1;
 }
 
 
@@ -354,11 +463,12 @@ int sg_drive_is_open(struct burn_drive * d)
 */  
 int sg_grab(struct burn_drive *d)
 {
-	int count;
 	struct cam_device *cam;
 
-	if(d->cam != NULL)
-		return 0;
+	if(d->cam != NULL) {
+		d->released = 0;
+		return 1;
+	}
 
 	cam = cam_open_device(d->devname, O_RDWR);
 	if (cam == NULL) {
@@ -383,10 +493,8 @@ int sg_grab(struct burn_drive *d)
 */
 int sg_release(struct burn_drive *d)
 {
-	if (d->cam == NULL) {
-		burn_print(1, "release an ungrabbed drive.  die\n");
+	if (d->cam == NULL)
 		return 0;
-	}
 	sg_close_drive(d);
 	return 0;
 }
@@ -509,7 +617,7 @@ int sg_obtain_scsi_adr(char *path, int *bus_no, int *host_no, int *channel_no,
                        int *target_no, int *lun_no)
 {
 	burn_drive_enumerator_t idx;
-	int initialize = 1;
+	int initialize = 1, ret;
 	char buf[64];
 	struct periph_match_result* result;
 
@@ -518,7 +626,7 @@ int sg_obtain_scsi_adr(char *path, int *bus_no, int *host_no, int *channel_no,
 		initialize = 0;
 		if (ret <= 0)
 	break;
-		if (strcmp(adr, buf) != 0)
+		if (strcmp(path, buf) != 0)
 	continue;
 		result = &(idx->ccb.cdm.matches[i].result.periph_result);
 		*bus_no = result->path_id;
@@ -540,7 +648,7 @@ int sg_obtain_scsi_adr(char *path, int *bus_no, int *host_no, int *channel_no,
 int sg_is_enumerable_adr(char* adr)
 {
 	burn_drive_enumerator_t idx;
-	int initialize = 1;
+	int initialize = 1, ret;
 	char buf[64];
 
 	while(1) {
@@ -557,3 +665,161 @@ int sg_is_enumerable_adr(char* adr)
 	return (0);
 }
 
+
+/* ts B00115 */
+/* Return 1 if the given path leads to a regular file or a device that can be
+   seeked, written, and read with 2 kB granularity.
+*/
+int burn_os_is_2k_seekrw(char *path, int flag)
+{
+        struct stat stbuf;
+	char *spt;
+	int i, e;
+
+        if (stat(path, &stbuf) == -1)
+                return 0;
+        if (S_ISREG(stbuf.st_mode))
+                return 1;
+	if (!S_ISCHR(stbuf.st_mode))
+		return 0;
+	spt = strrchr(path, '/');
+	if (spt == NULL)
+	        spt = path;
+	else
+	        spt++;
+	e = strlen(spt);
+	for (i = strlen(spt) - 1; i > 0; i--)
+		if (spt[i] >= '0' && spt[i] <= '9')
+			e = i;
+	if (strncmp(spt, "da", e) == 0) /* SCSI disk. E.g. USB stick. */
+		return 1;
+	if (strncmp(spt, "cd", e) == 0) /* SCSI CD drive might be writeable. */
+		return 1;
+	if (strncmp(spt, "ad", e) == 0) /* IDE hard drive */
+		return 1;
+	if (strncmp(spt, "acd", e) == 0) /* IDE CD drive might be writeable */
+		return 1;
+	if (strncmp(spt, "fd", e) == 0) /* Floppy disk */
+		return 1;
+	if (strncmp(spt, "fla", e) == 0) /* Flash drive */
+		return 1;
+	return 0;
+}
+
+
+/* ts A70909 */
+/** Estimate the potential payload capacity of a file address.
+    @param path  The address of the file to be examined. If it does not
+                 exist yet, then the directory will be inquired.
+    @param bytes This value gets modified if an estimation is possible
+    @return      -2 = cannot perform necessary operations on file object
+                 -1 = neither path nor dirname of path exist
+                  0 = could not estimate size capacity of file object
+                  1 = estimation has been made, bytes was set
+*/
+int burn_os_stdio_capacity(char *path, off_t *bytes)
+{
+	struct stat stbuf;
+	struct statvfs vfsbuf;
+	char *testpath = NULL, *cpt;
+	off_t add_size = 0;
+	int fd, ret;
+
+	BURN_ALLOC_MEM(testpath, char, 4096);
+	testpath[0] = 0;
+	if (stat(path, &stbuf) == -1) {
+		strcpy(testpath, path);
+		cpt = strrchr(testpath, '/');
+		if(cpt == NULL)
+			strcpy(testpath, ".");
+		else if(cpt == testpath)
+			testpath[1] = 0;
+		else
+			*cpt = 0;
+		if (stat(testpath, &stbuf) == -1)
+			{ret = -1; goto ex;}
+
+#ifdef Libburn_if_this_was_linuX
+
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		int open_mode = O_RDWR, fd, ret;
+		long blocks;
+
+		blocks = *bytes / 512;
+		if(burn_sg_open_o_excl)
+			open_mode |= O_EXCL;
+		fd = open(path, open_mode);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		ret = ioctl(fd, BLKGETSIZE, &blocks);
+		close(fd);
+		if (ret == -1)
+			{ret = -2; goto ex;}
+		*bytes = ((off_t) blocks) * (off_t) 512;
+
+#endif /* Libburn_if_this_was_linuX */
+
+
+	} else if(S_ISCHR(stbuf.st_mode)) {
+		fd = open(path, O_RDONLY);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		ret = ioctl(fd, DIOCGMEDIASIZE, &add_size);
+		close(fd);
+		if (ret == -1)
+			{ret = -2; goto ex;}
+		*bytes = add_size;
+	} else if(S_ISREG(stbuf.st_mode)) {
+		add_size = stbuf.st_blocks * (off_t) 512;
+		strcpy(testpath, path);
+	} else
+		{ret = 0; goto ex;}
+
+	if (testpath[0]) {	
+		if (statvfs(testpath, &vfsbuf) == -1)
+			{ret = -2; goto ex;}
+		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
+						(off_t) vfsbuf.f_bavail;
+	}
+	ret = 1;
+ex:
+	BURN_FREE_MEM(testpath);
+	return ret;
+}
+
+
+/* ts A91122 : an interface to open(O_DIRECT) or similar OS tricks. */
+
+#ifdef Libburn_read_o_direcT
+
+	/* No special O_DIRECT-like precautions are implemented here */
+
+#endif /* Libburn_read_o_direcT */
+
+
+int burn_os_open_track_src(char *path, int open_flags, int flag)
+{
+	int fd;
+
+	fd = open(path, open_flags);
+	return fd;
+}
+
+
+void *burn_os_alloc_buffer(size_t amount, int flag)
+{
+	void *buf = NULL;
+
+	buf = calloc(1, amount);
+	return buf;
+}
+
+
+int burn_os_free_buffer(void *buffer, size_t amount, int flag)
+{
+	if (buffer == NULL)
+		return 0;
+	free(buffer);
+	return 1;
+}
+

libburn/sg-freebsd.c

@@ -1,6 +1,15 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-#include <assert.h>
+/* 
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later
+        and under FreeBSD license revised, i.e. without advertising clause.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <errno.h>
 #include <unistd.h>
 #include <stdio.h>
@@ -8,6 +17,7 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <sys/ioctl.h>
+#include <sys/file.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/poll.h>
@@ -17,6 +27,24 @@
 
 #include <err.h> /* XXX */
 
+/* ts A70909 */
+#include <sys/statvfs.h>
+
+/* ts B00121 */
+#include <sys/disk.h> /* DIOCGMEDIASIZE */
+
+
+/* ts B00326 : For use of CAM_PASS_ERR_RECOVER with ahci */
+#define Libburn_for_freebsd_ahcI yes
+
+/* ts B00327 : for debugging of cam_send_cdb() failures
+ # define Libburn_ahci_verbouS yes
+*/
+
+/* ts B00327 : Apply CAM_PASS_ERR_RECOVER to drives even if not ahci
+ # define libburn_ahci_style_for_alL yes
+*/
+
 
 #include "transport.h"
 #include "drive.h"
@@ -27,6 +55,7 @@
 #include "debug.h"
 #include "toc.h"
 #include "util.h"
+#include "init.h"
 
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
@@ -46,8 +75,82 @@ int burn_drive_is_banned(char *device_address);
 
 
 /* ts A60821
-   <<< debug: for tracing calls which might use open drive fds */
-int mmc_function_spy(char * text);
+   debug: for tracing calls which might use open drive fds
+          or for catching SCSI usage of emulated drives. */
+int mmc_function_spy(struct burn_drive *d, char * text);
+
+
+/* ts B00113
+   Whether to log SCSI commands:
+   bit0= log in /tmp/libburn_sg_command_log
+   bit1= log to stderr
+   bit2= flush every line
+*/
+extern int burn_sg_log_scsi;
+
+/* ts B00114 */
+/* Storage object is in libburn/init.c
+   whether to strive for exclusive access to the drive
+*/
+extern int burn_sg_open_o_excl;
+
+
+/* ts A91227 */
+/** Returns the id string  of the SCSI transport adapter and eventually
+    needed operating system facilities.
+    This call is usable even if sg_initialize() was not called yet. In that
+    case a preliminary constant message might be issued if detailed info is
+    not available yet.
+    @param msg   returns id string
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_id_string(char msg[1024], int flag)
+{
+	strcpy(msg, "internal FreeBSD CAM adapter sg-freebsd");
+	return 1;
+}
+
+
+/* ts A91227 */
+/** Performs global initialization of the SCSI transport adapter and eventually
+    needed operating system facilities. Checks for compatibility supporting
+    software components.
+    @param msg   returns ids and/or error messages of eventual helpers
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_initialize(char msg[1024], int flag)
+{
+	return sg_id_string(msg, 0);
+}
+
+
+/* ts A91227 */
+/** Performs global finalization of the SCSI transport adapter and eventually
+    needed operating system facilities. Releases globally aquired resources.
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/  
+int sg_shutdown(int flag)
+{
+	return 1;
+}
+
+
+/** Finalizes BURN_OS_TRANSPORT_DRIVE_ELEMENTS, the components of
+    struct burn_drive which are defined in os-*.h.
+    The eventual initialization of those components was made underneath
+    scsi_enumerate_drives().
+    This will be called when a burn_drive gets disposed.
+    @param d     the drive to be finalized
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_dispose_drive(struct burn_drive *d, int flag)
+{
+        return 1;
+}
 
 
 /* ts A61021 : Moved most code from scsi_enumerate_drives under
@@ -59,19 +162,21 @@ static int sg_init_enumerator(burn_drive_enumerator_t *idx_)
 	struct burn_drive_enumeration_state *idx;
 	int bufsize;
 
-	idx = malloc(sizeof(*idx));
+	idx = calloc(1, sizeof(*idx));
 	if (idx == NULL) {
-		warnx("can't malloc memory for enumerator");
+		warnx("cannot allocate memory for enumerator");
 		return -1;
 	}
 	idx->skip_device = 0;
 
 	if ((idx->fd = open(XPT_DEVICE, O_RDWR)) == -1) {
-		warn("couldn't open %s", XPT_DEVICE);
+		warn("could not open %s", XPT_DEVICE);
+		free(idx);
+		idx = NULL;
 		return -1;
 	}
 
-	bzero(&(idx->ccb), sizeof(union ccb));
+	memset(&(idx->ccb), 0, sizeof(union ccb));
 
 	idx->ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
 	idx->ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
@@ -80,9 +185,9 @@ static int sg_init_enumerator(burn_drive_enumerator_t *idx_)
 	idx->ccb.ccb_h.func_code = XPT_DEV_MATCH;
 	bufsize = sizeof(struct dev_match_result) * 100;
 	idx->ccb.cdm.match_buf_len = bufsize;
-	idx->ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
+	idx->ccb.cdm.matches = (struct dev_match_result *) calloc(1, bufsize);
 	if (idx->ccb.cdm.matches == NULL) {
-		warnx("can't malloc memory for matches");
+		warnx("cannot allocate memory for matches");
 		close(idx->fd);
 		free(idx);
 		return -1;
@@ -139,7 +244,7 @@ static int sg_next_enumeration_buffer(burn_drive_enumerator_t *idx_)
 }
 
 
-/** Returns the next index number and the next enumerated drive address.
+/** Returns the next index object state and the next enumerated drive address.
     @param idx An opaque handle. Make no own theories about it.
     @param adr Takes the reply
     @param adr_size Gives maximum size of reply including final 0
@@ -193,9 +298,15 @@ int sg_give_next_adr(burn_drive_enumerator_t *idx_,
 				struct periph_match_result* result;
 
 				result = &(idx->ccb.cdm.matches[idx->i].result.periph_result);
+/* ts B00112 : we really want only "cd" devices.
+
 				if (idx->skip_device || 
 				    strcmp(result->periph_name, "pass") == 0)
 					break;
+*/
+				if (idx->skip_device || 
+				    strcmp(result->periph_name, "cd") != 0)
+					break;
 				ret = snprintf(adr, adr_size, "/dev/%s%d",
 					 result->periph_name, result->unit_number);
 				if(ret >= adr_size)
@@ -206,7 +317,7 @@ int sg_give_next_adr(burn_drive_enumerator_t *idx_,
 
 			}
 			default:
-				/* printf(stderr, "unknown match type\n"); */
+				/* fprintf(stderr, "unknown match type\n"); */
 				break;
 			}
 			(idx->i)++;
@@ -281,6 +392,10 @@ int sg_close_drive(struct burn_drive * d)
 		cam_close_device(d->cam);
 		d->cam = NULL;
 	}
+	if (d->lock_fd > 0) {
+		close(d->lock_fd);
+		d->lock_fd = -1;
+	}
 	return 0;
 }
 
@@ -334,7 +449,10 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 	out.lun = lun_no;
 
 	out.devname = burn_strdup(fname);
+
 	out.cam = NULL;
+	out.lock_fd = -1;
+	out.is_ahci = 0;
 
 	out.start_lba= -2000000000;
 	out.end_lba= -2000000000;
@@ -371,9 +489,9 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 	out.close_session = mmc_close_session;
 	out.close_track_session = mmc_close;
 	out.read_buffer_capacity = mmc_read_buffer_capacity;
-	out.idata = malloc(sizeof(struct burn_scsi_inquiry_data));
+	out.idata = calloc(1, sizeof(struct burn_scsi_inquiry_data));
 	out.idata->valid = 0;
-	out.mdata = malloc(sizeof(struct scsi_mode_data));
+	out.mdata = calloc(1, sizeof(struct scsi_mode_data));
 	out.mdata->valid = 0;
 	if (out.idata == NULL || out.mdata == NULL) {
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020108,
@@ -386,21 +504,18 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 
 /* ts A60821
    <<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("enumerate_common : -------- doing grab");
+	mmc_function_spy(NULL, "enumerate_common : -------- doing grab");
 
 /* try to get the drive info */
 	if (t->grab(t)) {
-		burn_print(2, "getting drive info\n");
 		t->getcaps(t);
 		t->unlock(t);
 		t->released = 1;
-	} else {
-		burn_print(2, "unable to grab new located drive\n");
 	}
 
 /* ts A60821
    <<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("enumerate_common : ----- would release ");
+	mmc_function_spy(NULL, "enumerate_common : ----- would release ");
 
 }
 
@@ -426,6 +541,9 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 	/* Operating system adapter is CAM */
 	/* Adapter specific handles and data */
 	out.cam = NULL;
+	out.lock_fd = -1;
+	out.is_ahci = 0;
+
 	/* Adapter specific functions */
 	out.grab = sg_grab;
 	out.release = sg_release;
@@ -438,17 +556,152 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 
 #endif /* ! Scsi_freebsd_make_own_enumeratE */
 
-/* ts A61021: do not believe this:
-	we use the sg reference count to decide whether we can use the
-	drive or not.
-	if refcount is not one, drive is open somewhere else.
+
+/* Lock the inode associated to dev_fd and the inode associated to devname.
+   Return OS errno, number of pass device of dev_fd, locked fd to devname,
+   error message.
+   A return value of > 0 means success, <= 0 means failure.
 */
+static int freebsd_dev_lock(int dev_fd, char *devname,
+	 int *os_errno, int *pass_dev_no, int *lock_fd, char msg[4096],
+	 int flag)
+{
+	int lock_denied = 0, fd_stbuf_valid, name_stbuf_valid, i, pass_l = 100;
+	int max_retry = 3, tries = 0;
+	struct stat fd_stbuf, name_stbuf;
+	char pass_name[16], *lock_name;
+
+	*os_errno = 0;
+	*pass_dev_no = -1;
+	*lock_fd = -1;
+	msg[0] = 0;
+
+	fd_stbuf_valid = !fstat(dev_fd, &fd_stbuf);
+
+	/* Try to find name of pass device by inode number */
+	lock_name = (char *) "effective device";
+	if(fd_stbuf_valid) {
+		for (i = 0; i < pass_l; i++) {
+			sprintf(pass_name, "/dev/pass%d", i);
+			if (stat(pass_name, &name_stbuf) != -1)
+				if(fd_stbuf.st_ino == name_stbuf.st_ino &&
+			   	fd_stbuf.st_dev == name_stbuf.st_dev)	
+		break;
+		}
+		if (i < pass_l) {
+			lock_name = pass_name;
+			*pass_dev_no = i;
+		}
+	}
+
+	name_stbuf_valid = !stat(devname, &name_stbuf);
+	for (tries= 0; tries <= max_retry; tries++) {
+		lock_denied = flock(dev_fd, LOCK_EX | LOCK_NB);
+		*os_errno = errno;
+		if (lock_denied) {
+			if (errno == EAGAIN && tries < max_retry) {
+				/* <<< debugging
+				fprintf(stderr,
+				"\nlibcdio_DEBUG: EAGAIN pass, tries= %d\n",
+					tries);
+				*/
+				usleep(2000000);
+	continue;
+			}
+			sprintf(msg,
+			    "Device busy. flock(LOCK_EX) failed on %s of %s",
+			    strlen(lock_name) > 2000 || *pass_dev_no < 0 ?
+						 "pass device" : lock_name,
+			    strlen(devname) > 2000 ? "drive" : devname);
+			return 0;
+		}
+	break;
+	}
+
+	/*
+	fprintf(stderr, "libburn_DEBUG: flock obtained on %s of %s\n",
+			lock_name, devname);
+	*/
+
+	/* Eventually lock the official device node too */
+	if (fd_stbuf_valid && name_stbuf_valid &&
+		(fd_stbuf.st_ino != name_stbuf.st_ino ||
+		 fd_stbuf.st_dev != name_stbuf.st_dev)) {
+
+		*lock_fd = open(devname, O_RDONLY);
+		if (*lock_fd == 0) {
+			close(*lock_fd);
+			*lock_fd = -1;
+		} if (*lock_fd > 0) {
+			for (tries = 0; tries <= max_retry; tries++) {
+				lock_denied = 
+					flock(*lock_fd, LOCK_EX | LOCK_NB);
+				if (lock_denied) {
+					if (errno == EAGAIN &&
+							 tries < max_retry) {
+						/* <<< debugging
+						fprintf(stderr,
+				"\nlibcdio_DEBUG: EAGAIN dev, tries= %d\n",
+							tries);
+						*/
+
+						usleep(2000000);
+			continue;
+					}
+					close(*lock_fd);
+					*lock_fd = -1;
+					sprintf(msg,
+				 "Device busy. flock(LOCK_EX) failed on %s",
+				 strlen(devname) > 4000 ? "drive" : devname);
+					return 0;
+				}
+			break;
+			}
+		}
+
+/*
+		fprintf(stderr, "libburn_DEBUG: flock obtained on %s\n",
+				devname);
+*/
+
+	}
+	return 1;
+}
+
+
+static int sg_lock(struct burn_drive *d, int flag)
+{
+	int ret, os_errno, pass_dev_no = -1, flock_fd = -1;
+	char *msg = NULL;
+
+	BURN_ALLOC_MEM(msg, char, 4096);
+	ret = freebsd_dev_lock(d->cam->fd, d->devname,
+				&os_errno, &pass_dev_no, &flock_fd, msg, 0);
+	if (ret <= 0) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020008,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			msg, os_errno, 0);
+		sg_close_drive(d);
+		{ret = 0; goto ex;}
+	}
+	if (d->lock_fd > 0)
+		close(d->lock_fd);
+	d->lock_fd = flock_fd;
+	ret = 1;
+ex:;
+	BURN_FREE_MEM(msg);
+	return ret;
+}
+
+
 int sg_grab(struct burn_drive *d)
 {
-	int count;
 	struct cam_device *cam;
+	char path_string[80];
 
-	mmc_function_spy("sg_grab");
+	if (mmc_function_spy(d, "sg_grab") <= 0)
+		return 0;
 
 	if (burn_drive_is_open(d)) {
 		d->released = 0;
@@ -457,22 +710,31 @@ int sg_grab(struct burn_drive *d)
 
 	cam = cam_open_device(d->devname, O_RDWR);
 	if (cam == NULL) {
-		libdax_msgs_submit(libdax_messenger, d->global_index, 0x00020003,
-		LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
-		"Could not grab drive", 0/*os_errno*/, 0);
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+				0x00020003,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				"Could not grab drive", errno, 0);
 		return 0;
 	}
-/*	er = ioctl(fd, SG_GET_ACCESS_COUNT, &count);*/
-	count = 1;
-	if (1 == count) {
-		d->cam = cam;
-		fcntl(cam->fd, F_SETOWN, getpid());
-		d->released = 0;
-		return 1;
-	}
-	burn_print(1, "could not acquire drive - already open\n");
-	sg_close_drive(d);
-	return 0;
+	d->cam = cam;
+	if (burn_sg_open_o_excl & 63)
+		if (sg_lock(d, 0) <= 0)
+			return 0;
+	fcntl(cam->fd, F_SETOWN, getpid());
+
+	cam_path_string(d->cam, path_string, sizeof(path_string));
+
+#ifdef Libburn_ahci_verbouS
+	fprintf(stderr, "libburn_EXPERIMENTAL: CAM path = %s\n", path_string);
+#endif
+
+	if (strstr(path_string, ":ahcich") != NULL)
+		d->is_ahci = 1;
+	else
+		d->is_ahci = -1;
+
+	d->released = 0;
+	return 1;
 }
 
 
@@ -483,14 +745,13 @@ int sg_grab(struct burn_drive *d)
 
 int sg_release(struct burn_drive *d)
 {
-	mmc_function_spy("sg_release");
-
-	if (d->cam == NULL) {
-		burn_print(1, "release an ungrabbed drive.  die\n");
+	if (mmc_function_spy(d, "sg_release") <= 0)
 		return 0;
-	}
 
-	mmc_function_spy("sg_release ----------- closing.");
+	if (d->cam == NULL)
+		return 0;
+
+	mmc_function_spy(NULL, "sg_release ----------- closing.");
 
 	sg_close_drive(d);
 	d->released = 1;
@@ -499,19 +760,27 @@ int sg_release(struct burn_drive *d)
 
 int sg_issue_command(struct burn_drive *d, struct command *c)
 {
-	int done = 0;
-	int err;
+	int done = 0, err, sense_len = 0, ret, ignore_error, i;
+	int cam_pass_err_recover = 0, key, asc, ascq, timeout_ms;
 	union ccb *ccb;
+	static FILE *fp = NULL;
+	time_t start_time;
 
-	char buf[161];
-	snprintf(buf, sizeof (buf), "sg_issue_command  d->cam=%p d->released=%d",
-		(void*)d->cam, d->released);
-	mmc_function_spy(buf);
+	mmc_function_spy(NULL, "sg_issue_command");
 
 	if (d->cam == NULL) {
 		c->error = 0;
 		return 0;
 	}
+	if (burn_sg_log_scsi & 1) {
+		if (fp == NULL) {
+			fp= fopen("/tmp/libburn_sg_command_log", "a");
+			fprintf(fp,
+			    "\n-----------------------------------------\n");
+		}
+	}
+	if (burn_sg_log_scsi & 3)
+		scsi_log_cmd(c,fp,0);
 
 	c->error = 0;
 
@@ -538,6 +807,23 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 		break;
 	}
 
+#ifdef Libburn_for_freebsd_ahcI
+	/* ts B00325 : Advise by Alexander Motin */
+        /* Runs well on 8-STABLE (23 Mar 2003)
+	   But on 8-RELEASE cam_send_ccb() returns non-zero with errno 6
+           on eject. Long lasting TEST UNIT READY cycles break with
+           errno 16.
+        */
+#ifdef Libburn_ahci_style_for_alL
+	{
+#else
+	if (d->is_ahci > 0) {
+#endif
+		ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
+		cam_pass_err_recover = 1;
+	}
+#endif /* Libburn_for_freebsd_ahcI */
+
 	ccb->csio.cdb_len = c->oplen;
 	memcpy(&ccb->csio.cdb_io.cdb_bytes, &c->opcode, c->oplen);
 	
@@ -546,11 +832,20 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	if (c->page) {
 		ccb->csio.data_ptr  = c->page->data;
 		if (c->dir == FROM_DRIVE) {
-			ccb->csio.dxfer_len = BUFFER_SIZE;
+
+			/* ts A90430 : Ticket 148 , by jwehle :
+			   "On ... FreeBSD 6.4 which has a usb memory reader in
+			    addition to a ATAPI DVD burner sg_issue_command
+			    will hang while the SCSI bus is being scanned"
+			*/
+			if (c->dxfer_len >= 0)
+				ccb->csio.dxfer_len = c->dxfer_len;
+			else
+				ccb->csio.dxfer_len = BUFFER_SIZE;
+
 /* touch page so we can use valgrind */
 			memset(c->page->data, 0, BUFFER_SIZE);
 		} else {
-			assert(c->page->bytes > 0);
 			ccb->csio.dxfer_len = c->page->bytes;
 		}
 	} else {
@@ -558,43 +853,305 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 		ccb->csio.dxfer_len = 0;
 	}
 
-	do {
+	start_time = time(NULL);
+	timeout_ms = 200000;
+	for (i = 0; !done; i++) {
+		memset(c->sense, 0, sizeof(c->sense));
 		err = cam_send_ccb(d->cam, ccb);
-		if (err == -1) {
+
+		ignore_error = sense_len = 0;
+		/* ts B00325 : CAM_AUTOSNS_VALID advised by Alexander Motin */
+		if (ccb->ccb_h.status & CAM_AUTOSNS_VALID) {
+			/* ts B00110 */
+			/* Better curb sense_len */
+			sense_len = ccb->csio.sense_len;
+			if (sense_len > (int) sizeof(c->sense))
+				sense_len = sizeof(c->sense);
+			memcpy(c->sense, &ccb->csio.sense_data, sense_len);
+			spc_decode_sense(c->sense, sense_len,
+							&key, &asc, &ascq);
+			if (sense_len >= 14 && cam_pass_err_recover && key)
+				ignore_error = 1;
+		}
+
+		if (err == -1 && cam_pass_err_recover && ! ignore_error) {
+
+#ifdef Libburn_ahci_verbouS
+			fprintf(stderr, "libburn_EXPERIMENTAL: errno = %d . cam_errbuf = '%s'\n", errno, cam_errbuf);
+#endif
+
+			if (errno == ENXIO && c->opcode[0] != 0) {
+				/* Operations on empty or ejected tray */
+				/* MEDIUM NOT PRESENT */
+
+#ifdef Libburn_ahci_verbouS
+				fprintf(stderr, "libburn_EXPERIMENTAL: Emulating [2,3A,00] MEDIUM NOT PRESENT\n");
+#endif
+
+				c->sense[0] = 0x70; /*Fixed format sense data*/
+				c->sense[2] = 0x02;
+				c->sense[12] = 0x3A;
+				c->sense[13] = 0x00;
+				sense_len = 14;
+				ignore_error = 1;
+			} else if (c->opcode[0] == 0 && 
+					(errno == EBUSY || errno == ENXIO)) {
+				/* Timeout of TEST UNIT READY loop */
+				/* Inquiries while tray is being loaded */
+				/*LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE*/
+
+#ifdef Libburn_ahci_verbouS
+				fprintf(stderr, "libburn_EXPERIMENTAL: Emulating [2,04,00] LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE\n");
+#endif
+
+				c->sense[0] = 0x70; /*Fixed format sense data*/
+				c->sense[2] = 0x02;
+				c->sense[12] = 0x04;
+				c->sense[13] = 0x00;
+				sense_len = 14;
+				ignore_error = 1;
+			} else if (errno == EINVAL) {
+				/* Inappropriate MODE SENSE */
+				/* INVALID FIELD IN CDB */
+
+#ifdef Libburn_ahci_verbouS
+				fprintf(stderr, "libburn_EXPERIMENTAL: Emulating [5,24,00] INVALID FIELD IN CDB\n");
+#endif
+
+				c->sense[0] = 0x70; /*Fixed format sense data*/
+				c->sense[2] = 0x05;
+				c->sense[12] = 0x24;
+				c->sense[13] = 0x00;
+				sense_len = 14;
+				ignore_error = 1;
+			}
+		}
+
+		if (err == -1 && !ignore_error) {
 			libdax_msgs_submit(libdax_messenger,
 				d->global_index, 0x0002010c,
 				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 				"Failed to transfer command to drive",
 				errno, 0);
-			cam_freeccb(ccb);
 			sg_close_drive(d);
 			d->released = 1;
 			d->busy = BURN_DRIVE_IDLE;
 			c->error = 1;
-			return -1;
+			{ret = -1; goto ex;}
 		}
 		/* XXX */
-		memcpy(c->sense, &ccb->csio.sense_data, ccb->csio.sense_len);
+
 		if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
-			if (!c->retry) {
-				c->error = 1;
-				cam_freeccb(ccb);
-				return 1;
-			}
-			switch (scsi_error(d, c->sense, 0)) {
-			case RETRY:
-				done = 0;
-				break;
-			case FAIL:
+			if (sense_len < 14) {
+				/*LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE*/
+
+#ifdef Libburn_ahci_verbouS
+				fprintf(stderr, "libburn_EXPERIMENTAL: CAM_STATUS= %d .Emulating [2,04,00] LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE\n", (ccb->ccb_h.status & CAM_STATUS_MASK));
+#endif
+
+				c->sense[0] = 0x70; /*Fixed format sense data*/
+				c->sense[2] = 0x02;
+				c->sense[12] = 0x04;
+				c->sense[13] = 0x00;
 				done = 1;
-				c->error = 1;
-				break;
 			}
+
+			/* >>> Need own duration time measurement.
+			       Then remove bit1 from flag.
+			*/
+			done = scsi_eval_cmd_outcome(d, c, fp, c->sense,
+						sense_len, 0, start_time,
+						timeout_ms, i,
+						2 | !!ignore_error);
 		} else {
 			done = 1;
 		}
 	} while (!done);
+	ret = 1;
+ex:;
 	cam_freeccb(ccb);
+	return ret;
+}
+
+
+/* ts B00115 */
+/* Return 1 if the given path leads to a regular file or a device that can be
+   seeked, read and eventually written with 2 kB granularity.
+*/
+int burn_os_is_2k_seekrw(char *path, int flag)
+{
+        struct stat stbuf;
+#ifdef Libburn_DIOCGMEDIASIZE_ISBLK
+	int fd, ret;
+	off_t add_size;
+#else
+	char *spt;
+	int i, e;
+#endif /* ! Libburn_DIOCGMEDIASIZE_ISBLK */
+
+        if (stat(path, &stbuf) == -1)
+                return 0;
+        if (S_ISREG(stbuf.st_mode))
+                return 1;
+	if (!S_ISCHR(stbuf.st_mode))
+		return 0;
+
+#ifdef Libburn_DIOCGMEDIASIZE_ISBLK
+
+	/* If it throws no error with DIOCGMEDIASIZE then it is a
+	   'block device'
+	*/
+	fd = open(path, O_RDONLY);
+	if (fd == -1)
+		return 0;
+	ret = ioctl(fd, DIOCGMEDIASIZE, &add_size);
+	close(fd);
+
+	return (ret != -1);
+
+#else /* Libburn_DIOCGMEDIASIZE_ISBLK */
+
+	spt = strrchr(path, '/');
+	if (spt == NULL)
+	        spt = path;
+	else
+	        spt++;
+	e = strlen(spt);
+	for (i = strlen(spt) - 1; i > 0; i--)
+		if (spt[i] >= '0' && spt[i] <= '9')
+			e = i;
+	if (strncmp(spt, "da", e) == 0) /* SCSI disk. E.g. USB stick. */
+		return 1;
+	if (strncmp(spt, "cd", e) == 0) /* SCSI CD drive might be writeable. */
+		return 1;
+	if (strncmp(spt, "ad", e) == 0) /* IDE hard drive */
+		return 1;
+	if (strncmp(spt, "acd", e) == 0) /* IDE CD drive might be writeable */
+		return 1;
+	if (strncmp(spt, "fd", e) == 0) /* Floppy disk */
+		return 1;
+	if (strncmp(spt, "fla", e) == 0) /* Flash drive */
+		return 1;
+	return 0;
+
+#endif /* ! Libburn_DIOCGMEDIASIZE_ISBLK */
+
+}
+
+
+/* ts A70909 */
+/** Estimate the potential payload capacity of a file address.
+    @param path  The address of the file to be examined. If it does not
+                 exist yet, then the directory will be inquired.
+    @param bytes This value gets modified if an estimation is possible
+    @return      -2 = cannot perform necessary operations on file object
+                 -1 = neither path nor dirname of path exist
+                  0 = could not estimate size capacity of file object
+                  1 = estimation has been made, bytes was set
+*/
+int burn_os_stdio_capacity(char *path, off_t *bytes)
+{
+	struct stat stbuf;
+	struct statvfs vfsbuf;
+	char *testpath = NULL, *cpt;
+	off_t add_size = 0;
+	int fd, ret;
+
+	BURN_ALLOC_MEM(testpath, char, 4096);
+	testpath[0] = 0;
+	if (stat(path, &stbuf) == -1) {
+		strcpy(testpath, path);
+		cpt = strrchr(testpath, '/');
+		if(cpt == NULL)
+			strcpy(testpath, ".");
+		else if(cpt == testpath)
+			testpath[1] = 0;
+		else
+			*cpt = 0;
+		if (stat(testpath, &stbuf) == -1)
+			{ret = -1; goto ex;}
+
+#ifdef Libburn_if_this_was_linuX
+
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		int open_mode = O_RDWR, fd, ret;
+		long blocks;
+
+		blocks = *bytes / 512;
+		if(burn_sg_open_o_excl)
+			open_mode |= O_EXCL;
+		fd = open(path, open_mode);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		ret = ioctl(fd, BLKGETSIZE, &blocks);
+		close(fd);
+		if (ret == -1)
+			{ret = -2; goto ex;}
+		*bytes = ((off_t) blocks) * (off_t) 512;
+
+#endif /* Libburn_if_this_was_linuX */
+
+
+	} else if(S_ISCHR(stbuf.st_mode)) {
+		fd = open(path, O_RDONLY);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		ret = ioctl(fd, DIOCGMEDIASIZE, &add_size);
+		close(fd);
+		if (ret == -1)
+			{ret = -2; goto ex;}
+		*bytes = add_size;
+	} else if(S_ISREG(stbuf.st_mode)) {
+		add_size = stbuf.st_blocks * (off_t) 512;
+		strcpy(testpath, path);
+	} else
+		{ret = 0; goto ex;}
+
+	if (testpath[0]) {	
+		if (statvfs(testpath, &vfsbuf) == -1)
+			{ret = -2; goto ex;}
+		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
+						(off_t) vfsbuf.f_bavail;
+	}
+	ret = 1;
+ex:
+	BURN_FREE_MEM(testpath);
+	return ret;
+}
+
+
+/* ts A91122 : an interface to open(O_DIRECT) or similar OS tricks. */
+
+#ifdef Libburn_read_o_direcT
+
+	/* No special O_DIRECT-like precautions are implemented here */
+
+#endif /* Libburn_read_o_direcT */
+
+
+int burn_os_open_track_src(char *path, int open_flags, int flag)
+{
+	int fd;
+
+	fd = open(path, open_flags);
+	return fd;
+}
+
+
+void *burn_os_alloc_buffer(size_t amount, int flag)
+{
+	void *buf = NULL;
+
+	buf = calloc(1, amount);
+	return buf;
+}
+
+
+int burn_os_free_buffer(void *buffer, size_t amount, int flag)
+{
+	if (buffer == NULL)
+		return 0;
+	free(buffer);
 	return 1;
 }
 

libburn/sg-libcdio.c

@@ -0,0 +1,997 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+/*
+   Copyright (c) 2009 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
+/*
+
+This is the main operating system dependent SCSI part of libburn. It implements
+the transport level aspects of SCSI control and command i/o.
+
+Present implementation: GNU libcdio , for X/Open compliant operating systems
+
+
+PORTING:
+
+Porting libburn typically will consist of adding a new operating system case
+to the following switcher files:
+  os.h    Operating system specific libburn definitions and declarations.
+  sg.c    Operating system dependent transport level modules.
+and of deriving the following system specific files from existing examples:
+  os-*.h  Included by os.h. You will need some general system knowledge
+          about signals and knowledge about the storage object needs of your
+          transport level module sg-*.c.
+
+  sg-*.c  This source module. You will need special system knowledge about
+          how to detect all potentially available drives, how to open them,
+          eventually how to exclusively reserve them, how to perform
+          SCSI transactions, how to inquire the (pseudo-)SCSI driver.
+          You will not need to care about CD burning, MMC or other high-level
+          SCSI aspects.
+
+Said sg-*.c operations are defined by a public function interface, which has
+to be implemented in a way that provides libburn with the desired services:
+
+sg_id_string()          returns an id string of the SCSI transport adapter.
+                        It may be called before initialization but then may
+                        return only a preliminary id.
+
+sg_initialize()         performs global initialization of the SCSI transport
+                        adapter and eventually needed operating system
+                        facilities. Checks for compatibility of supporting
+                        software components.
+
+sg_shutdown()           performs global finalizations and releases golbally
+                        aquired resources.
+
+sg_give_next_adr()      iterates over the set of potentially useful drive 
+                        address strings.
+
+scsi_enumerate_drives() brings all available, not-whitelist-banned, and
+                        accessible drives into libburn's list of drives.
+
+sg_dispose_drive()      finalizes adapter specifics of struct burn_drive
+                        on destruction. Releases resources which were aquired
+                        underneath scsi_enumerate_drives().
+ 
+sg_drive_is_open()      tells wether libburn has the given drive in use.
+
+sg_grab()               opens the drive for SCSI commands and ensures
+                        undisturbed access.
+
+sg_release()            closes a drive opened by sg_grab()
+
+sg_issue_command()      sends a SCSI command to the drive, receives reply,
+                        and evaluates wether the command succeeded or shall
+                        be retried or finally failed.
+
+sg_obtain_scsi_adr()    tries to obtain SCSI address parameters.
+
+
+burn_os_is_2k_seekrw()  tells whether the given path leads to a file object
+                        that can be used in 2 kB granularity by lseek(2),
+                        read(2), and possibly write(2) if not read-only..
+                        E.g. a USB stick or a hard disk.
+
+burn_os_stdio_capacity()  estimates the emulated media space of stdio-drives.
+
+burn_os_open_track_src()  opens a disk file in a way that allows best
+                        throughput with file reading and/or SCSI write command
+                        transmission.
+
+burn_os_alloc_buffer()  allocates a memory area that is suitable for file
+                        descriptors issued by burn_os_open_track_src().
+                        The buffer size may be rounded up for alignment
+                        reasons.
+
+burn_os_free_buffer()   delete a buffer obtained by burn_os_alloc_buffer().
+
+Porting hints are marked by the text "PORTING:".
+Send feedback to libburn-hackers@pykix.org .
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+
+/** PORTING : ------- OS dependent headers and definitions ------ */
+
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifdef Libburn_os_has_statvfS
+#include <sys/statvfs.h>
+#endif /* Libburn_os_has_stavtfS */
+
+#ifdef __linux
+/* for ioctl(BLKGETSIZE) */
+#include <sys/ioctl.h>
+#include <linux/fs.h>
+#endif
+
+#ifdef __FreeBSD__
+#define Libburn_is_on_freebsD 1
+#endif
+#ifdef __FreeBSD_kernel__
+#define Libburn_is_on_freebsD 1
+#endif
+#ifdef Libburn_is_on_freebsD
+/* To avoid ATAPI devices */
+#define Libburn_guess_freebsd_atapi_devicE 1
+/* To obtain size of disk-like devices */
+#include <sys/disk.h> /* DIOCGMEDIASIZE */
+#endif /* Libburn_is_on_freebsD */
+
+#define Libburn_guess_freebsd_atapi_devicE 1
+
+#ifdef sun
+#define Libburn_is_on_solariS 1
+#endif
+#ifdef __sun
+#define Libburn_is_on_solariS 1
+#endif
+
+/* Proposal by Rocky Bernstein to avoid macro clashes with cdio_config.h */
+#define __CDIO_CONFIG_H__ 1
+
+#include <cdio/cdio.h>
+#include <cdio/logging.h>
+#include <cdio/mmc.h>
+
+
+/* The waiting time before eventually retrying a failed SCSI command.
+   Before each retry wait Libburn_sg_linux_retry_incR longer than with
+   the previous one.
+*/
+#define Libburn_sg_libcdio_retry_usleeP 100000
+#define Libburn_sg_libcdio_retry_incR   100000
+
+
+/** PORTING : ------ libburn portable headers and definitions ----- */
+
+#include "transport.h"
+#include "drive.h"
+#include "sg.h"
+#include "spc.h"
+/* collides with symbols of <cdio/mmc.h>
+ #include "mmc.h"
+*/
+#include "sbc.h"
+#include "debug.h"
+#include "toc.h"
+#include "util.h"
+#include "init.h"
+
+#include "libdax_msgs.h"
+extern struct libdax_msgs *libdax_messenger;
+
+
+/* is in portable part of libburn */
+int burn_drive_is_banned(char *device_address);
+int burn_drive_resolve_link(char *path, char adr[],
+			 int *recursion_count, int flag); /* drive.c */
+
+/* Whether to log SCSI commands:
+   bit0= log in /tmp/libburn_sg_command_log
+   bit1= log to stderr
+   bit2= flush every line
+*/
+extern int burn_sg_log_scsi;
+
+
+/* ------------------------------------------------------------------------ */
+/* PORTING:   Private definitions. Port only if needed by public functions. */
+/*            (Public functions are listed below)                           */
+/* ------------------------------------------------------------------------ */
+
+
+/* Storage object is in libburn/init.c
+   whether to strive for exclusive access to the drive
+*/
+extern int burn_sg_open_o_excl;
+
+
+/* ------------------------------------------------------------------------ */
+/* PORTING: Private functions. Port only if needed by public functions      */
+/*          (Public functions are listed below)                             */
+/* ------------------------------------------------------------------------ */
+
+
+static int sg_close_drive(struct burn_drive * d)
+{
+	CdIo_t *p_cdio;
+
+	if (d->p_cdio != NULL) {
+		p_cdio = (CdIo_t *) d->p_cdio;
+		cdio_destroy(p_cdio);
+		d->p_cdio = NULL;
+	}
+	return 0;
+}
+
+
+static int sg_give_next_adr_raw(burn_drive_enumerator_t *idx,
+				     char adr[], int adr_size, int initialize)
+{
+	char **pos;
+	int count = 0;
+
+	if (initialize == 1) {
+		idx->pos = idx->ppsz_cd_drives =
+					cdio_get_devices(DRIVER_DEVICE);
+		if (idx->ppsz_cd_drives == NULL)
+			return 0;
+
+		for (pos = idx->ppsz_cd_drives ; pos != NULL; pos++) {
+			if (*pos == NULL)
+		break;
+			count++;
+		}
+
+	} else if (initialize == -1) {
+		if (idx->ppsz_cd_drives != NULL)
+			if (*(idx->ppsz_cd_drives) != NULL)
+				cdio_free_device_list(idx->ppsz_cd_drives);
+		idx->ppsz_cd_drives = NULL;
+	}
+
+#ifdef Libburn_guess_freebsd_atapi_devicE
+try_next:;
+#endif
+
+	if (idx->pos == NULL)
+		return 0;
+	if (*(idx->pos) == NULL)
+		return 0;
+
+#ifdef Libburn_guess_freebsd_atapi_devicE
+	if (strncmp(*(idx->pos), "/dev/acd", 8) == 0) {
+		(idx->pos)++;
+		goto try_next;
+	}
+#endif
+
+	if ((ssize_t) strlen(*(idx->pos)) >= adr_size)
+		return -1;
+	strcpy(adr, *(idx->pos));
+	(idx->pos)++;
+	return 1;
+}
+
+
+/* ----------------------------------------------------------------------- */
+/* PORTING: Private functions which contain publicly needed functionality. */
+/*          Their portable part must be performed. So it is probably best  */
+/*          to replace the non-portable part and to call these functions   */
+/*          in your port, too.                                             */
+/* ----------------------------------------------------------------------- */
+
+
+/** Wraps a detected drive into libburn structures and hands it over to
+    libburn drive list.
+*/
+static void enumerate_common(char *fname, char *cdio_name,
+				int bus_no, int host_no,
+				int channel_no, int target_no, int lun_no)
+{
+	int ret;
+	struct burn_drive out;
+
+	/* General libburn drive setup */
+	burn_setup_drive(&out, fname);
+
+	/* This transport adapter uses SCSI-family commands and models
+	   (seems the adapter would know better than its boss, if ever) */
+	ret = burn_scsi_setup_drive(&out, bus_no, host_no, channel_no,
+                                 target_no, lun_no, 0);
+        if (ret <= 0)
+                return;
+
+	/* PORTING: ------------------- non portable part --------------- */
+
+	/* Transport adapter is libcdio */
+	/* Adapter specific handles and data */
+	out.p_cdio = NULL;
+	strcpy(out.libcdio_name, fname);
+	if (strlen(cdio_name) < sizeof(out.libcdio_name))
+		strcpy(out.libcdio_name, cdio_name);
+
+	/* PORTING: ---------------- end of non portable part ------------ */
+
+	/* Adapter specific functions with standardized names */
+	out.grab = sg_grab;
+	out.release = sg_release;
+	out.drive_is_open = sg_drive_is_open;
+	out.issue_command = sg_issue_command;
+	/* Finally register drive and inquire drive information */
+	burn_drive_finish_enum(&out);
+}
+
+
+/* ------------------------------------------------------------------------ */
+/* PORTING:           Public functions. These MUST be ported.               */
+/* ------------------------------------------------------------------------ */
+
+
+/** Returns the id string  of the SCSI transport adapter and eventually
+    needed operating system facilities.
+    This call is usable even if sg_initialize() was not called yet. In that
+    case a preliminary constant message might be issued if detailed info is
+    not available yet.
+    @param msg   returns id string
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_id_string(char msg[1024], int flag)
+{
+	char *version_text;
+
+	sprintf(msg, "sg-libcdio h%d with libcdio ", LIBCDIO_VERSION_NUM);
+
+ #if LIBCDIO_VERSION_NUM < 83 
+
+LIBBURN_MISCONFIGURATION = 0;
+INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_cdio_version_dot_h_TOO_OLD__NEED_libcdio_VERSION_NUM_83 = 0;
+LIBBURN_MISCONFIGURATION_ = 0;
+
+ #endif /* LIBCDIO_VERSION_NUM < 83  */
+
+	version_text = (char *) cdio_version_string;
+	strncat(msg, version_text, 800);
+	return 1;
+}
+
+
+/** Performs global initialization of the SCSI transport adapter and eventually
+    needed operating system facilities. Checks for compatibility of supporting
+    software components.
+    @param msg   returns ids and/or error messages of eventual helpers
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/ 
+int sg_initialize(char msg[1024], int flag)
+{
+	int cdio_ver;
+	char *msg_pt;
+
+	cdio_loglevel_default = CDIO_LOG_ASSERT;
+
+	msg[0] = 0;
+	sg_id_string(msg, 0);
+	cdio_ver = libcdio_version_num;
+	libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
+		LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+		msg , 0, 0);
+	if (cdio_ver < LIBCDIO_VERSION_NUM) {
+		strcat(msg, " ---> ");
+		msg_pt = msg + strlen(msg);
+		sprintf(msg_pt,
+		    "libcdio TOO OLD: numeric version %d , need at least %d",
+		    cdio_ver, LIBCDIO_VERSION_NUM);
+		libdax_msgs_submit(libdax_messenger, -1,
+			0x00000002,
+			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+			msg_pt, 0, 0);
+		return 0;
+	}
+	return 1;
+}
+
+
+/** Performs global finalization of the SCSI transport adapter and eventually
+    needed operating system facilities. Releases globally aquired resources.
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/ 
+int sg_shutdown(int flag)
+{
+	return 1;
+}
+
+
+/** Finalizes BURN_OS_TRANSPORT_DRIVE_ELEMENTS, the components of
+    struct burn_drive which are defined in os-*.h.
+    The eventual initialization of those components was made underneath
+    scsi_enumerate_drives().
+    This will be called when a burn_drive gets disposed.
+    @param d     the drive to be finalized
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_dispose_drive(struct burn_drive *d, int flag)
+{
+	return 1;
+}
+
+
+/** Returns the next index number and the next enumerated drive address.
+    The enumeration has to cover all available and accessible drives. It is
+    allowed to return addresses of drives which are not available but under
+    some (even exotic) circumstances could be available. It is on the other
+    hand allowed, only to hand out addresses which can really be used right
+    in the moment of this call. (This implementation chooses the latter.)
+    @param idx An opaque handle. Make no own theories about it.
+    @param adr Takes the reply
+    @param adr_size Gives maximum size of reply including final 0
+    @param initialize  1 = start new,
+                       0 = continue, use no other values for now
+                      -1 = finish
+    @return 1 = reply is a valid address , 0 = no further address available
+           -1 = severe error (e.g. adr_size too small)
+*/
+int sg_give_next_adr(burn_drive_enumerator_t *idx,
+		     char adr[], int adr_size, int initialize)
+{
+	int ret, recursion_count = 0, path_size = 4096;
+	char *path = NULL;
+#ifdef Libburn_is_on_solariS
+	int l;
+#endif
+	BURN_ALLOC_MEM(path, char, path_size);
+
+	ret = sg_give_next_adr_raw(idx, adr, adr_size, initialize);
+	if (ret <= 0)
+		goto ex;
+	if ((ssize_t) strlen(adr) >= path_size)
+		goto ex;
+
+#ifdef Libburn_is_on_solariS
+	/* >>> provisory : preserve Solaris /dev/rdsk/cXtYdZs2 addresses */
+	l = strlen(adr);
+	if (l >= 18)
+		if (strncmp(adr, "/dev/rdsk/c", 11) == 0 && adr[11] >= '0' &&
+		    adr[11] <= '9' && strcmp(adr + (l - 2), "s2") == 0)
+			{ret = 1; goto ex;}
+#endif /* Libburn_is_on_solariS */
+
+	ret = burn_drive_resolve_link(adr, path, &recursion_count, 2);
+        if(ret > 0 && (ssize_t) strlen(path) < adr_size)
+		strcpy(adr, path);
+	ret = (ret >= 0);
+ex:
+	BURN_FREE_MEM(path);
+	return ret;
+}
+
+
+/** Brings all available, not-whitelist-banned, and accessible drives into
+    libburn's list of drives.
+*/
+int scsi_enumerate_drives(void)
+{
+	burn_drive_enumerator_t idx;
+	int initialize = 1, ret, i_bus_no = -1, recursion_count = 0;
+        int i_host_no = -1, i_channel_no = -1, i_target_no = -1, i_lun_no = -1;
+	int buf_size = 4096;
+	char *buf = NULL, *target = NULL;
+#ifdef Libburn_is_on_solariS
+	int l;
+#endif
+
+	BURN_ALLOC_MEM(buf, char, buf_size);
+	BURN_ALLOC_MEM(target, char, buf_size);
+
+	while(1) {
+		ret = sg_give_next_adr_raw(&idx, buf, buf_size, initialize);
+		initialize = 0;
+		if (ret <= 0)
+	break;
+		ret = 1;
+
+#ifdef Libburn_is_on_solariS 
+		/* >>> provisory : preserve Solaris /dev/rdsk/cXtYdZs2 */
+		l = strlen(buf);
+		if (l >= 18)
+			if (strncmp(buf, "/dev/rdsk/c", 11) == 0 &&
+			    buf[11] >= '0' && buf[11] <= '9' &&
+			    strcmp(buf + (l - 2), "s2") == 0)
+				ret = 0;
+#endif /* Libburn_is_on_solariS */
+
+		if (ret == 1) {
+			ret = burn_drive_resolve_link(buf, target,
+							 &recursion_count,2);
+		}
+		if (ret <= 0)
+			strcpy(target, buf);
+		if (burn_drive_is_banned(target))
+	continue; 
+		sg_obtain_scsi_adr(buf, &i_bus_no, &i_host_no,
+				&i_channel_no, &i_target_no, &i_lun_no);
+		enumerate_common(target, buf,
+				i_bus_no, i_host_no, i_channel_no,
+				i_target_no, i_lun_no);
+	}
+	sg_give_next_adr(&idx, buf, buf_size, -1);
+	ret = 1;
+ex:;
+	BURN_FREE_MEM(buf);
+	BURN_FREE_MEM(target);
+	return ret;
+}
+
+
+/** Tells whether libburn has the given drive in use or exclusively reserved.
+    If it is "open" then libburn will eventually call sg_release() on it when
+    it is time to give up usage resp. reservation.
+*/
+/** Published as burn_drive.drive_is_open() */
+int sg_drive_is_open(struct burn_drive * d)
+{
+	return (d->p_cdio != NULL);
+}
+
+
+/** Opens the drive for SCSI commands and - if burn activities are prone
+    to external interference on your system - obtains an exclusive access lock
+    on the drive. (Note: this is not physical tray locking.)
+    A drive that has been opened with sg_grab() will eventually be handed
+    over to sg_release() for closing and unreserving. 
+*/  
+int sg_grab(struct burn_drive *d)
+{
+	CdIo_t *p_cdio;
+	char *am_eff, *msg = NULL, *am_wanted;
+	int os_errno, second_try = 0, ret;
+
+	if (d->p_cdio != NULL) {
+		d->released = 0;
+		{ret = 1; goto ex;}
+	}
+	if (d->libcdio_name[0] == 0) /* just to be sure it is initialized */
+		strcpy(d->libcdio_name, d->devname);
+	am_wanted = (burn_sg_open_o_excl & 63) ?  "MMC_RDWR_EXCL" : "MMC_RDWR";
+try_to_open:;
+	p_cdio = cdio_open_am(d->libcdio_name, DRIVER_DEVICE, am_wanted);
+	if (p_cdio == NULL) {
+		BURN_ALLOC_MEM(msg, char, 4096);
+		os_errno = errno;
+		sprintf(msg, "Could not grab drive '%s'", d->devname);
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020003,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			msg, os_errno, 0);
+		{ret = 0; goto ex;}
+	}
+	am_eff = (char *) cdio_get_arg(p_cdio, "access-mode");
+        if (strncmp(am_eff, "MMC_RDWR", 8) != 0) {
+		cdio_destroy(p_cdio);
+		if (!second_try) {
+			am_wanted = (burn_sg_open_o_excl & 63) ?
+						"MMC_RDWR" : "MMC_RDWR_EXCL";
+			second_try = 1;
+			goto try_to_open;
+		}
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020003,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			"libcdio provides no MMC_RDWR access mode", 0, 0);
+		{ret = 0; goto ex;}
+        }
+
+	d->p_cdio = p_cdio;
+	d->released = 0;
+	ret = 1;
+ex:;
+	BURN_FREE_MEM(msg);
+	return ret;
+}
+
+
+/** PORTING: Is mainly about the call to sg_close_drive() and whether it
+             implements the demanded functionality.
+*/
+/** Gives up the drive for SCSI commands and releases eventual access locks.
+    (Note: this is not physical tray locking.) 
+*/
+int sg_release(struct burn_drive *d)
+{
+	if (d->p_cdio == NULL)
+		return 0;
+	sg_close_drive(d);
+	return 0;
+}
+
+
+/** Sends a SCSI command to the drive, receives reply and evaluates wether
+    the command succeeded or shall be retried or finally failed.
+    Returned SCSI errors shall not lead to a return value indicating failure.
+    The callers get notified by c->error. An SCSI failure which leads not to
+    a retry shall be notified via scsi_notify_error().
+    The Libburn_log_sg_commandS facility might be of help when problems with
+    a drive have to be examined. It shall stay disabled for normal use.
+    @return: 1 success , <=0 failure
+*/
+int sg_issue_command(struct burn_drive *d, struct command *c)
+{
+	int sense_valid = 0, i, timeout_ms, sense_len;
+	int key = 0, asc = 0, ascq = 0, done = 0;
+	time_t start_time;
+        driver_return_code_t i_status;
+	unsigned int dxfer_len;
+        static FILE *fp = NULL;
+	mmc_cdb_t cdb = {{0, }};
+	cdio_mmc_direction_t e_direction;
+	CdIo_t *p_cdio;
+	cdio_mmc_request_sense_t *sense_pt = NULL;
+
+	c->error = 0;
+	if (d->p_cdio == NULL) {
+		return 0;
+	}
+	p_cdio = (CdIo_t *) d->p_cdio;
+	if (burn_sg_log_scsi & 1) {
+		if (fp == NULL) {
+			fp= fopen("/tmp/libburn_sg_command_log", "a");
+			fprintf(fp,
+			    "\n-----------------------------------------\n");
+		}
+	}
+	if (burn_sg_log_scsi & 3)
+		scsi_log_cmd(c,fp,0);
+
+	memcpy(cdb.field, c->opcode, c->oplen);
+	if (c->dir == TO_DRIVE) {
+		dxfer_len = c->page->bytes;
+		e_direction = SCSI_MMC_DATA_WRITE;
+	} else if (c->dir == FROM_DRIVE) {
+		if (c->dxfer_len >= 0)
+			dxfer_len = c->dxfer_len;
+		else
+			dxfer_len = BUFFER_SIZE;
+		e_direction = SCSI_MMC_DATA_READ;
+		/* touch page so we can use valgrind */
+		memset(c->page->data, 0, BUFFER_SIZE);
+	} else {
+		dxfer_len = 0;
+		e_direction = SCSI_MMC_DATA_NONE;
+	}
+		
+	/* retry-loop */
+	start_time = time(NULL);
+	timeout_ms = 200000;
+	for(i = 0; !done; i++) {
+
+		i_status = mmc_run_cmd(p_cdio, timeout_ms, &cdb, e_direction,
+				 	dxfer_len, c->page->data);
+		sense_valid = mmc_last_cmd_sense(p_cdio, &sense_pt);
+		if (sense_valid >= 18) {
+			memcpy(c->sense, (unsigned char *) sense_pt,
+				(size_t) sense_valid >= sizeof(c->sense) ?
+				sizeof(c->sense) : (size_t) sense_valid );
+			spc_decode_sense(c->sense, 0, &key, &asc, &ascq);
+		} else
+			key = asc = ascq = 0;
+		if (sense_pt != NULL)
+			free(sense_pt);
+
+/* Regrettably mmc_run_cmd() does not clearly distinguish between transport
+   failure and SCSI error reply.
+   This reaction here would be for transport failure:
+
+		if (i_status != 0 && i_status != DRIVER_OP_ERROR) {
+			libdax_msgs_submit(libdax_messenger,
+				d->global_index, 0x0002010c,
+				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+				"Failed to transfer command to drive",
+				errno, 0);
+			sg_close_drive(d);
+			d->released = 1;
+			d->busy = BURN_DRIVE_IDLE;
+			c->error = 1;
+			return -1;
+		}
+*/
+
+		if ((!sense_valid) || (key == 0 && asc == 0 && ascq == 0)) {
+			memset(c->sense, 0, sizeof(c->sense));
+			if (i_status != 0) { /* set dummy sense */
+				/*LOGICAL UNIT NOT READY,
+					CAUSE NOT REPORTABLE*/
+				c->sense[0] = 0x70; /*Fixed format sense data*/
+				c->sense[2] = 0x02;
+				c->sense[12] = 0x04;
+				done = 1;
+			}
+		} 
+		if (key || asc || ascq)
+			sense_len = 18;
+		else
+			sense_len = 0;
+		done = scsi_eval_cmd_outcome(d, c, fp,  c->sense, sense_len,
+					0, start_time, timeout_ms, i, 2);
+
+	} /* end of retry-loop */
+
+	return 1;
+}
+
+
+/** Tries to obtain SCSI address parameters.
+    @return  1 is success , 0 is failure
+*/
+int sg_obtain_scsi_adr(char *path, int *bus_no, int *host_no, int *channel_no,
+                       int *target_no, int *lun_no)
+{
+	CdIo_t *p_cdio;
+	char *tuple;
+
+	*bus_no = *host_no = *channel_no = *target_no = *lun_no = -1;
+
+	p_cdio = cdio_open(path, DRIVER_DEVICE);
+	if (p_cdio == NULL)
+		return 0;
+
+	/* Try whether a bus,host,channel,target,lun address tuple is
+	   available */
+	tuple = (char *) cdio_get_arg(p_cdio, "scsi-tuple");
+        if (tuple != NULL) if (tuple[0]) {
+		sscanf(tuple, "%d,%d,%d,%d,%d",
+			bus_no, host_no, channel_no, target_no, lun_no);
+	}
+
+	cdio_destroy(p_cdio);
+	return (*bus_no >= 0);
+}
+
+
+/** Tells wether a text is a persistent address as listed by the enumeration
+    functions.
+*/
+int sg_is_enumerable_adr(char* adr)
+{
+	burn_drive_enumerator_t idx;
+	int initialize = 1, ret;
+	char buf[64];
+
+	while(1) {
+		ret = sg_give_next_adr(&idx, buf, sizeof(buf), initialize);
+		initialize = 0;
+		if (ret <= 0)
+	break;
+		if (strcmp(adr, buf) == 0) {
+			sg_give_next_adr(&idx, buf, sizeof(buf), -1);
+			return 1;
+		}
+	}
+	sg_give_next_adr(&idx, buf, sizeof(buf), -1);
+	return (0);
+}
+
+
+#ifdef __FreeBSD__
+#define Libburn_guess_block_devicE 1
+#endif
+#ifdef __FreeBSD_kernel__
+#define Libburn_guess_block_devicE 1
+#endif
+
+#ifdef Libburn_guess_block_devicE
+
+/* ts B00115 */
+/* The FreeBSD implementation of burn_os_is_2k_seekrw().
+   On FreeBSD there are no block devices.
+*/
+static int freebsd_is_2k_seekrw(char *path, int flag)
+{
+        struct stat stbuf;
+	char *spt;
+	int i, e;
+
+        if (stat(path, &stbuf) == -1)
+                return 0;
+        if (S_ISREG(stbuf.st_mode))
+                return 1;
+	if (!S_ISCHR(stbuf.st_mode))
+		return 0;
+	spt = strrchr(path, '/');
+	if (spt == NULL)
+	        spt = path;
+	else
+	        spt++;
+	e = strlen(spt);
+	for (i = strlen(spt) - 1; i > 0; i--)
+		if (spt[i] >= '0' && spt[i] <= '9')
+			e = i;
+	if (strncmp(spt, "da", e) == 0) /* SCSI disk. E.g. USB stick. */
+		return 1;
+	if (strncmp(spt, "cd", e) == 0) /* SCSI CD drive might be writeable. */
+		return 1;
+	if (strncmp(spt, "ad", e) == 0) /* IDE hard drive */
+		return 1;
+	if (strncmp(spt, "acd", e) == 0) /* IDE CD drive might be writeable */
+		return 1;
+	if (strncmp(spt, "fd", e) == 0) /* Floppy disk */
+		return 1;
+	if (strncmp(spt, "fla", e) == 0) /* Flash drive */
+		return 1;
+	return 0;
+}
+
+#endif /* Libburn_guess_block_devicE */
+
+
+/* Return 1 if the given path leads to a regular file or a device that can be
+   seeked, read, and possibly written with 2 kB granularity. 
+*/
+int burn_os_is_2k_seekrw(char *path, int flag)
+{
+#ifdef Libburn_guess_block_devicE
+	return freebsd_is_2k_seekrw(path, flag);
+#else 
+	struct stat stbuf;
+
+	if (stat(path, &stbuf) == -1)
+		return 0;
+	if (S_ISREG(stbuf.st_mode))
+		return 1;
+	if (S_ISBLK(stbuf.st_mode))
+		return 1;
+	return 0;
+#endif /* ! Libburn_guess_block_devicE */
+}
+
+
+/** Estimate the potential payload capacity of a file address.
+    @param path  The address of the file to be examined. If it does not
+                 exist yet, then the directory will be inquired.
+    @param bytes The pointed value gets modified, but only if an estimation is
+                 possible.
+    @return      -2 = cannot perform necessary operations on file object
+                 -1 = neither path nor dirname of path exist
+                  0 = could not estimate size capacity of file object
+                  1 = estimation has been made, bytes was set
+*/
+int burn_os_stdio_capacity(char *path, off_t *bytes)
+{
+	struct stat stbuf;
+
+#ifdef Libburn_os_has_statvfS
+	struct statvfs vfsbuf;
+#endif
+
+	char *testpath = NULL, *cpt;
+	off_t add_size = 0;
+	int ret;
+
+	BURN_ALLOC_MEM(testpath, char, 4096);
+	testpath[0] = 0;
+	if (stat(path, &stbuf) == -1) {
+		strcpy(testpath, path);
+		cpt = strrchr(testpath, '/');
+		if(cpt == NULL)
+			strcpy(testpath, ".");
+		else if(cpt == testpath)
+			testpath[1] = 0;
+		else
+			*cpt = 0;
+		if (stat(testpath, &stbuf) == -1)
+			{ret = -1; goto ex;}
+
+#ifdef __linux
+
+	/* GNU/Linux specific determination of block device size */
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		int open_mode = O_RDONLY, fd;
+		long blocks;
+
+		blocks = *bytes / 512;
+		fd = open(path, open_mode);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		ret = ioctl(fd, BLKGETSIZE, &blocks);
+		close(fd);
+		if (ret == -1)
+			{ret = -2; goto ex;}
+		*bytes = ((off_t) blocks) * (off_t) 512;
+
+#endif /* __linux */
+
+#ifdef Libburn_is_on_freebsD
+
+	} else if(S_ISCHR(stbuf.st_mode)) {
+		int fd;
+
+		fd = open(path, O_RDONLY);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		ret = ioctl(fd, DIOCGMEDIASIZE, &add_size);
+		close(fd);
+		if (ret == -1)
+			{ret = -2; goto ex;}
+		*bytes = add_size;
+
+#endif /* Libburn_is_on_freebsD */
+
+#ifdef Libburn_is_on_solariS
+
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		int open_mode = O_RDONLY, fd;
+		
+		fd = open(path, open_mode);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		*bytes = lseek(fd, 0, SEEK_END);
+		close(fd);
+		if (*bytes == -1) {
+			*bytes = 0;
+			{ret = 0; goto ex;}
+		}
+		
+#endif /* Libburn_is_on_solariS */
+
+	} else if(S_ISREG(stbuf.st_mode)) {
+		add_size = stbuf.st_blocks * (off_t) 512;
+		strcpy(testpath, path);
+	} else
+		{ret = 0; goto ex;}
+
+	if (testpath[0]) {	
+
+#ifdef Libburn_os_has_statvfS
+
+		if (statvfs(testpath, &vfsbuf) == -1)
+			{ret = -2; goto ex;}
+		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
+						(off_t) vfsbuf.f_bavail;
+
+#else /* Libburn_os_has_statvfS */
+
+		{ret = 0; goto ex;}
+
+#endif /* ! Libburn_os_has_stavtfS */
+
+	}
+	ret = 1;
+ex:;
+	BURN_FREE_MEM(testpath);
+	return ret;
+}
+
+
+/* ts A91122 : an interface to open(O_DIRECT) or similar OS tricks. */
+
+#ifdef Libburn_read_o_direcT
+
+	/* No special O_DIRECT-like precautions are implemented here */
+
+#endif /* Libburn_read_o_direcT */
+
+
+int burn_os_open_track_src(char *path, int open_flags, int flag)
+{
+	int fd;
+
+	fd = open(path, open_flags);
+	return fd;
+}
+
+
+void *burn_os_alloc_buffer(size_t amount, int flag)
+{
+	void *buf = NULL;
+
+	buf = calloc(1, amount);
+	return buf;
+}
+
+
+int burn_os_free_buffer(void *buffer, size_t amount, int flag)
+{
+	if (buffer == NULL)
+		return 0;
+	free(buffer);
+	return 1;
+}
+

libburn/sg-solaris.c

@@ -0,0 +1,880 @@
+/* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
+
+/*
+   Copyright (c) 2010 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
+/*
+
+This is the main operating system dependent SCSI part of libburn. It implements
+the transport level aspects of SCSI control and command i/o.
+
+Present implementation: Solaris uscsi, e.g. for SunOS 5.11
+
+
+PORTING:
+
+Porting libburn typically will consist of adding a new operating system case
+to the following switcher files:
+  os.h    Operating system specific libburn definitions and declarations.
+  sg.c    Operating system dependent transport level modules.
+and of deriving the following system specific files from existing examples:
+  os-*.h  Included by os.h. You will need some general system knowledge
+          about signals and knowledge about the storage object needs of your
+          transport level module sg-*.c.
+
+  sg-*.c  This source module. You will need special system knowledge about
+          how to detect all potentially available drives, how to open them,
+          eventually how to exclusively reserve them, how to perform
+          SCSI transactions, how to inquire the (pseudo-)SCSI driver.
+          You will not need to care about CD burning, MMC or other high-level
+          SCSI aspects.
+
+Said sg-*.c operations are defined by a public function interface, which has
+to be implemented in a way that provides libburn with the desired services:
+
+sg_id_string()          returns an id string of the SCSI transport adapter.
+                        It may be called before initialization but then may
+                        return only a preliminary id.
+
+sg_initialize()         performs global initialization of the SCSI transport
+                        adapter and eventually needed operating system
+                        facilities. Checks for compatibility of supporting
+                        software components.
+
+sg_shutdown()           performs global finalizations and releases golbally
+                        aquired resources.
+
+sg_give_next_adr()      iterates over the set of potentially useful drive 
+                        address strings.
+
+scsi_enumerate_drives() brings all available, not-whitelist-banned, and
+                        accessible drives into libburn's list of drives.
+
+sg_dispose_drive()      finalizes adapter specifics of struct burn_drive
+                        on destruction. Releases resources which were aquired
+                        underneath scsi_enumerate_drives().
+ 
+sg_drive_is_open()      tells wether libburn has the given drive in use.
+
+sg_grab()               opens the drive for SCSI commands and ensures
+                        undisturbed access.
+
+sg_release()            closes a drive opened by sg_grab()
+
+sg_issue_command()      sends a SCSI command to the drive, receives reply,
+                        and evaluates wether the command succeeded or shall
+                        be retried or finally failed.
+
+sg_obtain_scsi_adr()    tries to obtain SCSI address parameters.
+
+
+burn_os_is_2k_seekrw()  tells whether the given path leads to a file object
+                        that can be used in 2 kB granularity by lseek(2),
+                        read(2), and possibly write(2) if not read-only..
+                        E.g. a USB stick or a hard disk.
+
+burn_os_stdio_capacity()  estimates the emulated media space of stdio-drives.
+
+burn_os_open_track_src()  opens a disk file in a way that allows best
+                        throughput with file reading and/or SCSI write command
+                        transmission.
+
+burn_os_alloc_buffer()  allocates a memory area that is suitable for file
+                        descriptors issued by burn_os_open_track_src().
+                        The buffer size may be rounded up for alignment
+                        reasons.
+
+burn_os_free_buffer()   delete a buffer obtained by burn_os_alloc_buffer().
+
+Porting hints are marked by the text "PORTING:".
+Send feedback to libburn-hackers@pykix.org .
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+
+/** PORTING : ------- OS dependent headers and definitions ------ */
+
+#include <unistd.h>
+#include <stropts.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <stdlib.h>
+#include <dirent.h>
+
+#ifdef Libburn_os_has_statvfS
+#include <sys/statvfs.h>
+#endif /* Libburn_os_has_stavtfS */
+
+#include <sys/dkio.h>
+#include <sys/vtoc.h>
+
+#include <sys/scsi/impl/uscsi.h>
+
+
+/* The waiting time before eventually retrying a failed SCSI command.
+   Before each retry wait Libburn_sg_linux_retry_incR longer than with
+   the previous one.
+*/
+#define Libburn_sg_solaris_retry_usleeP 100000
+#define Libburn_sg_solaris_retry_incR   100000
+
+
+/** PORTING : ------ libburn portable headers and definitions ----- */
+
+#include "transport.h"
+#include "drive.h"
+#include "sg.h"
+#include "spc.h"
+#include "sbc.h"
+#include "debug.h"
+#include "toc.h"
+#include "util.h"
+#include "init.h"
+
+#include "libdax_msgs.h"
+extern struct libdax_msgs *libdax_messenger;
+
+
+/* is in portable part of libburn */
+int burn_drive_is_banned(char *device_address);
+int burn_drive_resolve_link(char *path, char adr[],
+			 int *recursion_count, int flag); /* drive.c */
+
+/* Whether to log SCSI commands:
+   bit0= log in /tmp/libburn_sg_command_log
+   bit1= log to stderr
+   bit2= flush every line
+*/
+extern int burn_sg_log_scsi;
+
+
+/* ------------------------------------------------------------------------ */
+/* PORTING:   Private definitions. Port only if needed by public functions. */
+/*            (Public functions are listed below)                           */
+/* ------------------------------------------------------------------------ */
+
+
+/* Storage object is in libburn/init.c
+   whether to strive for exclusive access to the drive
+*/
+extern int burn_sg_open_o_excl;
+
+
+/* ------------------------------------------------------------------------ */
+/* PORTING: Private functions. Port only if needed by public functions      */
+/*          (Public functions are listed below)                             */
+/* ------------------------------------------------------------------------ */
+
+
+static int sg_close_drive(struct burn_drive * d)
+{
+	if (d->fd != -1) {
+		close(d->fd);
+		d->fd = -1;
+		return 1;
+	}
+	return 0;
+}
+
+
+static int decode_btl_number(char **cpt, int stopper, int *no)
+{
+  *no = 0;
+  for ((*cpt)++; **cpt != stopper; (*cpt)++) {
+    if (**cpt < '0' || **cpt > '9')
+      return 0;
+    *no = *no * 10 + **cpt - '0';
+  }
+  return 1;
+}
+
+
+/* Read bus, target, lun from name "cXtYdZs2".
+   Return 0 if name is not of the desired form.
+*/
+static int decode_btl_solaris(char *name, int *busno, int *tgtno, int *lunno,
+                        int flag)
+{
+  char *cpt;
+  int ret;
+
+  *busno = *tgtno = *lunno = -1;
+  cpt = name;
+  if (*cpt != 'c')
+    return 0;
+  ret = decode_btl_number(&cpt, 't', busno);
+  if (ret <= 0)
+    return ret;
+  ret = decode_btl_number(&cpt, 'd', tgtno);
+  if (ret <= 0)
+    return ret;
+  ret = decode_btl_number(&cpt, 's', lunno);
+  if (ret <= 0)
+    return ret;
+  cpt++;
+  if (*cpt != '2' || *(cpt + 1) != 0)
+    return 0;
+  return 1;
+}
+
+
+static int start_enum_cXtYdZs2(burn_drive_enumerator_t *idx, int flag)
+{
+	DIR *dir;
+
+	idx->dir = NULL;
+	dir = opendir("/dev/rdsk");
+	if (dir == NULL) {
+		libdax_msgs_submit(libdax_messenger, -1,
+		    0x0002000c, LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+	"Cannot start device file enumeration. opendir(\"/dev/rdsk\") failed.",
+		    errno, 0);
+		return 0;
+	}
+	idx->dir = dir;
+	return 1;
+}
+
+
+static int next_enum_cXtYdZs2(burn_drive_enumerator_t *idx,
+				char adr[], int adr_size, int flag)
+{ 
+	int busno, tgtno, lunno, ret, fd = -1, volpath_size = 160;
+	char *volpath = NULL;
+	struct dirent *entry;
+	struct dk_cinfo cinfo;
+	DIR *dir;
+
+	BURN_ALLOC_MEM(volpath, char, volpath_size);
+
+	dir = idx->dir;
+	while (1) {
+		errno = 0;
+		entry = readdir(dir);
+		if (entry == NULL) {
+			if (errno) {
+				libdax_msgs_submit(libdax_messenger,
+						-1, 0x0002000d,
+				LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+	"Cannot enumerate next device. readdir() from \"/dev/rdsk\" failed.",
+						errno, 0);
+				{ret = -1; goto ex;}
+			}
+	break;
+		}
+		if (strlen(entry->d_name) > (size_t) (volpath_size - 11))
+	continue;
+		ret = decode_btl_solaris(entry->d_name,
+					&busno, &tgtno, &lunno, 0);
+		if (ret <= 0)
+	continue; /* not cXtYdZs2 */
+
+		sprintf(volpath, "/dev/rdsk/%s", entry->d_name);
+		if (burn_drive_is_banned(volpath))
+	continue; 
+
+		fd = open(volpath, O_RDONLY | O_NDELAY);
+		if (fd < 0)
+	continue;
+		/* See man dkio */
+		ret = ioctl(fd, DKIOCINFO, &cinfo);
+		close(fd);
+		if (ret < 0)
+	continue;
+		if (cinfo.dki_ctype != DKC_CDROM)
+	continue;
+		if (adr_size <= (int) strlen(volpath))
+			{ret = -1; goto ex;}
+		strcpy(adr, volpath);
+		{ret = 1; goto ex;}
+	}
+	ret = 0;
+ex:;
+	BURN_FREE_MEM(volpath);
+	return ret;
+}
+
+
+static int end_enum_cXtYdZs2(burn_drive_enumerator_t *idx, int flag)
+{
+	DIR *dir;
+
+	dir = idx->dir;
+	if(dir != NULL)
+		closedir(dir);
+	idx->dir = NULL;
+	return 1;
+}
+
+
+/* ----------------------------------------------------------------------- */
+/* PORTING: Private functions which contain publicly needed functionality. */
+/*          Their portable part must be performed. So it is probably best  */
+/*          to replace the non-portable part and to call these functions   */
+/*          in your port, too.                                             */
+/* ----------------------------------------------------------------------- */
+
+
+/** Wraps a detected drive into libburn structures and hands it over to
+    libburn drive list.
+*/
+static void enumerate_common(char *fname,
+				int bus_no, int host_no,
+				int channel_no, int target_no, int lun_no)
+{
+	int ret;
+	struct burn_drive out;
+
+	/* General libburn drive setup */
+	burn_setup_drive(&out, fname);
+
+	/* This transport adapter uses SCSI-family commands and models
+	   (seems the adapter would know better than its boss, if ever) */
+	ret = burn_scsi_setup_drive(&out, bus_no, host_no, channel_no,
+                                 target_no, lun_no, 0);
+        if (ret <= 0)
+                return;
+
+	/* PORTING: ------------------- non portable part --------------- */
+
+	/* Transport adapter is Solaris uscsi */
+	/* Adapter specific handles and data */
+	out.fd = -1;
+
+	/* PORTING: ---------------- end of non portable part ------------ */
+
+	/* Adapter specific functions with standardized names */
+	out.grab = sg_grab;
+	out.release = sg_release;
+	out.drive_is_open = sg_drive_is_open;
+	out.issue_command = sg_issue_command;
+	/* Finally register drive and inquire drive information */
+	burn_drive_finish_enum(&out);
+}
+
+
+/* ------------------------------------------------------------------------ */
+/* PORTING:           Public functions. These MUST be ported.               */
+/* ------------------------------------------------------------------------ */
+
+
+/** Returns the id string  of the SCSI transport adapter and eventually
+    needed operating system facilities.
+    This call is usable even if sg_initialize() was not called yet. In that
+    case a preliminary constant message might be issued if detailed info is
+    not available yet.
+    @param msg   returns id string
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_id_string(char msg[1024], int flag)
+{
+	sprintf(msg, "internal Solaris uscsi adapter sg-solaris");
+	return 1;
+}
+
+
+/** Performs global initialization of the SCSI transport adapter and eventually
+    needed operating system facilities. Checks for compatibility of supporting
+    software components.
+    @param msg   returns ids and/or error messages of eventual helpers
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/ 
+int sg_initialize(char msg[1024], int flag)
+{
+	return sg_id_string(msg, 0);
+}
+
+
+/** Performs global finalization of the SCSI transport adapter and eventually
+    needed operating system facilities. Releases globally aquired resources.
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/ 
+int sg_shutdown(int flag)
+{
+	return 1;
+}
+
+
+/** Finalizes BURN_OS_TRANSPORT_DRIVE_ELEMENTS, the components of
+    struct burn_drive which are defined in os-*.h.
+    The eventual initialization of those components was made underneath
+    scsi_enumerate_drives().
+    This will be called when a burn_drive gets disposed.
+    @param d     the drive to be finalized
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_dispose_drive(struct burn_drive *d, int flag)
+{
+	return 1;
+}
+
+
+/** Returns the next index number and the next enumerated drive address.
+    The enumeration has to cover all available and accessible drives. It is
+    allowed to return addresses of drives which are not available but under
+    some (even exotic) circumstances could be available. It is on the other
+    hand allowed, only to hand out addresses which can really be used right
+    in the moment of this call. (This implementation chooses the latter.)
+    @param idx An opaque handle. Make no own theories about it.
+    @param adr Takes the reply
+    @param adr_size Gives maximum size of reply including final 0
+    @param initialize  1 = start new,
+                       0 = continue, use no other values for now
+                      -1 = finish
+    @return 1 = reply is a valid address , 0 = no further address available
+           -1 = severe error (e.g. adr_size too small)
+*/
+int sg_give_next_adr(burn_drive_enumerator_t *idx,
+		     char adr[], int adr_size, int initialize)
+{
+	int ret;
+
+	if (initialize == 1) {
+		ret = start_enum_cXtYdZs2(idx, 0);
+		if (ret <= 0)
+			return ret;
+	} else if (initialize == -1) {
+		ret = end_enum_cXtYdZs2(idx, 0);
+		return 0;
+	}
+	ret = next_enum_cXtYdZs2(idx, adr, adr_size, 0);
+	return ret;
+}
+
+
+/** Brings all available, not-whitelist-banned, and accessible drives into
+    libburn's list of drives.
+*/
+int scsi_enumerate_drives(void)
+{
+	burn_drive_enumerator_t idx;
+	int initialize = 1, ret, i_bus_no = -1, buf_size = 4096;
+        int i_host_no = -1, i_channel_no = -1, i_target_no = -1, i_lun_no = -1;
+	char *buf = NULL;
+
+	BURN_ALLOC_MEM(buf, char, buf_size);
+
+	while(1) {
+		ret = sg_give_next_adr(&idx, buf, buf_size, initialize);
+		initialize = 0;
+		if (ret <= 0)
+	break;
+		if (burn_drive_is_banned(buf))
+	continue; 
+		sg_obtain_scsi_adr(buf, &i_bus_no, &i_host_no,
+				&i_channel_no, &i_target_no, &i_lun_no);
+		enumerate_common(buf,
+				i_bus_no, i_host_no, i_channel_no,
+				i_target_no, i_lun_no);
+	}
+	sg_give_next_adr(&idx, buf, buf_size, -1);
+	ret = 1;
+ex:;
+	BURN_FREE_MEM(buf);
+	return ret;
+}
+
+
+/** Tells whether libburn has the given drive in use or exclusively reserved.
+    If it is "open" then libburn will eventually call sg_release() on it when
+    it is time to give up usage resp. reservation.
+*/
+/** Published as burn_drive.drive_is_open() */
+int sg_drive_is_open(struct burn_drive * d)
+{
+	return (d->fd != -1);
+}
+
+
+/** Opens the drive for SCSI commands and - if burn activities are prone
+    to external interference on your system - obtains an exclusive access lock
+    on the drive. (Note: this is not physical tray locking.)
+    A drive that has been opened with sg_grab() will eventually be handed
+    over to sg_release() for closing and unreserving. 
+*/  
+int sg_grab(struct burn_drive *d)
+{
+	char *msg = NULL;
+	int os_errno, ret;
+	struct dk_cinfo cinfo;
+
+	BURN_ALLOC_MEM(msg, char, 4096);
+
+	if (d->fd != -1) {
+		d->released = 0;
+		{ret = 1; goto ex;}
+	}
+	d->fd = open(d->devname, O_RDONLY | O_NDELAY);
+	if (d->fd == -1) {
+		os_errno = errno;
+		sprintf(msg, "Could not grab drive '%s'", d->devname);
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020003,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			msg, os_errno, 0);
+		{ret = 0; goto ex;}
+	}
+	ret = ioctl(d->fd, DKIOCINFO, &cinfo);
+	if (ret < 0)
+		goto revoke;
+	if (cinfo.dki_ctype != DKC_CDROM)
+		goto revoke;
+
+	/* >>> obtain eventual locks */;
+
+	d->released = 0;
+	{ret = 1; goto ex;}
+revoke:;
+	sprintf(msg, "Could not grab drive '%s'. Not a CDROM device.",
+		 d->devname);
+	libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020003,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			msg, 0, 0);
+	ret = 0;
+ex:;
+	BURN_FREE_MEM(msg);
+	return ret;
+}
+
+
+/** PORTING: Is mainly about the call to sg_close_drive() and whether it
+             implements the demanded functionality.
+*/
+/** Gives up the drive for SCSI commands and releases eventual access locks.
+    (Note: this is not physical tray locking.) 
+*/
+int sg_release(struct burn_drive *d)
+{
+	if (d->fd < 0)
+		return 0;
+	sg_close_drive(d);
+	return 0;
+}
+
+
+/** Sends a SCSI command to the drive, receives reply and evaluates wether
+    the command succeeded or shall be retried or finally failed.
+    Returned SCSI errors shall not lead to a return value indicating failure.
+    The callers get notified by c->error. An SCSI failure which leads not to
+    a retry shall be notified via scsi_notify_error().
+    The Libburn_log_sg_commandS facility might be of help when problems with
+    a drive have to be examined. It shall stay disabled for normal use.
+    @return: 1 success , <=0 failure
+*/
+int sg_issue_command(struct burn_drive *d, struct command *c)
+{
+	int i, timeout_ms, ret, key, asc, ascq, done = 0, sense_len;
+	time_t start_time;
+	struct uscsi_cmd cgc;
+	char msg[80];
+        static FILE *fp = NULL;
+
+	c->error = 0;
+	memset(c->sense, 0, sizeof(c->sense));
+	if (d->fd == -1)
+		return 0;
+
+	if (burn_sg_log_scsi & 1) {
+		if (fp == NULL) {
+			fp= fopen("/tmp/libburn_sg_command_log", "a");
+			fprintf(fp,
+			    "\n-----------------------------------------\n");
+		}
+	}
+	if (burn_sg_log_scsi & 3)
+		scsi_log_cmd(c,fp,0);
+
+	memset (&cgc, 0, sizeof (struct uscsi_cmd));
+	/* No error messages, no retries,
+           do not execute with other commands, request sense data
+	*/
+	cgc.uscsi_flags = USCSI_SILENT | USCSI_DIAGNOSE | USCSI_ISOLATE
+				| USCSI_RQENABLE;
+	cgc.uscsi_timeout = 200;
+	cgc.uscsi_cdb = (caddr_t) c->opcode;
+	cgc.uscsi_bufaddr = (caddr_t) c->page->data;
+	if (c->dir == TO_DRIVE) {
+		cgc.uscsi_flags |= USCSI_WRITE;
+		cgc.uscsi_buflen = c->page->bytes;
+	} else if (c->dir == FROM_DRIVE) {
+		cgc.uscsi_flags |= USCSI_READ;
+		if (c->dxfer_len >= 0)
+			cgc.uscsi_buflen = c->dxfer_len;
+		else
+			cgc.uscsi_buflen = BUFFER_SIZE;
+		/* touch page so we can use valgrind */
+		memset(c->page->data, 0, BUFFER_SIZE);
+	} else {
+		cgc.uscsi_buflen = 0;
+	}
+	cgc.uscsi_cdblen  = c->oplen;
+	cgc.uscsi_rqlen = sizeof(c->sense);
+	cgc.uscsi_rqbuf = (caddr_t) c->sense;
+
+	/* retry-loop */
+	start_time = time(NULL);
+	timeout_ms = 200000;
+	for(i = 0; !done; i++) {
+
+		ret = ioctl(d->fd, USCSICMD, &cgc);
+
+		/* For cgc.uscsi_status see SAM-3 5.3.1, Table 22
+		   0 = GOOD , 2 = CHECK CONDITION : Sense Data are delivered
+		   8 = BUSY
+		*/
+		if (ret != 0 && cgc.uscsi_status != 2) {
+			sprintf(msg,
+		"Failed to transfer command to drive. (uscsi_status = 0x%X)",
+				(unsigned int) cgc.uscsi_status),
+			libdax_msgs_submit(libdax_messenger,
+				d->global_index, 0x0002010c,
+				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+				msg, errno, 0);
+			sg_close_drive(d);
+			d->released = 1;
+			d->busy = BURN_DRIVE_IDLE;
+			c->error = 1;
+			return -1;
+		}
+
+
+		/* >>> Should replace "18" by realistic sense length.
+		       What's about following older remark ?
+		*/
+		/* >>> valid sense:  cgc.uscsi_rqlen - cgc.uscsi_rqresid */;
+
+		spc_decode_sense(c->sense, 0, &key, &asc, &ascq);
+		if (key || asc || ascq)
+			sense_len = 18;
+		else
+			sense_len = 0;
+		done = scsi_eval_cmd_outcome(d, c, fp, c->sense, sense_len, 0,
+						start_time, timeout_ms, i, 2);
+					
+	} /* end of retry-loop */
+
+	return 1;
+}
+
+
+/** Tries to obtain SCSI address parameters.
+    @return  1 is success , 0 is failure
+*/
+int sg_obtain_scsi_adr(char *path, int *bus_no, int *host_no, int *channel_no,
+                       int *target_no, int *lun_no)
+{
+	int ret;
+
+	/* Try to guess from path */
+	if (strncmp("/dev/rdsk/", path, 10) == 0) {
+		ret = decode_btl_solaris(path + 10,
+					bus_no, target_no, lun_no, 0);
+		if (ret > 0) {
+			*host_no = *bus_no;
+			*channel_no = 0;
+			return 1;
+		}
+	}
+	*bus_no = *host_no = *channel_no = *target_no = *lun_no = -1;
+
+	/* >>> Could need a ioctl which gives SCSI numbers */;
+
+	return (0);
+}
+
+
+/** Tells wether a text is a persistent address as listed by the enumeration
+    functions.
+*/
+
+#ifndef NIX
+
+int sg_is_enumerable_adr(char* path)
+{
+	int ret;
+	int bus_no, target_no, lun_no;
+	struct stat stbuf;
+
+	if (strncmp("/dev/rdsk/", path, 10) != 0)
+		return 0;
+	ret = decode_btl_solaris(path + 10, &bus_no, &target_no, &lun_no, 0);
+	if (ret <= 0)
+		return 0;
+	if (stat(path, &stbuf) == -1)
+		return 0;
+	return 1;
+}
+
+#else /* ! NIX */
+
+int sg_is_enumerable_adr(char* adr)
+{
+	burn_drive_enumerator_t idx;
+	int initialize = 1, ret;
+	char buf[64];
+
+	while(1) {
+		ret = sg_give_next_adr(&idx, buf, sizeof(buf), initialize);
+		initialize = 0;
+		if (ret <= 0)
+	break;
+		if (strcmp(adr, buf) == 0) {
+			sg_give_next_adr(&idx, buf, sizeof(buf), -1);
+			return 1;
+		}
+	}
+	sg_give_next_adr(&idx, buf, sizeof(buf), -1);
+	return (0);
+}
+#endif /* NIX */
+
+
+
+
+/* Return 1 if the given path leads to a regular file or a device that can be
+   seeked, read, and possibly written with 2 kB granularity. 
+*/
+int burn_os_is_2k_seekrw(char *path, int flag)
+{
+	struct stat stbuf;
+
+	if (stat(path, &stbuf) == -1)
+		return 0;
+	if (S_ISREG(stbuf.st_mode))
+		return 1;
+	if (S_ISBLK(stbuf.st_mode))
+		return 1;
+	return 0;
+}
+
+
+/** Estimate the potential payload capacity of a file address.
+    @param path  The address of the file to be examined. If it does not
+                 exist yet, then the directory will be inquired.
+    @param bytes The pointed value gets modified, but only if an estimation is
+                 possible.
+    @return      -2 = cannot perform necessary operations on file object
+                 -1 = neither path nor dirname of path exist
+                  0 = could not estimate size capacity of file object
+                  1 = estimation has been made, bytes was set
+*/
+int burn_os_stdio_capacity(char *path, off_t *bytes)
+{
+	struct stat stbuf;
+	int ret;
+
+#ifdef Libburn_os_has_statvfS
+	struct statvfs vfsbuf;
+#endif
+
+	char *testpath = NULL, *cpt;
+	off_t add_size = 0;
+
+	BURN_ALLOC_MEM(testpath, char, 4096);
+
+	testpath[0] = 0;
+	if (stat(path, &stbuf) == -1) {
+		strcpy(testpath, path);
+		cpt = strrchr(testpath, '/');
+		if(cpt == NULL)
+			strcpy(testpath, ".");
+		else if(cpt == testpath)
+			testpath[1] = 0;
+		else
+			*cpt = 0;
+		if (stat(testpath, &stbuf) == -1)
+			{ret = -1; goto ex;}
+
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		int open_mode = O_RDONLY, fd;
+
+		fd = open(path, open_mode);
+		if (fd == -1)
+			{ret = -2; goto ex;}
+		*bytes = lseek(fd, 0, SEEK_END);
+		close(fd);
+		if (*bytes == -1) {
+			*bytes = 0;
+			{ret = 0; goto ex;}
+		}
+
+	} else if(S_ISREG(stbuf.st_mode)) {
+		add_size = stbuf.st_blocks * (off_t) 512;
+		strcpy(testpath, path);
+	} else
+		{ret = 0; goto ex;}
+
+	if (testpath[0]) {	
+
+#ifdef Libburn_os_has_statvfS
+
+		if (statvfs(testpath, &vfsbuf) == -1)
+			{ret = -2; goto ex;}
+		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
+						(off_t) vfsbuf.f_bavail;
+
+#else /* Libburn_os_has_statvfS */
+
+		{ret = 0; goto ex;}
+
+#endif /* ! Libburn_os_has_stavtfS */
+
+	}
+	ret = 1;
+ex:;
+	BURN_FREE_MEM(testpath);
+	return ret;
+}
+
+
+/* ts A91122 : an interface to open(O_DIRECT) or similar OS tricks. */
+
+#ifdef Libburn_read_o_direcT
+
+	/* No special O_DIRECT-like precautions are implemented here */
+
+#endif /* Libburn_read_o_direcT */
+
+
+int burn_os_open_track_src(char *path, int open_flags, int flag)
+{
+	int fd;
+
+	fd = open(path, open_flags);
+	return fd;
+}
+
+
+void *burn_os_alloc_buffer(size_t amount, int flag)
+{
+	void *buf = NULL;
+
+	buf = calloc(1, amount);
+	return buf;
+}
+
+
+int burn_os_free_buffer(void *buffer, size_t amount, int flag)
+{
+	if (buffer == NULL)
+		return 0;
+	free(buffer);
+	return 1;
+}
+

libburn/sg.c

@@ -1,17 +1,79 @@
 
 /* sg.c
    Switcher for operating system dependent transport level modules of libburn.
-   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
+   Copyright (C) 2009 - 2010 Thomas Schmitt <scdbackup@gmx.net>, 
+   provided under GPLv2+
 */
 
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#undef HAVE_CONFIG_H
+#endif
 
-#ifdef __FreeBSD__
 
-#include "sg-freebsd.c"
+#ifdef Libburn_use_sg_dummY
+
+#include "sg-dummy.c"
 
 #else
+#ifdef Libburn_use_libcdiO
+
+#include "sg-libcdio.c"
+
+#else
+#ifdef __FreeBSD__
+
+#ifdef Libburn_use_sg_freebsd_porT
+#include "sg-freebsd-port.c"
+#else
+#include "sg-freebsd.c"
+#endif
+
+#else
+#ifdef __FreeBSD_kernel__
+
+#ifdef Libburn_use_sg_freebsd_porT
+#include "sg-freebsd-port.c"
+#else
+#include "sg-freebsd.c"
+#endif
+
+#else
+#ifdef __linux
 
 #include "sg-linux.c"
 
-#endif
+#else
+#ifdef __sun
+
+#include "sg-solaris.c"
+
+#else
+
+/* The dummy adapter formally fulfills the expectations of libburn towards
+   its SCSI command transport. It will show no drives and perform no SCSI
+   commands.
+   libburn will then be restricted to using its stdio pseudo drives.
+*/
+static int intentional_compiler_warning(void)
+{
+ int INTENTIONAL_COMPILER_WARNING_;
+ int Cannot_recognize_GNU_Linux_nor_FreeBSD_nor_Solaris_;
+ int Have_to_use_dummy_MMC_transport_adapter_;
+ int This_libburn_will_not_be_able_to_operate_on_real_CD_drives;
+ int Have_to_use_dummy_MMC_transport_adapter;
+ int Cannot_recognize_GNU_Linux_nor_FreeBSD_nor_Solaris;
+ int INTENTIONAL_COMPILER_WARNING;
+
+ return(0);
+}
+
+#include "sg-dummy.c"
+
+#endif /* ! __sun */
+#endif /* ! __linux */
+#endif /* ! __FreeBSD_kernel__ */
+#endif /* ! __FreeBSD__ */
+#endif /* ! Libburn_use_libcdiO */
+#endif /* ! Libburn_use_sg_dummY */
 

libburn/sg.h

@@ -1,5 +1,8 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
+*/
+
 #ifndef __SG
 #define __SG
 
@@ -31,4 +34,51 @@ int scsi_enumerate_drives(void);
 
 int sg_drive_is_open(struct burn_drive * d);
 
+int burn_os_is_2k_seekrw(char *path, int flag);
+
+int burn_os_stdio_capacity(char *path, off_t *bytes);
+
+/* ts A91227 */
+/** Returns the id string of the SCSI transport adapter and eventually
+    needed operating system facilities.
+    This call is usable even if sg_initialize() was not called yet. In that
+    case a preliminary constant message might be issued if detailed info is
+    not available yet.
+    @param msg   returns id string
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_id_string(char msg[1024], int flag);
+
+/* ts A91225 */
+/** Performs global initialization of the SCSI transport adapter and eventually
+    needed operating system facilities. Checks for compatibility supporting
+    software components.
+    @param msg   returns ids and/or error messages of eventual helpers
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure 
+*/      
+int sg_initialize(char msg[1024], int flag);
+
+/* ts A91227 */
+/** Performs global finalization of the SCSI transport adapter and eventually
+    needed operating system facilities. Releases globally aquired resources.
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_shutdown(int flag);
+
+/* ts A91227 */
+/** Finalizes BURN_OS_TRANSPORT_DRIVE_ELEMENTS, the components of
+    struct burn_drive which are defined in os-*.h.
+    The eventual initialization of those components was made underneath
+    scsi_enumerate_drives().
+    This will be called when a burn_drive gets disposed.
+    @param d     the drive to be finalized
+    @param flag  unused yet, submit 0
+    @return      1 = success, <=0 = failure
+*/
+int sg_dispose_drive(struct burn_drive *d, int flag);
+
+
 #endif /* __SG */

libburn/source.c

@@ -1,5 +1,15 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
+
 #include <stdlib.h>
 #include <string.h>
 #include "libburn.h"
@@ -18,8 +28,6 @@ void burn_source_free(struct burn_source *src)
 enum burn_source_status burn_track_set_source(struct burn_track *t,
 					      struct burn_source *s)
 {
-	if (!s->read)
-		return BURN_SOURCE_FAILED;
 	s->refcount++;
 	t->source = s;
 
@@ -34,6 +42,36 @@ struct burn_source *burn_source_new(void)
 	struct burn_source *out;
 
 	out = calloc(1, sizeof(struct burn_source));
+
+	/* ts A70825 */
+	if (out == NULL)
+		return NULL;
+	memset((char *) out, 0, sizeof(struct burn_source));
+
 	out->refcount = 1;
 	return out;
 }
+
+
+/* ts A71223 */
+int burn_source_cancel(struct burn_source *src)
+{
+	if(src->read == NULL)
+		if(src->version > 0)
+			if(src->cancel != NULL)
+				src->cancel(src);
+	return 1;
+}
+
+
+/* ts B00922 */
+int burn_source_read(struct burn_source *src, unsigned char *buffer, int size)
+{
+	int ret;
+
+	if (src->read != NULL)
+		 ret = src->read(src, buffer, size);
+	else
+		 ret = src->read_xt(src, buffer, size);
+	return ret;
+}

libburn/source.h

@@ -5,4 +5,8 @@
 
 struct burn_source *burn_source_new(void);
 
+int burn_source_cancel(struct burn_source *src);
+
+int burn_source_read(struct burn_source *src, unsigned char *buffer, int size);
+
 #endif /*__SOURCE*/

libburn/spc.h

@@ -1,5 +1,11 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
 #ifndef __SPC
 #define __SPC
 
@@ -28,7 +34,8 @@ int spc_test_unit_ready(struct burn_drive *d);
 
 /* ts A70315 */
 /** Wait until the drive state becomes clear in or until max_sec elapsed */
-int spc_wait_unit_attention(struct burn_drive *d, int max_sec);
+int spc_wait_unit_attention(struct burn_drive *d, int max_sec, char *cmd_text,
+				int flag);
 
 /* ts A61021 : the spc specific part of sg.c:enumerate_common()
 */
@@ -42,7 +49,7 @@ int burn_scsi_setup_drive(struct burn_drive *d, int bus_no, int host_no,
 			int channel_no, int target_no, int lun_no, int flag);
 
 /* ts A61115 moved from sg-*.h */
-enum response { RETRY, FAIL };
+enum response { RETRY, FAIL, GO_ON };
 enum response scsi_error(struct burn_drive *, unsigned char *, int);
 
 /* ts A61122 */
@@ -55,4 +62,60 @@ enum response scsi_error_msg(struct burn_drive *d, unsigned char *sense,
 int scsi_notify_error(struct burn_drive *, struct command *c,
 			unsigned char *sense, int senselen, int flag);
 
+/* ts A70519 */
+int scsi_init_command(struct command *c, unsigned char *opcode, int oplen);
+
+/* ts A91106 */
+int scsi_show_cmd_text(struct command *c, void *fp, int flag);
+
+/* ts B11110 */
+/** Logs command (before execution). */
+int scsi_log_command(unsigned char *opcode, int oplen, int data_dir,
+                     unsigned char *data, int bytes,
+                     void *fp_in, int flag);
+
+/* ts A91218 (former sg_log_cmd ts A70518) */
+/** Legacy frontend to scsi_log_command() */
+int scsi_log_cmd(struct command *c, void *fp, int flag);
+
+/* ts B11110 */
+/** Logs outcome of a sg command.
+    @param flag  bit0 causes an error message 
+                 bit1 do not print duration
+*/
+int scsi_log_reply(unsigned char *opcode, int data_dir, unsigned char *data,
+                   int dxfer_len, void *fp_in, unsigned char sense[18],
+                   int sense_len, int duration, int flag);
+
+/* ts A91221 (former sg_log_err ts A91108) */
+/** Legacy frontend to scsi_log_reply().
+    @param flag  bit0 causes an error message
+                 bit1 do not print duration
+*/
+int scsi_log_err(struct command *c, void *fp, unsigned char sense[18], 
+                 int sense_len, int duration, int flag);
+
+/* ts B00728 */
+int spc_decode_sense(unsigned char *sense, int senselen,
+                     int *key, int *asc, int *ascq);
+
+/* ts B00808 */
+/** Evaluates outcome of a single SCSI command, eventually logs sense data,
+    and issues DEBUG error message in case the command is evaluated as done.
+    @param flag   bit1 = do not print duration
+    @return 0 = not yet done , 1 = done , -1 = error
+*/
+int scsi_eval_cmd_outcome(struct burn_drive *d, struct command *c, void *fp_in,
+                        unsigned char *sense, int sense_len,
+                        int duration, time_t start_time, int timeout_ms,
+			int loop_count, int flag);
+
+/* The waiting time before eventually retrying a failed SCSI command.
+   Before each retry wait Libburn_scsi_retry_incR longer than with
+   the previous one.
+*/
+#define Libburn_scsi_retry_usleeP 100000
+#define Libburn_scsi_retry_incR   100000
+
+
 #endif /*__SPC*/

libburn/structure.c

@@ -1,4 +1,13 @@
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 /* ts A61008 */
 /* #include <a ssert.h> */
 
@@ -9,6 +18,7 @@
 #include "structure.h"
 #include "write.h"
 #include "debug.h"
+#include "init.h"
 
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
@@ -24,7 +34,7 @@ extern struct libdax_msgs *libdax_messenger;
 		return 0;\
 	if (pos == BURN_POS_END)\
 		pos = TO->NEW##s;\
-	if (pos > TO->NEW##s)\
+	if ((int) pos > TO->NEW##s)\
 		return 0;\
 \
 	tmp = realloc(TO->NEW, sizeof(struct NEW *) * (TO->NEW##s + 1));\
@@ -40,6 +50,8 @@ struct burn_disc *burn_disc_create(void)
 {
 	struct burn_disc *d;
 	d = calloc(1, sizeof(struct burn_disc));
+	if (d == NULL) /* ts A70825 */
+		return NULL;
 	d->refcnt = 1;
 	d->sessions = 0;
 	d->session = NULL;
@@ -64,6 +76,8 @@ struct burn_session *burn_session_create(void)
 {
 	struct burn_session *s;
 	s = calloc(1, sizeof(struct burn_session));
+	if (s == NULL) /* ts A70825 */
+		return NULL;
 	s->refcnt = 1;
 	s->tracks = 0;
 	s->track = NULL;
@@ -100,10 +114,36 @@ int burn_disc_add_session(struct burn_disc *d, struct burn_session *s,
 	return 1;
 }
 
+
+/* ts A81202: this function was in the API but not implemented.
+*/
+int burn_disc_remove_session(struct burn_disc *d, struct burn_session *s)
+{
+	int i, skip = 0;
+
+	if (d->session == NULL)
+		return 0;
+	for (i = 0; i < d->sessions; i++) {
+		if (s == d->session[i]) {
+			skip++;
+	continue;
+		}
+		d->session[i - skip] = d->session[i];
+	}
+	if (!skip)
+		return 0;
+	burn_session_free(s);
+	d->sessions--;
+	return 1;
+}
+
+
 struct burn_track *burn_track_create(void)
 {
 	struct burn_track *t;
 	t = calloc(1, sizeof(struct burn_track));
+	if (t == NULL) /* ts A70825 */
+		return NULL;
 	t->refcnt = 1;
 	t->indices = 0;
 	t->offset = 0;
@@ -131,6 +171,8 @@ struct burn_track *burn_track_create(void)
 	/* ts A61031 */
 	t->open_ended = 0;
 	t->track_data_done = 0;
+	/* ts B10103 */
+	t->end_on_premature_eoi = 0;
 
 	t->postgap = 0;
 	t->pregap1 = 0;
@@ -200,8 +242,12 @@ int burn_session_remove_track(struct burn_session *s, struct burn_track *t)
 void burn_structure_print_disc(struct burn_disc *d)
 {
 	int i;
+	char msg[40];
 
-	burn_print(12, "This disc has %d sessions\n", d->sessions);
+	sprintf(msg, "This disc has %d sessions", d->sessions);
+	libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
+			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+			msg, 0, 0);
 	for (i = 0; i < d->sessions; i++) {
 		burn_structure_print_session(d->session[i]);
 	}
@@ -209,16 +255,25 @@ void burn_structure_print_disc(struct burn_disc *d)
 void burn_structure_print_session(struct burn_session *s)
 {
 	int i;
+	char msg[40];
 
-	burn_print(12, "    Session has %d tracks\n", s->tracks);
+	sprintf(msg, "    Session has %d tracks", s->tracks);
+	libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
+			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+			msg, 0, 0);
 	for (i = 0; i < s->tracks; i++) {
 		burn_structure_print_track(s->track[i]);
 	}
 }
 void burn_structure_print_track(struct burn_track *t)
 {
-	burn_print(12, "(%p)  track size %d sectors\n", t,
-		   burn_track_get_sectors(t));
+	char msg[80];
+
+	sprintf(msg, "        track size %d sectors",
+		burn_track_get_sectors(t));
+	libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
+			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+			msg, 0, 0);
 }
 
 void burn_track_define_data(struct burn_track *t, int offset, int tail,
@@ -228,13 +283,14 @@ void burn_track_define_data(struct burn_track *t, int offset, int tail,
 	int burn_sector_length(int tracktype);
 	unsigned char ctladr;
 	int form = -1; /* unchanged form will be considered an error too */
+	char msg[80];
 
 	type_to_form(mode, &ctladr, &form);
 	if (form == -1 || burn_sector_length(mode) <= 0) {
-		char msg[160];
 
-		sprintf(msg, "Attempt to set track mode to unusable value %d",
-			mode);
+		sprintf(msg,
+			"Attempt to set track mode to unusable value 0x%X",
+			(unsigned int) mode);
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020115,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			msg, 0, 0);
@@ -251,13 +307,23 @@ void burn_track_define_data(struct burn_track *t, int offset, int tail,
 /* ts A61024 */
 int burn_track_set_byte_swap(struct burn_track *t, int swap_source_bytes)
 {
-	if(swap_source_bytes!=0 && swap_source_bytes!=1)
+	if (swap_source_bytes != 0 && swap_source_bytes != 1)
 		return 0;
 	t->swap_source_bytes = swap_source_bytes;
 	return 1;
 }
 
 
+/* ts A90911 : API */
+int burn_track_set_cdxa_conv(struct burn_track *t, int value)
+{
+	if (value < 0 || value > 1)
+		return 0;
+	t->cdxa_conversion = value;
+	return 1;
+}
+
+
 void burn_track_set_isrc(struct burn_track *t, char *country, char *owner,
 			 unsigned char year, unsigned int serial)
 {
@@ -324,15 +390,27 @@ void burn_track_clear_isrc(struct burn_track *t)
 int burn_track_get_sectors(struct burn_track *t)
 {
 	/* ts A70125 : was int */
-	off_t size;
+	off_t size = 0;
 	int sectors, seclen;
 
 	seclen = burn_sector_length(t->mode);
-	size = t->offset + t->source->get_size(t->source) + t->tail;
+
+	if (t->cdxa_conversion == 1)
+		/* ts A90911 : will read blocks of 2056 bytes and write 2048 */
+		seclen += 8;
+
+	if (t->source != NULL)                /* ts A80808 : mending sigsegv */
+		size = t->offset + t->source->get_size(t->source) + t->tail;
+	else if(t->entry != NULL) {
+		/* ts A80808 : all burn_toc_entry of track starts should now
+			have (extensions_valid & 1), even those from CD.
+		*/
+		if (t->entry->extensions_valid & 1)
+			size = ((off_t) t->entry->track_blocks) * (off_t) 2048;
+	}
 	sectors = size / seclen;
 	if (size % seclen)
 		sectors++;
-	burn_print(1, "%d sectors of %d length\n", sectors, seclen);
 	return sectors;
 }
 
@@ -382,14 +460,16 @@ int burn_track_set_fillup(struct burn_track *t, int fill_up_media)
 int burn_track_apply_fillup(struct burn_track *t, off_t max_size, int flag)
 {
 	int max_sectors, ret = 2;
-	char msg[160];
+	char msg[80];
 
 	if (t->fill_up_media <= 0)
 		return 2;
 	max_sectors = max_size / 2048;
 	if (burn_track_get_sectors(t) < max_sectors || (flag & 1)) {
 		sprintf(msg, "Setting total track size to %ds (payload %ds)\n",
-		    max_sectors, (int) (t->source->get_size(t->source)/2048));
+			max_sectors & 0x7fffffff,
+			(int) ((t->source->get_size(t->source) / 2048)
+				& 0x7fffffff));
 		libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
 			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
 			msg, 0, 0);
@@ -462,6 +542,7 @@ int burn_session_get_sectors(struct burn_session *s)
 	return sectors;
 }
 
+
 int burn_disc_get_sectors(struct burn_disc *d)
 {
 	int sectors = 0, i;
@@ -509,3 +590,88 @@ int burn_session_get_hidefirst(struct burn_session *session)
 {
 	return session->hidefirst;
 }
+
+
+/* ts A80808 : Enhance CD toc to DVD toc */
+int burn_disc_cd_toc_extensions(struct burn_disc *d, int flag)
+{
+	int sidx= 0, tidx= 0, ret;
+	struct burn_toc_entry *entry, *prev_entry= NULL;
+	/* ts A81126 : ticket 146 : There was a SIGSEGV in here */
+	char *msg_data = NULL, *msg;
+
+	BURN_ALLOC_MEM(msg_data, char, 321);
+	strcpy(msg_data,
+		"Damaged CD table-of-content detected and truncated.");
+	strcat(msg_data, " In burn_disc_cd_toc_extensions: ");
+        msg = msg_data + strlen(msg_data);
+	if (d->session == NULL) {
+		strcpy(msg, "d->session == NULL");
+		goto failure;
+	}
+	for (sidx = 0; sidx < d->sessions; sidx++) {
+		if (d->session[sidx] == NULL) {
+			sprintf(msg, "d->session[%d of %d] == NULL",
+				sidx, d->sessions);
+			goto failure;
+		}
+		if (d->session[sidx]->track == NULL) {
+			sprintf(msg, "d->session[%d of %d]->track == NULL",
+				sidx, d->sessions);
+			goto failure;
+		}
+		if (d->session[sidx]->leadout_entry == NULL) {
+			sprintf(msg,
+				" Session %d of %d: Leadout entry missing.",
+			  	sidx, d->sessions);
+			goto failure;
+		}
+		for (tidx = 0; tidx < d->session[sidx]->tracks + 1; tidx++) {
+			if (tidx < d->session[sidx]->tracks) {
+				if (d->session[sidx]->track[tidx] == NULL) {
+					sprintf(msg,
+			  "d->session[%d of %d]->track[%d of %d] == NULL",
+			   sidx, d->sessions, tidx,  d->session[sidx]->tracks);
+					goto failure;
+				}
+				entry = d->session[sidx]->track[tidx]->entry;
+				if (entry == NULL) {
+					sprintf(msg,
+			  "session %d of %d, track %d of %d, entry == NULL",
+			  			sidx, d->sessions, tidx,
+						d->session[sidx]->tracks);
+					goto failure;
+				}
+			} else
+				entry = d->session[sidx]->leadout_entry;
+			entry->session_msb = 0;
+			entry->point_msb = 0;
+			entry->start_lba = burn_msf_to_lba(entry->pmin,
+						entry->psec, entry->pframe);
+			if (tidx > 0) {
+				prev_entry->track_blocks =
+					entry->start_lba
+					- prev_entry->start_lba;
+				prev_entry->extensions_valid |= 1;
+			}
+			if (tidx == d->session[sidx]->tracks) {
+				entry->session_msb = 0;
+				entry->point_msb = 0;
+				entry->track_blocks = 0;
+				entry->extensions_valid |= 1;
+			}
+			prev_entry = entry;
+		}
+	}
+	{ret = 1; goto ex;}
+failure:
+	libdax_msgs_submit(libdax_messenger, -1, 0x0002015f,
+		LIBDAX_MSGS_SEV_MISHAP, LIBDAX_MSGS_PRIO_HIGH, msg_data, 0, 0);
+	d->sessions= sidx;
+	ret = 0;
+ex:;
+	BURN_FREE_MEM(msg_data);
+	return ret;
+}
+
+

libburn/structure.h

@@ -1,3 +1,9 @@
+
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
 #ifndef BURN__STRUCTURE_H
 #define BURN__STRUCTURE_H
 
@@ -49,6 +55,14 @@ struct burn_track
 	int open_ended;
 	/** End of open ended track flag : offset+payload+tail are delivered */
 	int track_data_done;
+	/* ts B10103 */
+	/** End track writing on premature End-of-input if source is of
+	    defined length.
+	    0= normal operation in case of eoi
+	    1= be ready to end track writing on eoi
+	    2= eoi was encountered with previously set value of 1
+	*/
+	int end_on_premature_eoi;
 
 	/** The audio/data mode for the entry. Derived from control and
 	    possibly from reading the track's first sector. */
@@ -64,6 +78,10 @@ struct burn_track
 	/* ts A61024 */
 	/** Byte swapping on source data stream : 0=none , 1=pairwise */
 	int swap_source_bytes;
+
+	/* ts A90910 : conversions from CD XA prepared input */
+	int cdxa_conversion; /* 0=none, 1=remove -xa1 headers (first 8 bytes)*/
+
 };
 
 struct burn_session
@@ -109,4 +127,8 @@ int burn_track_apply_fillup(struct burn_track *t, off_t max_size, int flag);
 off_t burn_track_get_default_size(struct burn_track *t);
 
 
+/* ts A80808 : Enhance CD toc to DVD toc */
+int burn_disc_cd_toc_extensions(struct burn_disc *d, int flag);
+
+
 #endif /* BURN__STRUCTURE_H */

libburn/toc.c

@@ -1,5 +1,15 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2011 - 2011 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 /* ts A61008 */
 /* #include <a ssert.h> */
 
@@ -11,6 +21,7 @@
 #include "libburn.h"
 #include "sector.h"
 #include "options.h"
+#include "init.h"
 
 #if 0
 static void write_clonecd2(volatile struct toc *toc, int f);
@@ -94,17 +105,14 @@ static void write_clonecd2(volatile struct toc *toc, int f)
 
 void toc_find_modes(struct burn_drive *d)
 {
-	struct burn_read_opts o;
-	int lba;
 	int i, j;
-	struct buffer mem;
+	struct buffer *mem = NULL;
 	struct burn_toc_entry *e;
 
-	/* ts A61008 : to be prevented on the higher levels */
-	/* a ssert(d->busy); */
+/* ts A70519 : the code which needs this does not work with GNU/Linux 2.4 USB
+	int lba;
+	struct burn_read_opts o;
 
-	mem.bytes = 0;
-	mem.sectors = 1;
 	o.raw = 1;
 	o.c2errors = 0;
 	o.subcodes_audio = 1;
@@ -113,24 +121,38 @@ void toc_find_modes(struct burn_drive *d)
 	o.report_recovered_errors = 0;
 	o.transfer_damaged_blocks = 1;
 	o.hardware_error_retries = 1;
+*/
+
+	BURN_ALLOC_MEM_VOID(mem, struct buffer, 1);
+
+	mem->bytes = 0;
+	mem->sectors = 1;
 
 	for (i = 0; i < d->disc->sessions; i++)
 		for (j = 0; j < d->disc->session[i]->tracks; j++) {
 			struct burn_track *t = d->disc->session[i]->track[j];
 
 			e = t->entry;
-			if (!e)
-				lba = 0;
-			else
-				lba = burn_msf_to_lba(e->pmin, e->psec,
-						      e->pframe);
 /* XXX | in the subcodes if appropriate! */
 			if (e && !(e->control & 4)) {
 				t->mode = BURN_AUDIO;
 			} else {
-				mem.sectors = 1;
-				d->read_sectors(d, lba, mem.sectors, &o, &mem);
-				t->mode = sector_identify(mem.data);
+
+				t->mode = BURN_MODE1;
+/* ts A70519 : this does not work with GNU/Linux 2.4 USB because one cannot
+               predict the exact dxfer_size without knowing the sector type.
+				if (!e)
+					lba = 0;
+				else
+					lba = burn_msf_to_lba(e->pmin, e->psec,
+							      e->pframe);
+				mem->sectors = 1;
+				d->read_sectors(d, lba, mem.sectors, &o, mem);
+				t->mode = sector_identify(mem->data);
+*/
 			}
 		}
+
+ex:
+	BURN_FREE_MEM(mem);
 }

libburn/toc.h

@@ -1,5 +1,10 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Provided under GPL version 2 or later.
+*/
+
+
 #ifndef __TOC_H
 #define __TOC_H
 

libburn/transport.h

@@ -1,5 +1,11 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
 #ifndef __TRANSPORT
 #define __TRANSPORT
 
@@ -40,7 +46,9 @@ struct buffer
 	   Added 4096 bytes reserve against possible buffer overflows.
 	   (Changed in sector.c buffer flush test from >= to > BUFFER_SIZE .
 	    This can at most cause a 1 sector overlap. Sometimes an offset
-	    of 16 byte is applied to the output data (in some RAW mode). ) */
+	    of 16 byte is applied to the output data (in some RAW mode). )
+	    burn_write_opts.cdxa_conversion can imply an offset of 8 bytes.
+	 */
 	unsigned char data[BUFFER_SIZE + 4096];
 	int sectors;
 	int bytes;
@@ -51,6 +59,7 @@ struct command
 	unsigned char opcode[16];
 	int oplen;
 	int dir;
+	int dxfer_len;
 	unsigned char sense[128];
 	int error;
 	int retry;
@@ -113,13 +122,23 @@ struct burn_format_descr {
 	off_t size;
 
 	/* the Type Dependent Parameter (usually the write alignment size) */
-	unsigned tdp;
+	unsigned int tdp;
 };
 
 
 /** Gets initialized in enumerate_common() and burn_drive_register() */
 struct burn_drive
 {
+	/* ts A70902:
+		0=null-emulation
+		1=MMC drive ,
+		2=stdio random read-write
+		3=stdio sequential write-only
+                4=stdio random read-only
+                5=stdio random write-only
+	*/
+	int drive_role;
+
 	int bus_no;
 	int host;
 	int id;
@@ -152,6 +171,11 @@ struct burn_drive
 	char current_profile_text[80];
 	int current_is_cd_profile;
 	int current_is_supported_profile;
+	/* ts A90603 */
+	int current_is_guessed_profile;
+	/* ts A90815 */
+	unsigned char all_profiles[256];
+	int num_profiles;
 
 	/* ts A70128 : MMC-to-MMC feature info from 46h for DVD-RW.
            Quite internal. Regard as opaque :)
@@ -162,6 +186,19 @@ struct burn_drive
 	/* Link Size item number 0 from feature 0021h descriptor */
 	int current_feat21h_link_size;
 
+	/* Flags from feature 0023h for formatting BD mmc5r03c.pdf 5.3.13 
+           Byte 4 BD-RE:
+             bit0= Cert   format 30h sub-type 10b
+             bit1= QCert  format 30h sub-type 11b
+             bit2= Expand format 01h
+             bit3= RENoSA format 31h
+           Byte 8 BD-R:
+             bit0= RRM    format 32h sub-type 10b
+        */
+	int current_feat23h_byte4;
+	int current_feat23h_byte8;
+
+
 	/* Flags from feature 002Fh feature descriptor mmc5r03c.pdf 5.3.25 :
 	     bit1= DVD-RW supported
 	     bit2= Test Write available
@@ -171,17 +208,47 @@ struct burn_drive
 	*/
 	int current_feat2fh_byte4;
 
-	/* ts A70114 : wether a DVD-RW media holds an incomplete session
+	/* ts B10524 : whether the damage bit was set for the future track.
+	               bit0= damage bit , bit1= nwa valid bit
+	*/
+	int next_track_damaged;
+
+	/* ts A70114 : whether a DVD-RW media holds an incomplete session
 	               (which could need closing after write) */
 	int needs_close_session;
+	/* ts A71003 : whether a random write operation was done and no
+	               synchronize chache has happened yet */
+	int needs_sync_cache;
+
+	/* ts A80412 : whether to use WRITE12 with Streaming bit set
+	               rather than WRITE10. Speeds up DVD-RAM. Might help
+	               with BD-RE */
+	int do_stream_recording;
+
+        /* ts A90227 : the LBA where stream recording shall start.
+                       Writing to lower LBA will be done without streaming.
+        */
+        int stream_recording_start;
 
 	/* ts A61218 from 51h READ DISC INFORMATION */
+	int last_lead_in;
+	int last_lead_out;
+	int num_opc_tables;   /* ts A91104: -1= not yet known */
 	int bg_format_status; /* 0=needs format start, 1=needs format restart*/
+	int disc_type; /* 0="CD-DA or CD-ROM", 0x10="CD-I", 0x20="CD-ROM XA" */
+	unsigned int disc_id; /* a "32 bit binary integer" */
+	char disc_bar_code[9];
+	int disc_app_code;
+	int disc_info_valid;  /* bit0= disc_type ,     bit1= disc_id ,
+				 bit2= disc_bar_code , bit3= disc_app_code
+				 bit4= URU bit is set (= unrestricted use)
+				 bit5= Erasable bit was set in reply
+			       */
 
 	/* ts A70108 from 23h READ FORMAT CAPACITY mmc5r03c.pdf 6.24 */
 	int format_descr_type;      /* 1=unformatted, 2=formatted, 3=unclear */
 	off_t format_curr_max_size;  /* meaning depends on format_descr_type */
-	unsigned format_curr_blsas;  /* meaning depends on format_descr_type */
+	unsigned int format_curr_blsas;  /* dito */
 	int best_format_type;
 	off_t best_format_size;
 
@@ -195,6 +262,8 @@ struct burn_drive
 	/* ts A61106 */
 	int silent_on_scsi_error;
 
+	int stdio_fd;
+
 	int nwa;		/* next writeable address */
 	int alba;		/* absolute lba */
 	int rlba;		/* relative lba in section */
@@ -204,9 +273,16 @@ struct burn_drive
 
 	/* ts A70131 : from 51h READ DISC INFORMATION Number of Sessions (-1)*/
 	int complete_sessions;
+	/* ts A90107 */
+	int state_of_last_session;
+
 	/* ts A70129 :
 	   from 51h READ DISC INFORMATION Last Track Number in Last Session */
 	int last_track_no;
+
+	/* ts B10730 : whether a default mode page 05 was already sent.
+	*/
+	int sent_default_page_05;
 	/* ts A70212 : from various sources : free space on media (in bytes)
 	               With CD this might change after particular write
 	               parameters have been set and nwa has been inquired.
@@ -216,6 +292,14 @@ struct burn_drive
 	/* ts A70215 : if > 0 : first lba on media that is too high for write*/
 	int media_lba_limit;
 
+	/* ts A81210 : Upper limit of readable data size,
+	               0x7fffffff = unknown
+	               0x7ffffff0 = 32 bit overflow, or unknown stdio size
+	 */
+	int media_read_capacity;
+
+	/* ts B10314 : Next Writeable Adress for drive_role == 5 */
+        int role_5_nwa;
 
 	int toc_temp;
 	struct burn_disc *disc;	/* disc structure */
@@ -223,8 +307,41 @@ struct burn_drive
 	struct buffer *buffer;
 	struct burn_progress progress;
 
+	/* To be used by mmc.c, sbc.c, spc.c for SCSI commands where the struct
+	   content surely does not have to persist while another command gets
+	   composed and executed.
+	   (Inherently, sending SCSI commands to the same drive cannot be
+	    thread-safe. But there are functions which send SCSI commands
+	    and also call other such functions. These shall use own allocated
+	    command structs and not this struct here.)
+	*/
+	struct command casual_command;
+
+	/* ts A70711 : keeping an eye on the drive buffer */
+	off_t pessimistic_buffer_free;
+	int pbf_altered;
+	int wait_for_buffer_free;
+	int nominal_write_speed;
+	unsigned int wfb_min_usec;
+	unsigned int wfb_max_usec;
+	unsigned int wfb_timeout_sec;
+	unsigned int wfb_min_percent;
+	unsigned int wfb_max_percent;
+	unsigned int pessimistic_writes;
+	unsigned int waited_writes;
+	unsigned int waited_tries;
+	unsigned int waited_usec;
+
 	volatile int cancel;
 	volatile enum burn_drive_status busy;
+
+	/* ts A70929 */
+	pid_t thread_pid;
+	int thread_pid_valid;
+	/* ts B00225 */
+	pthread_t thread_tid;
+
+
 /* transport functions */
 	int (*grab) (struct burn_drive *);
 	int (*release) (struct burn_drive *);
@@ -248,6 +365,11 @@ struct burn_drive
 	void (*eject) (struct burn_drive *);
 	void (*load) (struct burn_drive *);
 	int (*start_unit) (struct burn_drive *);
+
+	/* ts A90824 : Calming down noisy drives */
+	int (*stop_unit) (struct burn_drive *);
+	int is_stopped;
+
 	void (*read_disc_info) (struct burn_drive *);
 	void (*read_sectors) (struct burn_drive *,
 			      int start,
@@ -304,8 +426,18 @@ struct burn_drive
 	/* mmc5r03c.pdf 6.24 : get list of available formats */
 	int (*read_format_capacities) (struct burn_drive *d, int top_wanted);
 
+	/* ts A70812 */
+	/* mmc5r03c.pdf 6.15 : read data sectors (start and amount in LBA) */
+	int (*read_10) (struct burn_drive *d, int start, int amount,
+	                struct buffer *buf);
+
 };
 
 /* end of generic 'drive' data structures */
 
+/* ts A80422 : centralizing this setting for debugging purposes
+*/
+int burn_drive_set_media_capacity_remaining(struct burn_drive *d, off_t value);
+
+
 #endif /* __TRANSPORT */

libburn/util.c

@@ -1,10 +1,25 @@
+
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "../config.h"
+#endif
+
 #include <string.h>
 
 /* ts A61008 */
 /* #include <a ssert.h> */
 
 #include <stdlib.h>
-#include "../version.h"
+#include <stdio.h>
+
+/* ts A80914 : This is unneeded. Version info comes from libburn.h.
+#include "v ersion.h"
+*/
+
 #include "util.h"
 #include "libburn.h"
 
@@ -19,7 +34,7 @@ char *burn_strdup(char *s)
 		return NULL;
 
 	l = strlen(s) + 1;
-	ret = malloc(l);
+	ret = calloc(1, l);
 	memcpy(ret, s, l);
 
 	return ret;
@@ -37,7 +52,7 @@ char *burn_strndup(char *s, int n)
 		return NULL;
 
 	l = strlen(s);
-	ret = malloc(l < n ? l : n);
+	ret = calloc(1, l < n ? l : n);
 
 	memcpy(ret, s, l < n - 1 ? l : n - 1);
 	ret[n - 1] = '\0';
@@ -47,7 +62,269 @@ char *burn_strndup(char *s, int n)
 
 void burn_version(int *major, int *minor, int *micro)
 {
-    *major = BURN_MAJOR_VERSION;
-    *minor = BURN_MINOR_VERSION;
-    *micro = BURN_MICRO_VERSION;
+/* ts A80408 : switched from configure.ac versioning to libburn.h versioning */
+	*major = burn_header_version_major;
+	*minor = burn_header_version_minor;
+	*micro = burn_header_version_micro;
 }
+
+
+struct cd_mid_record {
+	char *manufacturer;
+	int m_li;
+	int s_li;
+	int f_li;
+	char *other_brands;
+};
+typedef struct cd_mid_record cd_mid_record_t;
+
+
+/* ts A90902 */
+/** API
+   @param flag  Bitfield for control purposes,
+                bit0= append "(aka %s)",other_brands to reply
+ */
+char *burn_guess_cd_manufacturer(int m_li, int s_li, int f_li,
+                                 int m_lo, int s_lo, int f_lo, int flag)
+{
+	static cd_mid_record_t mid_list[]= {
+	{"SKC",                                 96, 40,  0,  ""},
+	{"Ritek Corp"                         , 96, 43, 30,  ""},
+	{"TDK / Ritek"                        , 97, 10,  0,  "TRAXDATA"},
+	{"TDK Corporation"                    , 97, 15,  0,  ""},
+	{"Ritek Corp"                         , 97, 15, 10,  "7-plus, Aopen, PONY, Power Source, TDK, TRAXDATA, HiCO, PHILIPS, Primdisc, Victor.JVC, OPTI STORAGE, Samsung"},
+	{"Mitsubishi Chemical Corporation"    , 97, 15, 20,  ""},
+	{"Nan-Ya Plastics Corporation"        , 97, 15, 30,  "Hatron, MMore, Acer, LITEON"},
+	{"Delphi"                             , 97, 15, 50,  ""},
+	{"Shenzhen SG&SAST"                   , 97, 16, 20,  ""},
+	{"Moser Baer India Limited"           , 97, 17,  0,  "EMTEC, Intenso, YAKUMO, PLATINUM, Silver Circle"},
+	{"SKY media Manufacturing SA"         , 97, 17, 10,  ""},
+	{"Wing"                               , 97, 18, 10,  ""},
+	{"DDT"                                , 97, 18, 20,  ""},
+	{"Daxon Technology Inc. / Acer"       , 97, 22, 60,  "Maxmax, Diamond Data, BenQ, gold, SONY"},
+	{"Taiyo Yuden Company Limited"        , 97, 24,  0,  "Maxell, FUJIFILM, SONY"},
+	{"Sony Corporation"                   , 97, 24, 10,  "LeadData, Imation"},
+	{"Computer Support Italcard s.r.l"    , 97, 24, 20,  ""},
+	{"Unitech Japan Inc."                 , 97, 24, 30,  ""},
+	{"MPO, France"                        , 97, 25,  0,  "TDK"},
+	{"Hitachi Maxell Ltd."                , 97, 25, 20,  ""},
+	{"Infodisc Technology Co,Ltd."        , 97, 25, 30,  "MEMOREX, SPEEDA, Lead data"},
+	{"Xcitec"                             , 97, 25, 60,  ""},
+	{"Fornet International Pte Ltd"       , 97, 26,  0,  "COMPUSA, Cdhouse"},
+	{"Postech Corporation"                , 97, 26, 10,  "Mr.Platinum"},
+	{"SKC Co Ltd."                        , 97, 26, 20,  "Infinite"},
+	{"Fuji Photo Film Co,Ltd."            , 97, 26, 40,  ""},
+	{"Lead Data Inc."                     , 97, 26, 50,  "SONY, Gigastorage, MIRAGE"},
+	{"CMC Magnetics Corporation"          , 97, 26, 60,  "Daxon, Verbatim, Memorex, Bi-Winner, PLEXTOR, YAMAHA, Melody, Office DEPOT, Philips, eMARK, imation, HyperMedia, Samsung, Shintaro, Techworks"},
+	{"Ricoh Company Limited"              , 97, 27,  0,  "Sony, Digital Storage, Csita"},
+	{"Plasmon Data Systems Ltd"           , 97, 27, 10,  "Ritek, TDK, EMTEC, ALPHAPET, MANIA"},
+	{"Princo Corporation"                 , 97, 27, 20,  ""},
+	{"Pioneer"                            , 97, 27, 30,  ""},
+	{"Eastman Kodak Company"              , 97, 27, 40,  ""},
+	{"Mitsui Chemicals Inc."              , 97, 27, 50,  "MAM-A, TDK"},
+	{"Ricoh Company Limited"              , 97, 27, 60,  "Ritek"},
+	{"Gigastorage Corporation"            , 97, 28, 10,  "MaxMax, Nan-Ya"},
+	{"Multi Media Masters&Machinary SA"   , 97, 28, 20,  "King, Mmirex"},
+	{"Ritek Corp"                         , 97, 31,  0,  "TDK"},
+	{"Grand Advance Technology Sdn. Bhd." , 97, 31, 30,  ""},
+	{"TDK Corporation"                    , 97, 32, 00,  ""},
+	{"Prodisc Technology Inc."            , 97, 32, 10,  "Smartbuy, Mitsubishi, Digmaster, LG, Media Market"},
+	{"Mitsubishi Chemical Corporation"    , 97, 34, 20,  "YAMAHA, Verbatim"},
+	{"Mitsui Chemicals Inc."              , 97, 48, 50, ""},
+	{"TDK Corporation"                    , 97, 49,  0, ""},
+	{"", 0, 0, 0, ""}
+	};
+
+	int i, f_li_0;
+	char buf[1024];
+	char *result = NULL;
+
+	if (m_li == 0 && s_li == 2 && f_li == 0) {
+		result = strdup("(no manufacturer code)");
+		return result;
+	}
+	f_li_0 = f_li - (f_li % 10);
+	for (i = 0; mid_list[i].manufacturer[0]; i++) {
+		if (m_li == mid_list[i].m_li &&
+		    s_li == mid_list[i].s_li &&
+		    (f_li_0 == mid_list[i].f_li || f_li == mid_list[i].f_li))
+	break;
+	}
+	if (mid_list[i].manufacturer[0] == 0) {
+		sprintf(buf, "Unknown CD manufacturer. Please report code '%2.2dm%2.2ds%2.2df/%2.2dm%2.2ds%2.2df', the human readable brand, size, and speed to scdbackup@gmx.net.", m_li, s_li, f_li, m_lo, s_lo, f_lo);
+		result = strdup(buf);
+		return result;
+	}
+
+	/* Compose, allocate and copy result */
+	if ((flag & 1) && mid_list[i].other_brands[0]) {
+		sprintf(buf, "%s  (aka %s)",
+			mid_list[i].manufacturer, mid_list[i].other_brands);
+		result = strdup(buf);
+	} else
+		result = strdup(mid_list[i].manufacturer);
+	return result;
+}
+
+
+/* ts A90904 */
+struct dvd_mid_record {
+	char *mc1;
+	int mc1_sig_len;
+	char *manufacturer;
+};
+typedef struct dvd_mid_record dvd_mid_record_t;
+
+/* ts A90904 */
+char *burn_guess_manufacturer(int prf,
+			 char *media_code1, char *media_code2, int flag)
+{
+	int i, l = 0, m_li, s_li, f_li, m_lo, s_lo, f_lo;
+	char buf[1024];
+	char *result = NULL, *cpt;
+
+	/* Important Note: media_code1 and media_code2 are supposed to be
+	                   encoded by burn_util_make_printable_word().
+	                   Especially: ' ' -> '_' , {"_%/" unprintables -> %XY)
+	*/
+	static dvd_mid_record_t mid_list[]= {
+	{"AML",         8, "UML"},
+	{"BeAll",       5, "BeAll Developers, Inc."},
+	{"CMC",         3, "CMC Magnetics Corporation"},
+	{"DAXON",       5, "Daxon Technology Inc. / Acer"},
+	{"Daxon",       5, "Daxon Technology Inc. / Acer"},
+	{"FUJI",        4, "Fujifilm Holdings Corporation"},
+	{"INFODISC",    8, "New Star Digital Co., Ltd."},
+	{"INFOME",      6, "InfoMedia Inc."},
+	{"ISMMBD",      6, "Info Source Multi Media Ltd."},
+	{"JVC",         3, "JVC Limited"},
+	{"KIC01RG",     7, "AMC"},
+	{"LD",          8, "Lead Data Inc."},
+	{"LGE",         3, "LG Electronics"},
+	{"MAM",         8, "Mitsui Advanced Media, Inc. Europe"},
+	{"MAXELL",      6, "Hitachi Maxell Ltd."},
+	{"MBI",         3, "Moser Baer India Limited"},
+	{"MCC",         8, "Mitsubishi Chemical Corporation"},
+	{"MCI",         8, "Mitsui Chemicals Inc."},
+	{"MEI",         3, "Panasonic Corporation"},
+	{"MKM",         3, "Mitsubishi Kagaku Media Co."},
+	{"MMC",         8, "Mitsubishi Kagaku Media Co."},
+	{"MXL",         8, "Hitachi Maxell Ltd."},
+	{"NANYA",       5, "Nan-Ya Plastics Corporation"},
+	{"NSD",         8, "NESA International Inc."},
+	{"OPTODISC",    8, "Optodisc Technology Corporation"},
+	{"OTCBDR",      8, "Optodisc Technology Corporation"},
+	{"PHILIP",      8, "Moser Baer India Limited"},
+	{"PHILIPS",     8, "Philips"},
+	{"PRINCO",      6, "Princo Corporation"},
+	{"PRODISC",     7, "Prodisc Technology Inc."},
+	{"Prodisc",     7, "Prodisc Technology Inc."},
+	{"PVC",         3, "Pioneer"},
+	{"RICOHJPN",    8, "Ricoh Company Limited"},
+	{"RITEK",       5, "Ritek Corp"},
+	{"SONY",        4, "Sony Corporation"},
+	{"TDK",         3, "TDK Corporation"},
+	{"TT",          8, "TDK Corporation"},
+	{"TY",          8, "Taiyo Yuden Company Limited"},
+	{"TYG",         3, "Taiyo Yuden Company Limited"},
+	{"UTJR001",     7, "Unifino Inc."},
+	{"VERBAT",      5, "Mitsubishi Kagaku Media Co."},
+	{"YUDEN",       5, "Taiyo Yuden Company Limited"},
+	{"", 0, ""}
+	};
+
+	if (media_code2 != NULL &&
+	    (prf == -1 || prf == 0x09 || prf == 0x0A)) {
+		if (strlen(media_code2) == 9 && media_code1[0] == '9' &&
+			media_code1[2] == 'm' && media_code1[5] == 's' &&
+			media_code1[8] == 'f' &&
+			strchr(media_code1, '%') == NULL) {
+			sscanf(media_code1, "%dm%ds%df", &m_li, &s_li, &f_li);
+			sscanf(media_code2, "%dm%ds%df", &m_lo, &s_lo, &f_lo);
+			if (m_li >= 96 && m_li <= 97 && m_lo > 0) {
+				result = burn_guess_cd_manufacturer(
+					m_li, s_li, f_li, m_lo, s_lo, f_lo, 0);
+				return result;
+			}
+		}
+	}
+
+	/* DVD-R do not keep manufacturer id apart from media id.
+	   Some manufacturers use a blank as separator which would now be '_'.
+	*/
+	cpt = strchr(media_code1, '_');
+	if (cpt != NULL && (prf == -1 || prf ==  0x11 || prf == 0x13 ||
+						 prf == 0x14 || prf == 0x15))
+		l = cpt - media_code1;
+
+	for (i = 0; mid_list[i].mc1[0]; i++) {
+		if (strncmp(mid_list[i].mc1, media_code1,
+			 mid_list[i].mc1_sig_len) == 0)
+	break;
+		if (l > 0)
+			if (strncmp(mid_list[i].mc1, media_code1, l) == 0)
+	break;
+	}
+	if (mid_list[i].mc1[0] == 0) {
+		sprintf(buf, "Unknown DVD/BD manufacturer. Please report code '%s/%s', the human readable brand, size, and speed to scdbackup@gmx.net.", 
+			media_code1, media_code2);
+		result = strdup(buf);
+		return result;
+	}
+	result = strdup(mid_list[i].manufacturer);
+	return result;
+}
+
+
+/* ts A90905 */
+/* Make *text a single printable word */
+/* IMPORTANT: text must be freeable memory !
+   @param flag bit0=escape '/' too
+               bit1=(overrides bit0) do not escape " _/"
+*/
+int burn_util_make_printable_word(char **text, int flag)
+{
+	int i, esc_add = 0, ret;
+	char *wpt, *rpt, *new_text = NULL;
+
+	if (flag & 2)
+		flag &= ~1;
+
+	for (i = 0; (*text)[i]; i++) {
+		rpt = (*text) + i;
+		if (*rpt < 32 || *rpt > 126 || *rpt == 96 ||
+		    ((*rpt == '_' || *rpt == '%') && (!(flag & 2))) ||
+		    (*rpt == '/' && (flag & 1)))
+			esc_add += 2;
+	}
+	if (esc_add) {
+		new_text = calloc(strlen(*text) + esc_add + 1, 1);
+		if (new_text == NULL) {
+			ret = -1;
+			goto ex;
+		}
+		wpt = new_text;
+		for (i = 0; (*text)[i]; i++) {
+			rpt = (*text) + i;
+			if (*rpt < 32 || *rpt > 126 || *rpt == 96 ||
+			    ((*rpt == '_' || *rpt == '%') && (!(flag & 2))) ||
+			    (*rpt == '/' && (flag & 1))) {
+				sprintf(wpt, "%%%2.2X", 
+				    (unsigned int) *((unsigned char *) rpt));
+				wpt+= 3;
+			} else
+				*(wpt++) = *rpt;
+		}
+		*wpt = 0;
+		free(*text);
+		*text = new_text;
+	}
+	if (!(flag & 2))
+		for (i = 0; (*text)[i]; i++)
+			if ((*text)[i] == ' ')
+				(*text)[i] = '_';
+	ret = 1;
+ex:
+	return ret;
+}
+

libburn/util.h

@@ -5,4 +5,7 @@ char *burn_strdup(char *s);
 
 char *burn_strndup(char *s, int n);
 
+/* ts A90905 */
+int burn_util_make_printable_word(char **text, int flag);
+
 #endif

libburn/write.h

@@ -1,5 +1,11 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
+   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under GPL version 2 or later.
+*/
+
+
 #ifndef BURN__WRITE_H
 #define BURN__WRITE_H
 
@@ -31,7 +37,7 @@ int burn_write_flush(struct burn_write_opts *o, struct burn_track *track);
 /* ts A61030 : necessary for TAO */
 int burn_write_close_track(struct burn_write_opts *o, struct burn_session *s,
                            int tnum);
-int burn_write_close_session(struct burn_write_opts *o,struct burn_session *s);
+int burn_write_close_session(struct burn_write_opts *o);
 
 
 

libcevap/cgen.h

@@ -0,0 +1,35 @@
+
+#ifndef Cgen_includeD
+#define Cgen_includeD Yes
+
+
+
+struct CgeN {
+
+ char *classname;
+ char *structname;
+ char *functname;
+
+ int is_managed_list;
+ int is_bossless_list;
+ int gen_for_stic; /* 0=no smem,srgex,sfile , 1=all three, 2=smem only */
+ int make_ansi;
+ int make_lowercase;
+ char global_include_file[4096];
+ FILE *global_include_fp;
+
+ struct CtyP *elements;
+ struct CtyP *last_element;
+
+ int may_overwrite;
+ FILE *fp;
+ char filename[4096];
+ FILE *ptt_fp;
+ char ptt_filename[4096];
+
+ char msg[8192];
+};
+
+
+#endif /* Cgen_includeD */
+

libcevap/cgen.txt

@@ -0,0 +1,222 @@
+
+
+Description of the helper program stic*/bin/cgen
+
+cgen is copyright 2001 to 2007, Thomas Schmitt <stic-source@gmx.net>
+and provided under BSD license.
+
+Compilation:
+  cc -g -o cgen cgen.c ctyp.c smem.c
+
+
+cgen produces a class stub in C programming language. The data structure of
+the class is described by some lines which get read from stdin. The stub will
+consist of four files which emerge in the current working directory:
+ <classname>.h          public header file of the class
+ <classname>.c          automatically generated C code of the class
+                        plus a copy of <classname>.c.methods
+ <classname>_private.h  private header file of the class
+ <classname>.c.methods  safe storage for manually created functions.
+                        From here they get copied into the generated stub.
+                        If such a file is missing, a dummy gets created.
+It will define a struct <ClassnamE> for representing the class data aspects,
+construtor <Classname>_new(), destructor <Classname>_destroy(),
+getter <Classname>_<element>_get() for each structure element.
+Some more functions get added for particular class and element roles.
+
+cgen normally refuses to overwrite existing files because it supposes that
+those contain code added by the human programmer. 
+Human programmer enhancements may be explanatory comments, class specific
+methods, initial element values and other special precautions within the
+generated functions.
+As long as the modelling phase is going on, one may store such human code
+in <classname>.c.methods and may use command line option -overwrite for
+modelling development cycles.
+
+At some point of model matureness one may decide to give up cgen and the
+.c.method files and to go on only with _private.h , .h and .c files.
+
+
+Command line options
+
+  -no_stic   prevents usage of stic_dir/s_tools/*.[ch]
+
+  -ansi      generates ANSI C function heads and makes file <classname>.h hold
+             only public definitions: an opaque declaration of the class struct
+             and a list of function prototypes. The definiton of the class
+             struct is then in <classname>_private.h .
+  -global_include filename
+             sets the name of a file which will contain globally necessary
+             declarations. Currently it lists the existence of all class
+             structs.
+  -lowercase generate struct <classname> rather than struct <ClassnamE> and
+             function names <classname>_func() rather than <Classname>_func() .
+  -overwrite allows to overwrite files <classname>_private.h, <classname>.h
+             and <classname>.c, but not <classname>.c.methods.
+
+
+Input line format:
+
+There are two states of input: class level and element level.
+Exampes are shown below with class roles and element roles.
+
+Input starts at class level. A class level line may be one of
+
+- Comment. A line which begins with '#' is ignored on class level.
+
+- Empty. A line with no characters is a comment with empty text (i.e. ignored).
+
+- Class. Options which begin with '-' and finally a word in lowercase letters
+  which defines the <classname>. The classname leads to a struct ClassnamE
+  and some class methods implemented as C functions <Classnname>_<func>().
+
+- End of input. Line "@@@" or EOF at stdin end the program run.
+
+After a class line, input switches to element level where a line may be:
+
+- Comment. A line which after some white space begins with '#' is considered
+  a comment. The preceeding white space is ignored and the text after '#' is
+  eventuellay trimmed by a single blank at both ends. This text will be part
+  of the class struct definition within file <classname_private>.h as a single
+  C comment line /* ... */. The sequence of elements and comments is preserved.
+  An empty comment text leads to an empty line in <classname_private>.h.
+
+- Empty. A line with no characters is a comment with empty text.
+
+- Element. Options which begin with '-', eventual C keywords "unsigned" or
+  "volatile", type or "struct <NamE>", element name. This leads to a struct
+  element which is taken into respect in some class methods. Depending on the
+  options in this line, some element methods <Classnname>_<func>_<element>()
+  may get generated.
+
+- End of class. A single '@' marks the end of the element list and brings
+  input back to class level. I.e. next is expected another class name or
+  "@@@" or EOF at stdin.
+
+Input semantics:
+
+A class can have one of two roles:
+
+- Standalone class.
+  Input example:
+    my_class
+
+- Listable class, which has pointers to peer instances: .prev and .next
+  Such classes get a list destructor <Classname>_destroy_all() which destroys
+  all members of a list (which is given by any of the list members).
+  Such a class should have a pointer *boss as first element in which case
+  the constructor will look like
+    <Classname>_new(struct <ClassnamE> **o,struct <Some_clasS> *boss,int flag);
+  There is a function <Classname>_link() which inserts an instance into a list
+  and a function <Classname>_count() which tells the number of list members.
+  For pseudo random access there is function <Classname>_by_idx().
+  Input example:
+    -l my_class
+
+
+A modifier is defined for classes:
+
+- Bossless. Disables a special boss-subordinate relationship which is created
+  if the first element of a class is a struct pointer with the name "boss".
+  Like
+    -l <classname>
+    -v struct Some_clasS *boss
+  Normally such a parameter *boss becomes part of the constructor method
+    <Classname>_new(struct <ClassnamE> **o, struct Some_clasS *boss, int flag);
+  This relationship is typical for a listable class and a single class which
+  is designed to host instances of that listable class. Therefore one gets a
+  warning if a listable class does not begin with a struct pointer *boss.
+  But if -b is given, then CgeN ill not include a parameter *boss into the
+  constructor. It will rather look normal:
+    <Classname>_new(struct <ClassnamE> **o, int flag);
+  It will not warn if the first element of a listable class is not struct
+  pointer *boss.
+
+
+Elements have one of the following roles:
+
+- Value. It provides only storage for a C data type (which may be a C pointer
+  despite the role name "value"), a getter method <Classname>_<element>_get(),
+  and a setter method <Classname>_<element>_set().
+  Input examples:
+    -v int i
+    -v int a[100]
+    -v char *cpt
+    -v struct xyz x
+    -v struct xyz *xpt
+
+- Managed. This has to be a pointer to a struct <XyZ> or to char. It will not
+  get attached to an object by the stub's code but its destructor
+  <Xyz>_destroy() will be called by <Classname>_destruct(). In case of (char *)
+  it is supposed that a non-NULL value has been allocated by malloc().
+  Managed (char *) types get a setter function <Classname>_<element>_set()
+  which allocates memory and copies the textstring from its parameter.
+  Input examples:
+    -m struct XyZ *xyzpt
+    -m char *textstring
+
+- Chainlink. A pair of prev-next-style pointers to the own class struct.
+  Function <Classname>_destruct() will unlink the affected instance and
+  put together its link partners.
+  Input example (there must always be two consequtive -c lines):
+    -c struct My_clasS *up
+    -c struct My_clasS *down
+
+- List. A pair of pointers to the struct <XyZ> of a listable class. The first
+  one <ls> holds the start of the list, the second one <eol> holds the end.
+  The getter function has an additional argument idx:
+    <Classname>_get_<ls>(struct <ClassnamE> *o, int idx, struct <XyZ> **pt,
+                         int flag)
+  idx == 0 is the start of the list, idx=1 the next element, ...
+  idx == -1 retrieves the last element of the list.
+  For insertion of list items there is provided method <Classname>_new_<ls>().
+  The inserted item is reachable via the getter function with idx == -1
+  <Classname>_destroy() instance calls <Xyz>_destroy_all(). Note that the end
+  pointer is always generated as private element (-p).
+  Input example (there must always be a -l and a -v line):
+    -l struct XyZ *list_start
+    -v struct XyZ *list_end
+
+The availability of getter method <Classname>_get_<element>(), and setter
+method <Classname>_set_<element>_set() can be controled by two modifiers:
+
+- Readonly. Only a getter method.
+  Input example
+    -r -v int broadcasted_status
+
+- Private. Neither getter nor setter method.
+  Input example
+    -p -v int private_value
+
+- Bossless listable. This marks elements which are listable objects but do not
+  expect a boss pointer in their constructor. See above: Listable class and
+  the bossless modifier for classes.
+  Input example
+    -b -l struct XyZ *list
+    -v struct XyZ *last_in_list
+
+- Initialization free. The class constructor will not initialize this element.
+  This modifier has to be used if neither NULL nor 0 are suitable
+  initialization values.
+
+Example run:
+
+  rm  class_x.c  class_x.h  class_y.c  class_y.h
+  bin/cgen <<+
+-l class_x
+-r -v struct Boss_clasS *boss
+-v int x
+-r -v struct stat stbuf
+-m struct Class_Y *y
+-m char *text
+-c struct Class_X *master
+-c struct Class_X *slave
+-b -l struct Class_X *provider
+-p -v struct Class_X *last_provider
+@
+-b -l class_y
+-r -v char providername[80]
+@
++
+  
+

libcevap/ctyp.c

@@ -0,0 +1,364 @@
+
+/*
+  cc -g -o ctyp.c
+*/
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+#include "smem.h"
+extern char *Sfile_fgets();
+extern int Sregex_string();
+extern int Sregex_trimline();
+
+#include "ctyp.h"
+
+
+/* --------------------------  CtyP  ----------------------- */
+
+
+int Ctyp_new(objpt,link,flag)
+struct CtyP **objpt;
+struct CtyP *link;
+int flag;
+{
+ struct CtyP *o;
+ int ret;
+
+ *objpt= o= TSOB_FELD(struct CtyP,1);
+ if(o==NULL)
+   return(-1);
+
+ o->is_comment= 0;
+ o->is_pointer= 0;
+ o->is_struct= 0;
+ o->is_unsigned= 0;
+ o->is_volatile= 0;
+ o->array_size= 0;
+ o->management= 0;
+ o->with_getter= 1;
+ o->with_setter= 1;
+ o->bossless_list= 0;
+ o->no_initializer= 0;
+ o->dtype= NULL;
+ o->name= NULL;
+ o->prev= NULL;
+ o->next= NULL;
+
+ if(link!=NULL)
+   link->next= o;
+ o->prev= link;
+
+ return(1);
+failed:;
+ Ctyp_destroy(objpt,0);
+ return(-1);
+}
+
+
+int Ctyp_destroy(objpt,flag)
+struct CtyP **objpt;
+int flag;
+{
+ struct CtyP *o;
+
+ o= *objpt;
+ if(o==NULL)
+   return(0);
+
+ if(o->prev!=NULL)
+   o->prev->next= o->next;
+ if(o->next!=NULL)
+   o->next->prev= o->prev;
+ Sregex_string(&(o->dtype),NULL,0);
+ Sregex_string(&(o->name),NULL,0);
+
+ free((char *) o);
+ *objpt= NULL;
+ return(1);
+}
+
+
+int Ctyp_get_pointer_level(ct,flag)
+struct CtyP *ct;
+int flag;
+{
+ return(ct->is_pointer);
+}
+
+
+int Ctyp_is_struct(ct,flag)
+struct CtyP *ct;
+int flag;
+{
+ return(ct->is_struct);
+}
+
+
+int Ctyp_get_array_size(ct,flag)
+struct CtyP *ct;
+int flag;
+{
+ return(ct->array_size);
+}
+
+
+int Ctyp_get_management(ct,flag)
+struct CtyP *ct;
+int flag;
+{
+ return(ct->management);
+}
+
+
+int Ctyp_get_with_getter(ct,flag)
+struct CtyP *ct;
+int flag;
+{
+ return(ct->with_getter);
+}
+
+
+int Ctyp_get_with_setter(ct,flag)
+struct CtyP *ct;
+int flag;
+{
+ return(ct->with_setter);
+}
+
+
+int Ctyp_get_dtype(ct,text,flag)
+struct CtyP *ct;
+char **text; /* must point to NULL of freeable memory */
+int flag;
+/*
+ bit0=eventually prepend "struct "
+*/
+{
+ if((flag&1) && ct->is_struct) {
+   if(Sregex_string(text,"struct ",0)<=0)
+     return(-1);
+ } else {
+   if(Sregex_string(text,"",0)<=0)
+     return(-1);
+ }
+ if(Sregex_string(text,ct->dtype,1)<=0)
+   return(-1);
+ return(1);
+}
+
+
+int Ctyp_get_name(ct,text,flag)
+struct CtyP *ct;
+char **text; /* must point to NULL of freeable memory */
+int flag;
+{
+ if(Sregex_string(text,ct->name,0)<=0)
+   return(-1);
+ return(1);
+}
+
+
+int Ctyp_get_type_mod(ct,is_spointer,is_struct,array_size,flag)
+struct CtyP *ct;
+int *is_spointer,*is_struct,*array_size;
+int flag;
+{
+ *is_spointer= ct->is_pointer;
+ *is_struct= ct->is_struct;
+ *array_size= ct->array_size;
+}
+
+int Ctyp_new_from_line(ct,link,line,msg,flag)
+struct CtyP **ct;
+struct CtyP *link;
+char *line;
+char *msg;
+int flag;
+/*
+ bit0= make  struct ClassnamE  to  struct classname 
+*/
+{
+ struct CtyP *o;
+ char *cpt,*bpt;
+ int ret,l;
+ char orig_line[4096];
+
+ ret= Ctyp_new(ct,*ct,0);
+ if(ret<=0) {
+   sprintf(msg,"Failed to create CtyP object (due to lack of memory ?)");
+   goto ex;
+ }
+ o= *ct;
+
+ strcpy(orig_line,line); 
+ cpt= line;
+ while(*cpt!=0 && isspace(*cpt)) cpt++;
+ if(cpt[0]=='#') {
+   cpt++;
+   if(cpt[1]==' ')
+     cpt++;
+   l= strlen(cpt);
+   if(cpt[0]==' ')
+     cpt++;
+   if(l>1)
+     if(cpt[l-1]==' ')
+       cpt[l-1]= 0;
+   if(Sregex_string(&(o->name),cpt,0)<=0)
+     {ret= -1; goto ex;}
+   o->is_comment= 1;
+   {ret= 1; goto ex;}
+ } else if(cpt[0]==0) {
+   if(Sregex_string(&(o->name),cpt,0)<=0)
+     {ret= -1; goto ex;}
+   o->is_comment= 1;
+   {ret= 1; goto ex;}
+ } else if(cpt[0]=='/' && cpt[1]=='*') {
+   sprintf(msg,
+          "C-style multi line comments (/* ... */) not supported yet. Use #.");
+   goto ex;
+
+   /* >>> */
+
+ }
+ cpt= line;
+ while(cpt[0]=='-') {
+   /* look for management specifiers:
+      -v*   just a value
+      -m*   allocated memory which needs to be freed
+      -c*   mutual link (like prev+next)
+      -l*   list of -m chained by mutual links prev and next
+
+      -r*   read-only : no setter function
+      -p*   private   : neither setter nor getter function
+      -b*   bossless_list : Class_new(o,flag), not Class_new(o,boss,flag)
+      -i*   no_initializer : do not initialize element in <Class>_new()
+      #...  line is a comment
+   */
+   if(cpt[1]=='v' || cpt[1]=='V') {
+     o->management= 0;
+   } else if(cpt[1]=='m' || cpt[1]=='M') {
+     o->management= 1;
+   } else if(cpt[1]=='c' || cpt[1]=='C') {
+     o->management= 2;
+     if(o->prev!=NULL)
+       if(o->prev->management==2)
+         o->management= 3;
+   } else if(cpt[1]=='l' || cpt[1]=='L') {
+     o->management= 4;
+   } else if(cpt[1]=='r' || cpt[1]=='R') {
+     o->with_setter= 0;
+   } else if(cpt[1]=='p' || cpt[1]=='P') {
+     o->with_setter= 0;
+     o->with_getter= 0;
+   } else if(cpt[1]=='b' || cpt[1]=='B') {
+     o->bossless_list= 1;
+   } else if(cpt[1]=='i' || cpt[1]=='I') {
+     o->no_initializer= 1;
+   }
+   while(*cpt!=0 && !isspace(*cpt)) cpt++;
+   while(*cpt!=0 && isspace(*cpt)) cpt++;
+   if(*cpt==0)
+     goto no_name;
+ }
+
+ if(strncmp(cpt,"struct ",7)==0) {
+   o->is_struct= 1;
+   cpt+= 7;
+ } else if(strncmp(cpt,"unsigned ",9)==0) {
+   o->is_unsigned= 1;
+   cpt+= 9;
+ } else if(strncmp(cpt,"volatile ",9)==0) {
+   o->is_volatile= 1;
+   cpt+= 9;
+   if(strncmp(cpt,"unsigned ",9)==0) {
+     o->is_unsigned= 1;
+     cpt+= 9;
+   }
+ }
+ if(*cpt==0)
+   goto no_name;
+ while(*cpt!=0 && isspace(*cpt)) cpt++;
+ bpt= cpt;
+ while(*bpt!=0 && !isspace(*bpt)) bpt++;
+ if(*bpt==0) 
+   goto no_name;
+ if(*bpt==0) {
+no_name:;
+   sprintf(msg,"No name found after type description : %s",orig_line);
+   ret= 0; goto ex;
+ }
+ *bpt= 0;
+ if(Sregex_string(&(o->dtype),cpt,0)<=0)
+   {ret= -1; goto ex;}
+ if((flag&1) && o->is_struct && strlen(o->dtype)>=3)
+   if(isupper(o->dtype[0]) && islower(o->dtype[1]) && 
+      isupper(o->dtype[strlen(o->dtype)-1])) {
+     o->dtype[0]= tolower(o->dtype[0]);
+     o->dtype[strlen(o->dtype)-1]= tolower(o->dtype[strlen(o->dtype)-1]);
+   }
+ cpt= bpt+1;
+ while(*cpt!=0 && isspace(*cpt)) cpt++;
+ if(*cpt==0)
+   goto no_name;
+ for(;*cpt=='*';cpt++) 
+   o->is_pointer++;
+ if(*cpt==0)
+   goto no_name;
+ bpt= strchr(cpt,'[');
+ if(bpt!=NULL) {
+   if(strchr(bpt,']')!=NULL)
+     *strchr(bpt,']')= 0;
+   sscanf(bpt+1,"%lu",&(o->array_size));
+   *bpt= 0;
+ }
+ if(Sregex_string(&(o->name),cpt,0)<=0)
+   {ret= -1; goto ex;}
+ if(o->management==1) {
+   if((!(o->is_pointer>=1 && o->is_pointer<=2)) ||
+       ((!o->is_struct) && strcmp(o->dtype,"char")!=0 &&
+        (strcmp(o->dtype,"unsigned char")!=0))) {
+     sprintf(msg,"-m can only be applied to pointers of struct or char : %s",
+             orig_line);
+     ret= 0; goto ex;
+   }
+ }
+ ret= 1;
+ex:;
+ return(ret);
+}
+
+
+int Ctyp_read_fp(ct,fp,msg,flag)
+struct CtyP **ct;
+FILE *fp;
+char msg[]; /* at least [4096+256] */
+int flag;
+/*
+ bit0= make  struct ClassnamE  to  struct classname 
+*/
+{
+ int ret;
+ char line[4096];
+ struct CtyP *o;
+
+ line[0]= 0;
+ printf(
+     "[-value|-managed|-chain|-list] class element ? (e.g.: -l struct XyZ)\n");
+ if(Sfile_fgets(line,sizeof(line)-1,fp)==NULL)
+   {ret= 2; goto ex;}
+ printf("%s\n",line);
+ Sregex_trimline(line,0);
+ if(strcmp(line,"@")==0)
+   {ret= 2; goto ex;}
+ ret= Ctyp_new_from_line(ct,*ct,line,msg,flag&1);
+ if(ret<=0)
+   goto ex; 
+ ret= 1;
+ex:;
+ return(ret);
+}
+

libcevap/ctyp.h

@@ -0,0 +1,41 @@
+
+#ifndef Ctyp_includeD
+#define Ctyp_includeD
+
+
+
+struct CtyP {
+
+ /* if 1 : .name contains comment text, all other elements are invalid */
+ int is_comment;
+
+ int is_pointer;  /* number of asterisks */
+ int is_struct;
+ int is_unsigned;
+ int is_volatile;
+ unsigned long array_size;
+
+ int management;  /*
+               -v    0= just a value
+               -m    1= allocated memory which needs to be freed
+               -c    2= mutual link with the next element 
+               -c    3= mutual link with the prev element
+               -l    4= list of -m , chained by -c pair named 'prev','next'    
+                        supposed to be followed by a -v of the same type
+                        which will mark the end of the list
+                   */
+ int with_getter;
+ int with_setter;
+ int bossless_list;
+ int no_initializer;
+
+ char *dtype;
+ char *name;
+
+ struct CtyP *prev;
+ struct CtyP *next;
+};
+
+
+#endif /* Ctyp_includeD */
+