Updated changelog before release

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

Makefile.am

@@ -101,10 +101,14 @@ test_structest_CPPFLAGS = -Ilibburn
 test_structest_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
 test_structest_SOURCES = test/structest.c
 
-##  cdrskin construction site - ts A60816 - A70312
+##  cdrskin construction site - ts A60816 - A71025
 cdrskin_cdrskin_CPPFLAGS = -Ilibburn
-cdrskin_cdrskin_CFLAGS = -DCdrskin_libburn_0_3_4
-cdrskin_cdrskin_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+cdrskin_cdrskin_CFLAGS = -DCdrskin_libburn_0_4_2
+
+# cdrskin_cdrskin_LDADD = $(libburn_libburn_la_OBJECTS) $(THREAD_LIBS)
+# ts A80123, change proposed by Simon Huggins to cause dynamic libburn linking
+cdrskin_cdrskin_LDADD = libburn/libburn.la $(THREAD_LIBS)
+
 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"

README

@@ -1,25 +1,25 @@
 ------------------------------------------------------------------------------
-                              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
+libburnia-project.org
 By Mario Danic <mario.danic@gmail.com> and Thomas Schmitt <scdbackup@gmx.net>
-Copyright (C) 2006-2007 Mario Danic, Thomas Schmitt
+Copyright (C) 2006-2008 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.
+These parts are to be replaced by own code of above libburnia-project.org
+copyright holders and then libburnia-project.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 
+This libburnia-project.org toplevel README (C) 2006-2007 Thomas Schmitt 
 ------------------------------------------------------------------------------
 
                            Build and Installation
@@ -27,16 +27,16 @@ This libburnia.pykix.org toplevel README (C) 2006-2007 Thomas Schmitt
 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
+   svn co http://svn.libburnia-project.org/libburn/trunk libburn
+go into directory libburn and apply autotools by
    ./bootstrap
 
 Alternatively you may unpack a release tarball for which you do not need
 autotools installed.
 
-To build a libburnia.pykix.org subproject it should be sufficient to go
-into its toplevel directory (here: "libburn_pykix") and execute
-   ./configure
+To build a libburnia-project.org subproject it should be sufficient to go
+into its toplevel directory (here: "libburn") and execute
+   ./configure --prefix=/usr
    make
 
 To make the libraries accessible for running resp. developing applications 
@@ -44,16 +44,16 @@ To make the libraries accessible for running resp. developing applications
 
 
 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
+   svn co http://svn.libburnia-project.org/libisofs/trunk libisofs
 See README file 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.
 
@@ -127,7 +127,7 @@ 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.
@@ -197,13 +197,30 @@ 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.
+
 
 ------------------------------------------------------------------------------
 
     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.
+    the Free Software Foundation. To be exact: version 2 of that License.
 
     This program is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of

cdrskin/README

@@ -1,84 +1,36 @@
 ------------------------------------------------------------------------------
-        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.4.pl00.tar.gz
-Copyright (C) 2006-2007 Thomas Schmitt
-
+http://scdbackup.sourceforge.net/cdrskin-0.4.2.tar.gz
+Copyright (C) 2006-2008 Thomas Schmitt, provided under GPL version 2.
 ------------------------------------------------------------------------------
 
-On top of libburn there is implemented cdrskin 0.3.4, 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 only supported on Linux with kernels >= 2.4.
 
-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.4.pl00.tar.gz, take it to a directory of your choice and do:
+Obtain cdrskin-0.4.2.tar.gz, take it to a directory of your choice and do:
 
-    tar xzf cdrskin-0.3.4.pl00.tar.gz
-    cd cdrskin-0.3.4
+    tar xzf cdrskin-0.4.2.tar.gz
+    cd cdrskin-0.4.2
 
-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.4 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
+This will already produce a cdrskin binary. But it will 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.
 
@@ -92,11 +44,17 @@ 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:
-If cdrskin was already installed by a previous version, or by "make install"
-in the course of this installation, then find out where:
+The command for global installation of both, libburn and cdrskin is
+    make install
+
+But 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
 
@@ -113,6 +71,10 @@ 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,20 +88,32 @@ 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
 
-    chmod a+rw /dev/sg0 /dev/sg1
+    chmod a+rw /dev/sr0 /dev/sr1
+
+This is equivalent to the traditional setup chmod a+x,u+s cdrecord.
 
 I strongly discourage to run cdrskin with setuid root or via sudo !
 It is not checked for the necessary degree of hacker safety.
 
+Consider to put all authorized users into group "floppy", to chgrp the
+device file to that group and to disallow w-access to others.
+
+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,7 +126,7 @@ 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
@@ -201,44 +175,32 @@ 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 +211,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 +226,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
@@ -395,24 +267,19 @@ 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.
 
-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 ...
-
 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. 
+manipulating the first session. Meanwhile cdrskin can do the same.
+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
@@ -428,7 +295,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 +304,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 +314,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,
@@ -475,6 +342,21 @@ blank=deformat_sequential_quickest   is faster but might yield DAO-only media.
 From the view of cdrskin they behave much like DVD-R. Each track gets wrapped
 into an own session, though.
 
+
+                              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
@@ -494,12 +376,36 @@ 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.
 
+
+------------------------------------------------------------------------------
+                      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 implied the need to reboot the
+system because of drives gnawing endlessly on ill media. Permanent hardware
+damage did not occur in 1.5 years of development.
+
+------------------------------------------------------------------------------
+
+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
+    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
@@ -510,6 +416,21 @@ debugging messages.
     along with this program; if not, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
+------------------------------------------------------------------------------
+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-2008 Mario Danic, Thomas Schmitt
+
+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.
+
+
 ------------------------------------------------------------------------------
 cdrskin is currently copyright Thomas Schmitt only.
 It adopts the following commitment by the toplevel copyright holders:

cdrskin/add_ts_changes_to_libburn_0_4_2

@@ -38,7 +38,7 @@ original="./libburn_svn_release.tgz"
 # My changes are in $changes , mainly in $changes/cdrskin
 changes="./libburn-release"
 
-skin_release="0.3.4"
+skin_release="0.4.2"
 patch_level=".pl00"
 skin_rev="$skin_release""$patch_level"
 
@@ -58,7 +58,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"
@@ -114,7 +115,8 @@ then
 fi
 cp -a "$cdrskin_dir" "$cdrskin_target"
 
-# Remove copied binaries
+# Remove copied vim.swp and binaries
+rm "$cdrskin_target"/.*.swp
 rm "$cdrskin_target"/*.o
 rm "$cdrskin_target"/cdrfifo
 rm "$cdrskin_target"/cdrskin
@@ -137,7 +139,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 +155,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
@@ -192,6 +198,18 @@ do
   fi
 done
 
+# Repair non-portable shell code output of ./bootstrap
+(
+ cd "$compile_dir" || exit 1
+ sed -e 's/^for ac_header in$/test -z 1 \&\& for ac_header in dummy/' \
+     < ./configure > ./configure-repaired
+ if test "$?" = 0
+ then
+   echo "$0: Empty 'for ac_header in' found in configure." >&2
+ fi
+ mv ./configure-repaired ./configure
+ chmod a+rx,go-w,u+w ./configure
+)
 
 # Pack it up to the new libburn+cdrskin-tarball
 tar czf "$cdrskin_tarball" "$target"

cdrskin/add_ts_changes_to_libburn_0_4_3

@@ -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="0.4.3"
 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,8 @@ then
 fi
 cp -a "$cdrskin_dir" "$cdrskin_target"
 
-# Remove copied binaries
+# Remove copied vim.swp and binaries
+rm "$cdrskin_target"/.*.swp
 rm "$cdrskin_target"/*.o
 rm "$cdrskin_target"/cdrfifo
 rm "$cdrskin_target"/cdrskin
@@ -137,11 +138,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
@@ -192,6 +196,19 @@ do
   fi
 done
 
+# Repair non-portable shell code output of ./bootstrap
+( 
+ cd "$compile_dir" || exit 1
+ sed -e 's/^for ac_header in$/test -z 1 \&\& for ac_header in dummy/' \
+     < ./configure > ./configure-repaired
+ if test "$?" = 0
+ then
+   echo "$0: Empty 'for ac_header in' found in configure." >&2
+ fi
+ mv ./configure-repaired ./configure
+ chmod a+rx,go-w,u+w ./configure
+)
+
 
 # Pack it up to the new libburn+cdrskin-tarball
 tar czf "$cdrskin_tarball" "$target"
@@ -201,13 +218,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" ..
 )
@@ -220,7 +239,7 @@ rm -rf "$target"
 ./"$bintarget_dynamic" -version
 ./"$bintarget_static" -version
 ls -l "$cdrskin_tarball"
-ls -l "$bintarget_dynamic"
+ls -l "$bintarget_dynamic"*
 ls -l "$bintarget_static"
 ls -l $(basename "$man_page_html")
 

cdrskin/cdrfifo.c

@@ -77,6 +77,9 @@ struct CdrfifO {
  double empty_counter;
  double full_counter;
 
+ /* 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  */
@@ -159,6 +162,8 @@ int Cdrfifo_new(struct CdrfifO **ff, int source_fd, int dest_fd,
  o->get_counter= 0.0;
  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;
@@ -219,6 +224,8 @@ 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)
    free((char *) o->buffer);
  free((char *) o);
@@ -390,6 +397,21 @@ int Cdrfifo_get_min_fill(struct CdrfifO *o, int *total_min_fill,
 }
 
 
+int Cdrfifo_get_iso_fs_size(struct CdrfifO *o, double *size_in_bytes, int flag)
+{
+ *size_in_bytes= o->iso_fs_size;
+ return(o->iso_fs_size>=2048);
+}
+
+
+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.
 */
@@ -398,7 +420,7 @@ int Cdrfifo_get_cdr_counters(struct CdrfifO *o,
                              double *empty_counter, double *full_counter,
                              int flag)
 {
- *put_counter= o->put_counter;;
+ *put_counter= o->put_counter;
  *get_counter= o->get_counter;
  *empty_counter= o->empty_counter;
  *full_counter= o->full_counter;
@@ -870,6 +892,29 @@ int Cdrfifo_fill(struct CdrfifO *o, int size, int flag)
    if(ret==2)
  break;
  }
+
+#ifndef Cdrfifo_standalonE
+ if(fill>=32*2048) {
+   int Scan_for_iso_size(unsigned char data[2048], double *size_in_bytes,
+                         int flag);
+   int bs= 16*2048;
+   double size;
+
+   /* 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;
+ }
+#endif
+
  o->total_min_fill= fill;
  o->interval_min_fill= fill;
  return(1);

cdrskin/cdrfifo.h

@@ -117,6 +117,21 @@ int Cdrfifo_get_cdr_counters(struct CdrfifO *o,
                              double *empty_counter, double *full_counter, 
                              int flag);
 
+/** Inquire the eventually detected size of an eventual ISO-9660 file system
+    @return 0=no ISO resp. size detected, 1=size_in_bytes is valid
+*/
+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

cdrskin/cdrskin.1

@@ -2,7 +2,7 @@
 .\" First parameter, NAME, should be all caps
 .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection
 .\" other parameters are allowed: see man(7), man(1)
-.TH CDRSKIN 1 "March 6, 2007"
+.TH CDRSKIN 1 "September 26, 2007"
 .\" Please adjust this date whenever revising the manpage.
 .\"
 .\" Some roff macros, for reference:
@@ -31,7 +31,7 @@ via libburn.
 \fBcdrskin\fP is a program that provides some of cdrecord's options
 in a compatible way for CD media. With DVD it has its own ways.
 You do not need to be superuser for its daily usage.
-.PP
+.SS
 .B Overview of features:
 .br
 Blanking of CD-RW and DVD-RW.
@@ -46,14 +46,18 @@ Multi session on CD (follow-up sessions in TAO only)
 .br
 or on DVD-R[W] (in Incremental mode) or on DVD+R.
 .br
-Single session on DVD-RW or DVD-R (Disk-at-once)
+Single session on DVD-RW or DVD-R (Disk-at-once).
 .br
-or on overwriteable DVD+RW, DVD-RW, DVD-RAM.
+Single session or emulated ISO-9660 multi-session 
+.br
+on overwriteable DVD+RW, DVD-RW, DVD-RAM,
+.br
+or on data file or block device.
 .br
 Bus scan, burnfree, speed options, retrieving media info, padding, fifo.
 .br
 See section EXAMPLES at the end of this text.
-.PP
+.SS
 .B General information paragraphs:
 .br
 Track recording model
@@ -67,7 +71,9 @@ Sequentially Recordable DVD Media
 Overwriteable DVD Media
 .br
 Drive preparation and addressing
-.PP
+.br
+Emulated drives
+.SS
 .B Track recording model:
 .br
 The input-output entities which get processed are called tracks.
@@ -109,9 +115,22 @@ Another type of data track content are archive formats which originally
 have been developed for magnetic tapes. Only formats which mark a detectable
 end-of-archive in their data are suitable, though. Well tested are
 the archivers afio and star. Not suitable seems GNU tar.
-.PP
+.SS
 .B Write mode selection:
 .br
+In general there are two approaches for writing media:
+.br
+A permissive mode depicted by option
+.B -tao
+which needs no predicted track size and allows to make use of
+eventual multi-session capabilities.
+.br
+A more restrictive mode
+.B -sao
+(alias -dao) which usually demands a predictable track size and is not
+necessarily capable of multi-session. It may have advantages for some
+readers resp. players of the recorded tracks.
+.br
 If none of the options -dao, -tao or -sao is given then the program will
 try to choose a write mode which matches the defined recording job,
 the capabilities of the drive and the state of the present media.
@@ -119,7 +138,7 @@ the capabilities of the drive and the state of the present media.
 So the mentioning of write modes in the following paragraphs and in the
 examples is not so much a demand that the user shall choose one explicitely,
 but rather an illustration of what to expect with particular media types.
-.PP
+.SS
 .B Recordable CD Media:
 .br
 CD-R can be initially written only once and eventually extended until they
@@ -128,15 +147,11 @@ read-only. Closing is done automatically unless option
 .B -multi
 is given which keeps the media appendable.
 .br
-There are two write modes,
-.B -tao
-and
-.B -sao .
-.br
--tao allows to use track source of unpredictable length (like stdin) and allows
-to write further sessions to appendable media. -sao produces audio sessions
-with seamless tracks but needs predicted track sizes and cannot append sessions
-to media.
+Write mode
+-tao allows to use track sources of unpredictable length (like stdin) and
+allows to write further sessions to appendable media.
+-sao produces audio sessions with seamless tracks but needs predicted track
+sizes and cannot append sessions to media.
 .br
 CD-RW media can be blanked to make them re-usable for another
 round of overwriting. Usually
@@ -145,7 +160,7 @@ is the appropriate option.
 Blanking damages the previous content but does not
 make it completely unreadable. It is no effective privacy precaution.
 Multiple cycles of blanking and overwriting with random numbers might be.
-.PP
+.SS
 .B Sequentially Recordable DVD Media:
 .br
 Currently DVD-RW, DVD-R and DVD+R can be used for the Sequential recording
@@ -191,20 +206,27 @@ Quite deliberately write mode -sao insists in the tradition of a predicted
 track size and blank media, whereas -tao writes the tracks open ended and
 allows appendable media.
 .br
-Currently DVD+R are always kept appendable regardless wether -multi is given
-or not. This might change in future so it is strongly advised to already now
-use
-.B -multi
-whenever the disc shall be kept appendable.
-.PP
+.B Note:
+Option -multi might make DVD media unreadable in some DVD-ROM drives.
+Best reader compatibility is achieved without it
+(i.e. by single session media).
+.SS
 .B Overwriteable DVD Media:
 .br
 Currently types DVD+RW, DVD-RW and DVD-RAM can be overwritten via cdrskin.
 .br
-DVD+RW and DVD-RAM media get treated as blank media regardless wether they
-hold data or not. They need no special initial formatting.
-Options -audio and -multi are not allowed. Only one track is allowed.
--toc does not return information about the media content.
+DVD+RW and DVD-RAM media need no special initial formatting. They offer a
+single continuous data area for blockwise random access.
+.br
+Option -audio is not allowed. Only one track is allowed.
+Option -multi cannot mark a recognizeable end of overwriteable media.
+Therefore -multi is banned unless ISO-9660 images shall be expandable by help
+of option
+.B --grow_overwriteable_iso .
+Without this option or without an ISO-9660 filesystem image present
+on media, -toc does not return information about the media content and
+media get treated as blank regardless wether they hold data or not.
+.br
 Currently there is no difference between -sao and -tao. If ever, then -tao
 will be the mode which preserves the current behavior.
 .br
@@ -217,7 +239,7 @@ can be done by option
 Several programs like dvd+rw-format, cdrecord, wodim, or cdrskin
 can bring a DVD-RW out of overwriteable state so
 that it has to be formatted again. If in doubt, just give it a try.
-.PP
+.SS
 .B Drive preparation and addressing:
 .br
 The drives, either CD burners or DVD burners, are accessed via addresses which
@@ -231,9 +253,11 @@ it might be only the
 who is able to get this list without further
 precautions.
 .br
-It is consensus that \fBchmod a+rw /dev/sg0\fP or \fBchmod a+rw /dev/hdc\fP
-is less security sensitive than chmod u+s /usr/bin/cdrskin. The risk for the
-drive is somewhat higher but the overall system is much less at stake.
+It is consensus that \fBchmod a+rw /dev/sr0\fP or \fBchmod a+rw /dev/hdc\fP
+is less security sensitive than chmod u+s,a+x /usr/bin/cdrskin. The risk for
+the drive is somewhat higher but the overall system is much less at stake.
+Consider to restrict rw-access to a single group which bundles the users who
+are allowed to use the burner drive (like group "floppy").
 .br
 .PP
 If you only got one CD capable drive then you may leave out cdrskin option
@@ -249,7 +273,41 @@ See option -scanbus for getting a list of cdrecord style addresses.
 .br
 Further are accepted on Linux: links to libburn-suitable device files, 
 device files which have the same major and minor device number,
-and device files which have the same SCSI address parameters (e.g. /dev/sr0).
+and device files which have the same SCSI address parameters (e.g. /dev/sg0).
+.br
+.SS
+.B Emulated drives:
+.br
+Option
+.B --allow_emulated_drives
+enables addressing of pseudo-drives
+which get emulated on top of filesystem objects. Regular data files and
+block devices result in pseudo-drives which behave much like DVD-RAM.
+If the given address does not exist yet but its directory exists, then
+it gets created as regular file.
+Other file types like character devices or pipes result in pseudo-drives
+which behave much like blank DVD-R.
+The target file address is given after prefix "stdio:".
+.br
+E.g.: dev=stdio:/tmp/my_pseudo_drive
+.br
+Addresses of the form "stdio:/dev/fd/<number>" are treated special. The
+number is read literally and used as open file descriptor. With
+dev="stdio:/dev/fd/1" the normal standard output of the program is
+redirected to stderr and the stream data of a burn run will appear on stdout.
+.br
+Not good for terminals ! Redirect it.
+.br
+Pseudo-drives allow -dummy. Their reply with --tell_media_space can be utopic.
+-dummy burn runs touch the file but do not modify its data content.
+.br
+Note: --allow_emulated_drives is restricted to stdio:/dev/null if cdrskin
+is run by the
+.B superuser
+or if it has changed user identity via the
+.B setuid
+bit of its access permissions. The ban for the superuser can be lifted by a
+skillfully created file. See section FILES below.
 .br
 .SH OPTIONS
 .TP
@@ -258,6 +316,11 @@ Show non-cdrecord compatible options.
 .TP
 .BI \-help
 Show cdrecord compatible options.
+.br
+Note that some of the help texts are quite wrong - for cdrecord as well as
+for cdrskin (e.g. -format, blank=, -load). They are, nevertheless, traditional
+indicators for the availability of the listed options. Some frontend programs
+make decisions after reading them.
 .TP
 .BI \-version
 Print cdrskin id line, compatibility lure line, libburn version, cdrskin
@@ -275,9 +338,9 @@ Announces that the subsequent tracks are to be burned as audio.
 The source is supposed to be uncompressed headerless PCM, 44100 Hz, 16 bit,
 stereo. For little-endian byte order (which is usual on PCs) use option
 -swab. Unless marked explicitely by option -data, input files with suffix
-.wav are examined wether they have a header in MS-WAVE format confirming
+".wav" are examined wether they have a header in MS-WAVE format confirming
 those parameters and eventually raw audio data get extracted and burned as
-audio track. Same is done for suffix .au and SUN Audio.
+audio track. Same is done for suffix ".au" and SUN Audio.
 .br
 Option -audio may be used only with CD media and not with DVD.
 .TP 
@@ -292,11 +355,11 @@ Print this list of blanking types.
 .TP
 all
 Blank an entire CD-RW or an unformatted DVD-RW.
-(See also --prodvd_cli_compatible)
+(See also --prodvd_cli_compatible, --grow_overwriteable_iso)
 .TP
 fast
 Minimally blank an entire CD-RW or blank an unformatted DVD-RW.
-(See also --prodvd_cli_compatible)
+(See also --prodvd_cli_compatible, --grow_overwriteable_iso)
 .TP
 format_overwrite
 Format a DVD-RW to "Restricted Overwrite". The user should bring some patience.
@@ -304,14 +367,14 @@ Format a DVD-RW to "Restricted Overwrite". The user should bring some patience.
 (Note: blank=format_overwrite* are not original cdrecord options.)
 .TP
 format_overwrite_quickest
-Like format_overwrite without creating a 128 MB trailblazer session.
+Like format_overwrite without creating a 128 MiB trailblazer session.
 Leads to "intermediate" state which only allows sequential write
 beginning from address 0.
 The "intermediate" state ends after the first session of writing data.
 .TP
 format_overwrite_full
 For DVD-RW this is like format_overwrite but claims full media size
-rather than just 128 MB.
+rather than just 128 MiB.
 Most traditional formatting is attempted. No data get written. 
 Much patience is required.
 .br
@@ -336,7 +399,7 @@ Incremental Streaming (-tao).
 .RE
 .TP
 .BI \-checkdrive
-Retrieve some info about the addressed drive.
+Retrieve some info about the addressed drive and then exit.
 Exits with non-zero value if the drive cannot be found and opened.
 .TP
 .BI \-dao
@@ -371,8 +434,10 @@ even if attempted explicitely via "driveropts=burnfree".
 .TP
 .BI \-dummy
 Try to perform the drive operations without actually affecting the inserted
-media. There is no guarantee that this will work with a particular combination
+media. There is no warranty that this will work with a particular combination
 of drive, media, and write mode. Blanking is prevented reliably, though.
+To avoid inadverted real burning, -dummy refuses burn runs on anything but
+CD-R[W], DVD-R[W], or emulated stdio-drives.
 .TP
 .BI \-eject
 Eject the disc after work is done.
@@ -386,9 +451,15 @@ write modes which libburn believes they are not supported by the drive.
 Another application is to enforce blanking or re-formatting of media
 which appear to be in the desired blank or format state already.
 .br
+This option enables a burn run with option -dummy even if libburn believes
+that drive and media will not simulate the write mode but will write for real.
+.br
 .B Caution:
 Use this only when in urgent need.
 .TP
+.BI \-format
+Same as blank=format_overwrite_full -force but restricted to DVD+RW.
+.TP
 .BI fs= size
 Set the fifo size to the given value. The value may have appended letters which
 multiply the preceding number:
@@ -408,6 +479,54 @@ option fifo_start_at=size.
 .BI gracetime= seconds
 Set the grace time before starting to write. (Default is 0)
 .TP
+.BI -immed
+Equivalent to:
+.br
+modesty_on_drive=1:min_percent=75:max_percent=95
+.br
+The name of this cdrecord option stems from the "Immed" bit which can make some
+long running drive commands asynchronous and thus eases the load on some
+wiring hardware types. Regardless of option -immed, cdrskin uses asynchronous
+commands where possible and appropriate. 
+.TP
+.BI -inq
+Print the identification of the drive and then exit.
+.TP
+.BI -isosize
+The next track following this option will try to obtain its source size from
+the header information out of the first few blocks of the source data.
+If these blocks indicate an ISO-9660 filesystem then its declared size
+will be used under the assumption that it is a single session filesystem.
+.br
+If not, then the burn run will be aborted.
+.br
+The range of -isosize is exactly one track. Further tracks may be preceeded
+by further -isosize options, though. At least 15 blocks of padding will be
+added to each -isosize track. But be advised to rather use padsize=300k.
+.br
+This option can be performed on track sources which are regular files or block
+devices. For the first track of the session it can be performed on any type
+of source if there is a fifo of at least 64 kiB. See option fs= .
+.TP
+.BI -load
+Load the media and exit. Exit value is 0 if any kind of media was found, non
+zero else. Note: Option -eject will unload the media even if -load is given.
+.TP
+.BI -lock
+Like option -load but leave the drive's eject button disabled if there is any
+media found and not option -eject is given.
+.br
+Use program "eject" or cdrskin -eject to get the tray out of the drive.
+Runs of programs like cdrecord, growisofs, wodim, cdrskin will not be hampered
+and normally enable the drive's eject button when they are done.
+.TP
+.BI minbuf= percentage
+Equivalent to:
+.br
+modesty_on_drive=1:min_percent=<percentage>:max_percent=95
+.br
+Percentage is permissible between 25 and 95.
+.TP
 .BI msifile= path
 Run option -msinfo and copy the result line into the file given by path.
 Unlike -msinfo this option does not redirect all normal output away from
@@ -424,6 +543,9 @@ The result string shall be used as argument of option -C with said programs.
 It gives the start address of the most recent session and the predicted
 start address of the next session to be appended. The string is empty if
 the most recent session was not written with option -multi.
+.br
+To have a chance for working on overwriteable media, this option has to be
+accompanied by option --grow_overwriteable_iso.
 .TP
 .BI \-multi
 This option keeps the CD or unformatted DVD-R[W] appendable after the current
@@ -432,9 +554,8 @@ Without it the disc gets closed and may not be written any more  - unless it
 is a -RW and gets blanked which causes loss of its content.
 .br
 The following sessions can only be written in -tao mode. -multi is prohibited
-with overwriteable DVD media and with DVD-R[W] DAO write mode.
-Option --prodvd_cli_compatible eventually makes -multi tolerable but cannot
-make it work.
+with DVD-R[W] DAO write mode. Option --prodvd_cli_compatible eventually makes
+-multi tolerable but cannot make it work.
 .br
 In order to have all filesystem content accessible, the eventual ISO-9660
 filesystem of a follow-up
@@ -443,7 +564,16 @@ program. mkisofs and genisoimage expect particular info about the situation
 which can be retrieved by cdrskin option -msinfo.
 .br
 To retrieve an archive file which was written as follow-up session,
-you may use option -toc to learn about the "lba" of the desired track number. 
+you may use option -toc to learn about the "lba" of the desired track number.
+This lba is the address of the 2048 byte block where the archive begins.
+.br
+With overwriteable DVD media, -multi cannot mark the end of the session.
+So when adding a new session this end has to be determined from the payload.
+Currently only ISO-9660 filesystems can be used that way. See option
+.B \--grow_overwriteable_iso
+for lifting the ban on -multi. 
+.br
+Note: -multi might make DVD media unreadable in some DVD-ROM drives.
 .TP
 .BI \-nopad
 Do not add trailing zeros to the data stream. Nevertheless, since there seems
@@ -451,7 +581,7 @@ to be no use for audio tracks with incomplete last sector, this option applies
 only to data tracks. There it is default.
 .TP
 .BI \-pad
-Add 30 kB of trailing zeros to each data track. (This is not sufficient to
+Add 30 kiB of trailing zeros to each data track. (This is not sufficient to
 avoid problems with various CD-ROM read drivers.)
 .TP
 .BI padsize= size
@@ -503,6 +633,9 @@ Set speed of drive. With data CD, 1x speed corresponds to a throughput of
 150,000 bytes/second. With DVD, 1x = 1,385,000 bytes/second.
 It is not an error to set a speed higher than is suitable for drive
 and media. One should stay within a realistic speed range, though.
+Special speed settings are:
+.br
+0 = minimal speed , -1 = maximal speed (default), text "any" = like -1.
 .TP
 .BI \-swab
 Announce that the raw audio data source of subsequent tracks is byte swapped
@@ -566,10 +699,37 @@ some extra lines to be put out with info retrieval options.
 Level 2 additionally reports about option settings derived from arguments or
 startup files. Level 3 is for debugging and useful mainly in conjunction with
 somebody who had a look into the program sourcecode.
+.TP
+.BI \-waiti
+Wait until input data is available at stdin or EOF occurs at stdin.
+Only then begin to access any drives.
+.br
+One should use this if cdrskin is working at the end of a pipe where the
+feeder process reads from the drive before it starts writing its output into
+cdrskin. Example:
+.br
+mkisofs ... -C 0,12800 -M /dev/sr0 | \\
+.br
+cdrskin dev=/dev/sr0 ... -waiti -
+.br
+This option works even if stdin is not among the track sources. If no process
+is piping in, then the Enter key of your terminal will act as trigger for
+cdrskin. Note that this input line will not be consumed by cdrskin if stdin
+is not among the track sources. It will end up as shell command, usually.
 .PP
 Alphabetical list of options which are genuine to cdrskin and intended for
 normal use:
 .TP
+.BI \--adjust_speed_to_drive
+Curb explicitely given speed= values to the maximum which is announced by the
+drive for the loaded media. By default, such an adjustment is only made with
+pseudo-speeds 0 and -1 whereas speed settings > 0 are sent unchanged to the
+drive which will then choose an appropriate speed on its own.
+.TP
+.BI \--allow_emulated_drives
+Enable drive addresses of the form dev=stdio:<path>. See above, paragraph
+"Drive preparation and addressing".
+.TP
 .BI \--allow_setuid
 Disable the loud warning about insecure discrepance between login user and
 effective user which indicates application of chmod u+s to the program binary.
@@ -611,6 +771,59 @@ Number dev='Devicefile' rw-Permissions : 'Vendor' 'Model'
 Number and Devicefile can both be used with option dev=, but number is
 volatile (numbering changes if drives become busy).
 .TP
+.BI direct_write_amount= size
+Do not write a session with tracks but rather make an appropriate number of
+direct write operations with no preparations. Flushing the drive buffer will
+be the only finalization. It is advised to eject the media afterwards because
+the write operations circumvent the usual system i/o with its caches and
+buffers. By ejecting, those invalid memory copies get surely discarded.
+.br
+Only few media can be written this way: DVD-RAM, RVD+RW and overwriteable
+DVD-RW. Writing is restricted to the already formatted area of the media.
+.br
+Writing starts at byte 0 of the media or at the address given by option
+.B write_start_address= .
+Only the first track source is used as input for the write operations.
+The fifo (fs=) is disabled.
+.br
+Parameter
+.B size
+controls the amount of data to be written. Size 0 means that the track source
+shall be used up until EOF. In this case, the last write transaction gets
+padded up to the necessary size by zeros. Size -1 revokes direct writing
+and switches back to normal session oriented writing.
+.br
+Both, write_start_address and direct_write_amount size must be aligned to a
+media dependend transaction size. With DVD-RAM and DVD+RW this is 2k, with
+overwriteable DVD-RW it is 32k.
+.TP
+.BI fallback_program= command
+Set a command name to be executed if cdrskin encounters a known cdrecord
+option which it does not yet support. If a non-empty command is given with
+fallback_program=, and if no essential options are given which are specific
+to cdrskin, then cdrskin will delegate the job to said command.
+.br
+The natural commands to be given are cdrecord or wodim but one may well submit
+the address of an own program. 
+.br
+The fallback programm will get all arguments of cdrskin which do not match
+the shell patterns --?* or *_*=* . This eventually suppresses path names of
+track sources which happen to match those patterns. The options from the
+startup files are not handed to the fallback program.
+.br
+Fallback program execution is disabled if cdrskin is run setuid and not
+option --allow_setuid is given. In general, the drive's device files and the
+involved programs should be set up so that each program runs under its advised
+conditions. (E.g. cdrskin as member of group floppy, cdrecord setuid root.)
+.br
+Two alias names for cdrskin are predefined with default fallback programs:
+.br
+.B unicord
+implies fallback_program=cdrecord
+.br
+.B codim
+implies fallback_program=wodim
+.TP
 .BI fifo_start_at= size
 Do not wait for full fifo but start burning as soon as the given number
 of bytes is read. This option may be helpful to bring the average throughput
@@ -621,6 +834,46 @@ the software protection against buffer underun is as weak as the size of
 fifo_start_at= . So it is best if the drive offers hardware protection which
 is enabled automatically if not driveropts=noburnfree is given.
 .TP
+.BI \--grow_overwriteable_iso
+Enable emulation of multi-session writing on overwriteable media which
+contain an ISO-9660 filesystem. This emulation is learned from growisofs -M
+but adapted to the usage model of
+.br
+.B cdrskin -msinfo 
+.br
+.B mkisofs -C -M | cdrskin -waiti [-multi] -
+.br
+--grow_overwriteable_iso does not hamper the use of true multi-session media.
+I.e. it is possible to use the same cdrskin options with both kinds of media
+and to achieve similar results if ISO-9660 filesystem images are to be written.
+This option implies option -isosize and therefore demands that the track
+source is a ISO-9660 filesystem image.
+.br
+With overwriteable media and no option blank=fast|all present it expands an
+eventual ISO-9660 filesystem on media. It is assumed that this image's inner
+size description points to the end of the valuable data.
+Overwriteable media with a recognizeable ISO-9660 size will be regarded as
+appendable rather than as blank. I.e. options -msinfo and -toc will work.
+-toc will always show a single session with its size increasing with
+every added mkisofs image.
+.br
+If not overriden by option write_start_address=, the track with the new image
+will be placed behind the end of the old one. One may use option
+assert_write_lba= to make sure that media state and mkisofs job do match.
+.br
+--grow_overwriteable_iso causes option blank=fast|all to invalidate an
+eventual ISO-9660 image by altering the first few bytes of block 16 on
+overwriteable media.
+Option -multi is tolerated in order not to hamper true multi-session media.
+.br
+An equivalent of growisofs -Z for overwriteable media is:
+.br
+.B mkisofs | cdrskin --grow_overwriteable_iso blank=fast [-multi] -
+.br
+With multi-session DVD, blank=fast will act like dvd+rw-format -blank=full .
+.br
+growisofs -dvd-compat is roughly equivalent to cdrskin without option -multi.
+.TP
 .BI \--list_ignored_options
 List all ignored cdrecord options. The "-" options cannot be used as addresses
 of track sources. No track source address may begin with a text equal to an
@@ -678,8 +931,8 @@ string and eventual output of -msinfo.
 .TP 
 .BI write_start_address= byte_offset
 Set the address on media where to start writing the track. With DVD+RW or
-DVD-RAM byte_offset must be aligned to 2 KB blocks, but better is 32 kB.
-With DVD-RW 32 kB alignment is mandatory.
+DVD-RAM byte_offset must be aligned to 2 kiB blocks, but better is 32 kiB.
+With DVD-RW 32 kiB alignment is mandatory.
 .br
 Other media are not suitable for this option yet.
 .PP
@@ -712,7 +965,7 @@ translate cdrecord addresses into cdrskin addresses.
 dev=. <to> is the address to be used instead whenever <from> is given.
 More than one translation instruction can be given in one cdrskin run.
 .br
-E.g.: dev_translation=+ATA:1,0,0+/dev/sg1 dev_translation=+ATA:1,1,0+/dev/sg2
+E.g.: dev_translation=+ATA:1,0,0+/dev/sr1 dev_translation=+ATA:1,1,0+/dev/sr2
 .TP
 .BI \--drive_abort_on_busy
 Linux specific: Abort process if a busy drive is encountered.
@@ -721,14 +974,33 @@ Linux specific: Abort process if a busy drive is encountered.
 Linux specific: Try to wait for a busy drive to become free.
 This is not guaranteed to work with all drivers. Some need nonblocking i/o.
 .TP
+.BI \--drive_f_setlk
+Linux specific: Try to get exclusive lock on drive device file via fcntl(2).
+.TP
 .BI \--drive_not_exclusive
+Linux specific: Combine --drive_not_f_setlk and --drive_not_o_excl.
+.TP
+.BI \--drive_not_f_setlk
+Linux specific: Do not try to get exclusive lock on drive device file via
+fcntl(2).
+.TP
+.BI \--drive_not_o_excl
 Linux specific: Do not ask the operating system to prevent opening busy drives.
 Wether this leads to senseful behavior depends on operating system and kernel.
 .TP
+.BI drive_scsi_dev_family= sr | scd | sg
+Linux specific: Select a SCSI device file family to be used for drive command
+transactions. Normally this is /dev/sgN on kernel versions < 2.6 and /dev/srN
+on kernels >= 2.6 . This option allows to explicitely override that default
+in order to meet other programs at a common device file for each drive.
+On kernel 2.4 families sr and scd will find no drives.
+.br
+Device file family /dev/hdX on kernel >= 2.6 is not affected by this setting.
+.TP
 .BI \--drive_scsi_exclusive
 Linux specific:
-Try to exclusively reserve device files /dev/srN, /dev/scdM, /dev/stK of drive.
-this would be helpful to protect against collisions with program growisofs.
+Try to exclusively reserve device files /dev/srN, /dev/scdM, /dev/sgK of drives.
+This would be helpful to protect against collisions with program growisofs.
 Regrettably on Linux kernel 2.4 with ide-scsi emulation this seems not to
 work. Wether it becomes helpful with new Linux systems has to be evaluated.
 .TP
@@ -746,9 +1018,12 @@ This option overrides option -multi. It will not fill up media if option -sao
 is given with CD media.
 .br
 .B Caution:
-This option might increase read compatibility with DVD-ROM drives but
-with some DVD recorders and media types it might also fail to produce readable
-media at all. "Your mileage may vary".
+With multi-session media this option might increase readatibility on DVD-ROM
+drives but with some DVD recorders and media types it might also fail to
+produce readable media at all. "Your mileage may vary".
+.br
+You can expect the best possible read compatibility if you do not use -multi at
+all. 
 .TP
 .BI grab_drive_and_wait= seconds
 Open the addressed drive, wait the given number of seconds, release the drive,
@@ -762,6 +1037,30 @@ Try to ignore any signals rather than to abort the program. This is not a
 very good idea. You might end up waiting a very long time for cdrskin
 to finish.
 .TP
+.BI modesty_on_drive= <mode>[:min_percent=<num>][:max_percent=<num>]
+Mode 1 keeps the program from trying to write to the burner drive while its
+buffer is in danger to be filled by more than max_percent. If this filling is
+exceeded then the program will wait until the filling is at most min_percent.
+.br
+This can ease the load on operating system and drive controller and thus help
+with achieving better input bandwidth if disk and burner are not on independent
+controllers (like hda and hdb). Unsufficient input bandwidth is indicated by
+output "(fifo  xy%)" of option -v if xy is lower than 90 for some time.
+modesty_on_drive= might hamper output bandwidth and cause buffer underruns.
+.br
+To have max_percent larger than the burner's best actual
+buffer fill has the same effect as min_percent==max_percent. Some burners
+do not use their full buffer with all media types. Watch output "[buf xy%]"
+of option -v to get an impression of the actual buffer usage. Some burners
+are not suitable because they report buffer fill with granularity too large
+in size or time. 
+.br
+Mode 0 disables this feature. Mode -1 keeps it unchanged. Default is:
+.br
+modesty_on_drive=0:min_percent=65:max_percent=95
+.br
+Percentages are permissible in the range of 25 to 100.
+.TP
 .BI \--no_abort_handler
 On signals exit even if the drive is in busy state. This is not a very good
 idea. You might end up with a stuck drive that refuses to hand out the media.
@@ -778,7 +1077,7 @@ Partly Linux specific:
 Such opening is needed for Bus,Target,Lun addresses unless option
 --old_pseudo_scsi_adr is given. It is also needed to resolve device file
 addresses which are not listed with cdrskin --devices but nevertheless point
-to a usable drive. (Like /dev/sr0 using the same SCSI address as /dev/sg0.)
+to a usable drive. (Like /dev/sg0 using the same SCSI address as /dev/sr0.)
 .TP
 .BI \--old_pseudo_scsi_adr
 Linux specific:
@@ -863,6 +1162,9 @@ cdrskin -v dev=ATA:1,0,0 speed=48 -sao \\
 track1.wav track2.au -audio -swab track3.raw
 .br
 .SH FILES
+.SS
+Startup files:
+.br
 If not --no_rc is given as the first argument then cdrskin attempts on
 startup to read the arguments from the following files:
 .PP
@@ -880,26 +1182,35 @@ The files are read in the sequence given above, but none of them is
 required for cdrskin to function properly. Each readable line is treated
 as one single argument. No extra blanks.
 A first character '#' marks a comment, empty lines are ignored.
-.SS
-.B Example content of a startup file:
+.br
+Example content of a startup file:
 .br
 # This is the default device
 .br
 dev=0,1,0
 .br
-# To accomodate to remnant cdrskin-0.2.2 addresses
-.br
-dev_translation=+1,0,0+0,1,0
-.br
 # Some more options
 .br
 fifo_start_at=0
 .br
 fs=16m
 .br
+.SS
+Disabling superuser safety precautions:
+The superuser is normally banned from using any other emulated drive but
+/dev/null. This ban can be lifted by the existence of file
+.PP
+.B /root/cdrskin_permissions/allow_emulated_drives
+.PP
+where the directory must be owned by the superuser and must not offer
+w-permissions for group or others.
+.br
+Warning: Superusers must take care not to spoil their hard disk via its raw
+block device (like stdio:/dev/hda or stdio:/dev/sd0).
+
 .SH SEE ALSO
 .TP
-Formatting track sources for cdrskin:
+Formatting data track sources for cdrskin:
 .br
 .BR mkisofs (8),
 .BR genisoimage (8),

cdrskin/cdrskin_eng.html

@@ -12,7 +12,7 @@
 
 <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>
@@ -34,7 +34,7 @@ CD-R, DVD-R, DVD+R, CD-RW, DVD-RW, DVD-RAM, DVD+RW
 <P>
 <H2>Hardware requirements:</H2>
 A CD/DVD recorder suitable for 
-<A HREF="http://libburnia.pykix.org">libburnia.pykix.org</A> <BR>
+<A HREF="http://libburnia-project.org">http://libburnia-project.org</A> <BR>
 (SCSI , ATA , USB , or SATA writers compliant to standard MMC-3 for CD
 and to MMC-5 for DVD).
 <BR>
@@ -43,7 +43,7 @@ and to MMC-5 for DVD).
 <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>libpthread</DT>
@@ -56,9 +56,10 @@ 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-0.4.2</DT>
+<DD>(founded by Derek Foreman and Ben Jansens,
+furthered by team of libburnia-project.org)</DD>
+<DD>transfers data to CD and DVD</DD>
 </DL>
 </P>
 
@@ -81,24 +82,19 @@ 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 single layer DVD media cdrskin is able to perform any recording job
+which is possible with cdrecord.
+Other than with cdrecord, options -multi and -tao are supported with
+certain DVD types.
+</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>
@@ -160,7 +156,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,6 +166,9 @@ man cdrecord</A></KBD></DD>
  this "don't bother Joerg" demand.)
 </DD>
 </DL>
+
+Testers wanted who are willing to risk some double layer DVD media.
+
 </P>
 
 <HR>
@@ -178,25 +176,25 @@ man cdrecord</A></KBD></DD>
 <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>
-(570 KB).
+<DD><A HREF="cdrskin-0.4.2.pl00.tar.gz">cdrskin-0.4.2.pl00.tar.gz</A>
+(700 KB).
 </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>
 <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>, (80 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>
@@ -223,16 +221,13 @@ 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-0.4.0:
 <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= prevents inadverted writing to appendable
-<LI>Bug fix: Multi-track runs with fifo could stall in rare cases</LI>
+<LI>Safe dynamic linking possible with libburn.so.4</LI>
 </UL>
 
 <!--
- Bug fixes towards cdrskin-0.3.4.pl00:
+ Bug fixes towards cdrskin-0.4.2.pl00:
 <UL>
 <LI>none yet</LI>
 </UL>
@@ -244,23 +239,25 @@ Enhancements towards previous stable version cdrskin-0.3.2:
 
 <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 0.4.3 :</H3></DT>
+<DD>Enhancements towards stable version 0.4.2.pl00:
 <UL>
 <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 0.4.3</A>
+<DD><A HREF="cdrskin__help_devel">cdrskin_0.4.3 --help</A></DD>
+<DD><A HREF="cdrskin_help_devel">cdrskin_0.4.3 -help</A></DD>
+<DD><A HREF="man_1_cdrskin_devel.html">man cdrskin (as of 0.4.3)</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</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.
@@ -274,15 +271,15 @@ admins with full system souvereignty.</DT>
 <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>
-(570 KB).
+<A HREF="cdrskin-0.4.3.tar.gz">cdrskin-0.4.3.tar.gz</A>
+(700 KB).
 </DD>
 <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>, (80 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>, (280 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>
@@ -310,13 +307,13 @@ provide libburn with invaluable examples on how to deal with DVD media.
 <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>(CD devices which offer no rw-permission are invisible to normal users.)
+</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; rwrwr- :&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>
+<DD># <KBD><B>chmod a+rw /dev/sr0 /dev/hdc</B></KBD></DD>
 </DL>
 </P>
 
@@ -353,7 +350,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.
@@ -430,7 +427,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>
@@ -448,8 +445,7 @@ and by <A HREF="http://sourceforge.net">sourceforge.net</A><BR>
 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>
+<DD><A HREF=http://stic.sourceforge.net>Some Tools for Image Collectors</A>
 <DD><A HREF=http://scdbackup.webframe.org/pppoem>
 pppoem, a DSL throughput monitor (mainly for Linux kernel 2.4)</A>
 </DL>

cdrskin/cdrskin_timestamp.h

@@ -1 +1 @@
-#define Cdrskin_timestamP "2007.03.12.110001"
+#define Cdrskin_timestamP "2008.02.01.100001"

cdrskin/compile_cdrskin.sh

@@ -1,13 +1,13 @@
 #!/bin/sh
 
 # compile_cdrskin.sh  
-# Copyright 2005 - 2006 Thomas Schmitt, scdbackup@gmx.net, GPL
+# Copyright 2005 - 2008 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_4"
+libvers="-DCdrskin_libburn_0_4_2"
 cleanup_src_or_obj="libburn/cleanup.o"
 libdax_msgs_o="libburn/libdax_msgs.o"
 libdax_audioxtr_o="libburn/libdax_audioxtr.o"
@@ -33,15 +33,15 @@ do
     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"
+  elif test "$i" = "-libburn_0_4_2"
   then
-    libvers="-DCdrskin_libburn_0_3_4"
+    libvers="-DCdrskin_libburn_0_4_2"
     libdax_audioxtr_o="libburn/libdax_audioxtr.o"
     libdax_msgs_o="libburn/libdax_msgs.o"
     cleanup_src_or_obj="libburn/cleanup.o"
   elif test "$i" = "-libburn_svn"
   then
-    libvers="-DCdrskin_libburn_0_3_5"
+    libvers="-DCdrskin_libburn_0_4_3"
     libdax_audioxtr_o="libburn/libdax_audioxtr.o"
     libdax_msgs_o="libburn/libdax_msgs.o"
     cleanup_src_or_obj="libburn/cleanup.o"
@@ -68,10 +68,7 @@ do
     do_strip=1
   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"
@@ -79,7 +76,7 @@ do
     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_0_4_2    set macro to match libburn-0.4.2."
     echo "  -libburn_svn      set macro to match current libburn-SVN."
     echo "  -no_largefile     do not use 64 bit off_t (must match libburn)."
     echo "  -do_not_compile_cdrskin  omit compilation of cdrskin/cdrskin."
@@ -87,8 +84,7 @@ do
     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"
@@ -133,6 +129,7 @@ then
     \
     libburn/sg.o \
     libburn/write.o \
+    libburn/read.o \
     $libdax_audioxtr_o \
     $libdax_msgs_o \
     \

cdrskin/convert_man_to_html.sh

@@ -45,17 +45,19 @@ 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/See section FILES/See section <A HREF="#FILES">FILES<\/A>/' \
   -e 's/See section EXAMPLES/See section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
   <"$2" >"$htmlpage"
 

cdrskin/wiki_plain.txt

@@ -1,7 +1,7 @@
 --------------------------------------------------------------------------
                        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.'''
 
@@ -17,14 +17,13 @@ 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 dual layer DVD 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,6 +79,39 @@ 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.
 
+--------------------------------------------------------------------------
+
+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
@@ -107,8 +139,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 +150,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 and DVD+RW 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 +167,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.
 
 
@@ -243,15 +283,16 @@ 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, but also with DVD-RAM, DVD+RW and
+even regular disk files or block devices other than CD/DVD writers.
+This is enabled by option --grow_overwriteable_iso.
+
+We are currently preparing an integrated ISO-9660 multi-session tool
+named [wiki:Xorriso xorriso] which will try to go one step beyond
+growisofs.
 
-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.
 
 --------------------------------------------------------------------------
 

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT([libburn], [0.3.4], [http://libburnia.pykix.org])
+AC_INIT([libburn], [0.4.2], [http://libburnia-project.org])
 AC_PREREQ([2.50])
 dnl AC_CONFIG_HEADER([config.h])	
 
@@ -7,35 +7,89 @@ AC_CANONICAL_TARGET
 
 AM_INIT_AUTOMAKE([subdir-objects])
 
-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.
+dnl Notes by ts A71207 - A80126 :
 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
+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 The name of the dynamic library will be 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 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 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
 BURN_MAJOR_VERSION=0
-BURN_MINOR_VERSION=3
-BURN_MICRO_VERSION=4
-BURN_INTERFACE_AGE=0
-BURN_BINARY_AGE=0
+BURN_MINOR_VERSION=4
+BURN_MICRO_VERSION=2
 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
+# SONAME = 11 - 7 = 4 . Library name = libburn.so.4.7.0
+LT_CURRENT=11
+LT_REVISION=0
+LT_AGE=7
 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
 
 AC_SUBST(LT_RELEASE)
@@ -44,6 +98,12 @@ AC_SUBST(LT_REVISION)
 AC_SUBST(LT_AGE)
 AC_SUBST(LT_CURRENT_MINUS_AGE)
 
+# 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
 

doc/comments

@@ -33,7 +33,7 @@ scope by help of existing cdrecord frontends.
 
 - 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
@@ -43,6 +43,11 @@ scope by help of existing cdrecord frontends.
            ISO 9660 disk image. This may then be brought to CD via libburn.
            libisofs is to be the foundation of our upcoming mkisofs emulation.
 
+- libisoburn is an add-on to libburn and libisofs which 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.
+
 - 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
@@ -54,6 +59,13 @@ scope by help of existing cdrecord frontends.
            runs, though.
            See cdrskin/README for more.
 
+- xorriso  is an upcomming application of all three libraries which creates,
+           loads, manipulates and writes ISO 9660 filesystem images with
+           Rock Ridge extensions. Manipulation will not only be adding or
+           overwriting of files but also deletion, renaming, and attribute
+           changing.
+           See SVN of libisoburn, man test/xorriso.1, test/compile_xorriso.sh
+
 - "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
@@ -89,7 +101,7 @@ 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 .
+(see: libburn/libburn.h) as provided on  http://libburnia-project.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.
 

doc/cookbook.txt

@@ -1,11 +1,11 @@
-libburnia.pykix.org Optical Media Rotisserie Recipes as of February 2007
+libburnia-project.org Optical Media Rotisserie Recipes as of August 2007
 
 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)
 - Sequential DVD-R[W] Cookbook
-- DVD+R Cookbook (still emerging)
+- DVD+R Cookbook
 
 -------------------------------------------------------------------------------
                          TAO Multi-Session CD Cookbook
@@ -18,7 +18,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>
 
 -------------------------------------------------------------------------------
 
@@ -215,7 +215,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>
 
 -------------------------------------------------------------------------------
 
@@ -405,7 +405,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>
 
 -------------------------------------------------------------------------------
 
@@ -680,7 +680,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>
 
 -------------------------------------------------------------------------------
 
@@ -788,12 +788,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.
@@ -860,7 +860,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 +990,12 @@ close session if multi-session is demanded.
 -------------------------------------------------------------------------------
 
 -------------------------------------------------------------------------------
-
-                              INCOMPLETE YET
-
                               DVD+R 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>
 
 -------------------------------------------------------------------------------
 
@@ -1063,7 +1061,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)
 
@@ -1078,17 +1076,28 @@ libburn obtains the necessary logical track number from Last Track Number in
 Last Session from the reply of 51h READ DISC INFORMATION requesting
 Data Type 000b.
 (mmc5r03c.pdf 6.22) 
+
 After each track 5Bh CLOSE TRACK SESSION Close Function 010b with Logical Track
 Number 0 closes the DVD+R session but keeps the media appendable.
 (mmc5r03c.pdf 6.3.3.4.3)
-
-
->>> This is not tested yet. growisofs has code for that gesture but explicitly 
-    avoids to use it. Instead it recommends to fill up the media with zeros.
-Eventually 5Bh CLOSE TRACK SESSION Close Function 101b is used to finalize
-the media with minimal radius. After that the disc is not appendable any more !
+If the media shall not stay appendable then the last DVD+R session is to be
+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, 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) :

doc/ddlp.txt

@@ -0,0 +1,388 @@
+-------------------------------------------------------------------------------
+
+Users of modern desktop Linux installations report misburns with CD/DVD
+recording due to concurrency problems.
+
+This text describes two locking protocols which have been developed by our
+best possible effort. But finally they rather serve as repelling example of
+what would be needed in user space to achieve an insufficient partial solution.
+
+Ted Ts'o was so friendly to help as critic with his own use cases. It turned
+out that we cannot imagine a way in user space how to cover reliably the needs
+of callers of libblkid and the needs of our burn programs.
+
+-------------------------------------------------------------------------------
+Content:
+
+The "Delicate Device Locking Protocol" shall demonstrate our sincere
+consideration of the problem.
+
+"What are the Stumble Stones ?" lists reasons why the effort finally failed.
+
+-----------------------------------------------------------------------------
+
+
+                      Delicate Device Locking Protocol
+               (a joint sub project of cdrkit and libburnia)
+                       (contact: scdbackup@gmx.net )
+
+Our projects provide programs which allow recording of data on CD or DVD.
+We encounter an increasing number of bug reports about spoiled burn runs and
+wasted media which obviously have one common cause: interference by other
+programs which access the drive's device files.
+There is some riddling about which gestures exactly are dangerous for
+ongoing recordings or can cause weirdly misformatted drive replies to MMC 
+commands. 
+We do know, nevertheless, that these effects do not occur if no other program
+accesses a device file of the drive while our programs use it. 
+
+DDLP shall help to avoid collisions between programs in the process of
+recording to a CD or DVD drive and other programs which access that drive.
+The protocol intends to provide advisory locking. So any good-willing program
+has to take some extra precautions to participate.
+
+If a program does not feel vulnerable to disturbance, then the precautions
+impose much less effort than if the program feels the need for protection.
+
+Two locking strategies are specified:
+DDLP-A operates on device files only. It is very Linux specific.
+DDLP-B adds proxy lock files, inspired by FHS /var/lock standard.
+
+
+                                  DDLP-A
+
+This protocol relies on the hardly documented feature open(O_EXCL | O_RDWR)
+with Linux device files and on POSIX compliant fcntl(F_SETLK).
+
+Other than the original meaning of O_EXCL with creating regular files, the
+effect on device files is mutual exclusion of access. I.e. if one
+filedescriptor is open on that combination of major-minor device number, then
+no other open(O_EXCL) will succeed. But open() without O_EXCL would succeed.
+So this is advisory and exclusive locking.
+With kernel 2.6 it seems to work on all device drivers which might get used
+to access a CD/DVD drive.
+
+The vulnerable programs shall not start their operation before they occupied a
+wide collection of drive representations.
+Non-vulnerable programs shall take care to detect the occupation of _one_ such
+representation.
+
+                          So for Friendly Programs
+
+A program which does not feel vulnerable to disturbance is urged to access
+CD/DVD drives by opening a file descriptor which will uphold the lock
+as long as it does not get closed. There are two alternative ways to achieve
+this.
+Very reliable is  
+
+  open( some_path , O_EXCL | ...)
+
+But O_EXCL imposes restrictions and interferences:
+- O_EXCL | O_RDONLY does not succeed with /dev/sg* !
+- O_EXCL cannot provide shared locks for programs which only want to lock
+  against burn programs but not against their own peers.
+- O_EXCL keeps from obtaining information by harmless activities.
+- O_EXCL already has a meaning with devices which are mounted as filesystems.
+  This priority meaning is more liberal than the one needed for CD/DV recording
+  protection.
+
+So it may be necessary to use a cautious open() without O_EXCL and to aquire
+a POSIX lock via fcntl(). "Cautious" means to add O_NDELAY to the flags of
+open(), because this is declared to avoid side effects within open().
+
+With this gesture it is important to use the paths expected by our burn
+programs: /dev/sr[0..255] /dev/scd[0..255] /dev/sg[0..255] /dev/hd[a..z]
+because fcntl(F_SETLK) does not lock the device but only a device-inode.
+
+  std_path = one of the standard device files:
+               /dev/sr[0..255] /dev/scd[0..255] /dev/sg[0..255] /dev/hd[a..z]
+             or a symbolic link pointing to one of them.
+  open( std_path , ... | O_NDELAY)
+  fcntl(F_SETLK) and close() on failure
+  ... eventually disable O_NDELAY by fcntl(F_SETFL) ...
+
+There is a pitfall mentioned in man 2 fcntl :
+ "locks are automatically released [...] if it closes any file descriptor
+  referring to a file on which locks are held. This is bad [...]"
+So you may have to re-lock after some temporary fd got closed.
+
+
+                            Vulnerable Programs
+
+For programs which do feel vulnerable, O_EXCL would suffice for the /dev/hd*
+device file family and their driver. But USB and SATA recorders appear with
+at least two different major-minor combinations simultaneously.
+One as /dev/sr* alias /dev/scd*, the other as /dev/sg*.
+The same is true for ide-scsi or recorders attached to SCSI controllers.
+
+So, in order to lock any access to the recorder, one has to open(O_EXCL)
+not only the device file that is intended for accessing the recorder but also
+a device file of any other major-minor representation of the recorder.
+This is done via the SCSI address parameter vector (Host,Channel,Id,Lun)
+and a search on standard device file paths /dev/sr* /dev/scd* /dev/sg*.
+In this text the alternative device representations are called "siblings".
+
+For finding them, it is necessary to apply open() to many device files which
+might be occupied by delicate operations. On the other hand it is very
+important to occupy all reasonable representations of the drive.
+So the reading of the (Host,Channel,Id,Lun) parameters demands an 
+open(O_RDONLY | O_NDELAY) _without_ fcntl() in order to find the outmost
+number of representations among the standard device files. Only ioctls
+SCSI_IOCTL_GET_IDLUN and SCSI_IOCTL_GET_BUS_NUMBER are applied.
+Hopefully this gesture is unable to cause harmful side effects on kernel 2.6.
+
+At least one file of each class sr, scd and sg should be found to regard
+the occupation as satisfying. Thus corresponding sr-scd-sg triplets should have
+matching ownerships and access permissions.
+One will have to help the sysadmins to find those triplets.
+
+A spicy detail is that sr and scd may be distinct device files for the same
+major-minor combination.  In this case fcntl() locks on both are needed
+but O_EXCL can only be applied to one of them.
+
+
+An open and free implementation ddlpa.[ch] is provided as
+  http://libburnia.pykix.org/browser/libburn/trunk/libburn/ddlpa.h?format=txt
+  http://libburnia.pykix.org/browser/libburn/trunk/libburn/ddlpa.c?format=txt
+The current version of this text is 
+  http://libburnia.pykix.org/browser/libburn/trunk/doc/ddlp.txt?format=txt
+
+Put ddlpa.h and ddlpa.c into the same directory and compile as test program by
+  cc -g -Wall -DDDLPA_C_STANDALONE -o ddlpa ddlpa.c
+
+Use it to occupy a drive's representations for a given number of seconds
+  ./ddlpa /dev/sr0 300
+
+It should do no harm to any of your running activities.
+If it does: Please, please alert us.
+
+Your own programs should not be able to circumvent the occupation if they
+obey above rules for Friendly Programs.
+Of course ./ddlpa should be unable to circumvent itself.
+
+A successfull occupation looks like
+  DDLPA_DEBUG: ddlpa_std_by_rdev("/dev/scd0") = "/dev/sr0"
+  DDLPA_DEBUG: ddlpa_collect_siblings() found "/dev/sr0"
+  DDLPA_DEBUG: ddlpa_collect_siblings() found "/dev/scd0"
+  DDLPA_DEBUG: ddlpa_collect_siblings() found "/dev/sg0"
+  DDLPA_DEBUG: ddlpa_occupy()        : '/dev/scd0'
+  DDLPA_DEBUG: ddlpa_occupy() O_EXCL : '/dev/sg0'
+  DDLPA_DEBUG: ddlpa_occupy() O_EXCL : '/dev/sr0'
+  ---------------------------------------------- Lock gained
+  ddlpa: opened           /dev/sr0
+  ddlpa: opened siblings: /dev/scd0 /dev/sg0
+  slept 1 seconds of 300
+
+Now an attempt via device file alias /dev/NEC must fail:
+  DDLPA_DEBUG: ddlpa_std_by_rdev("/dev/NEC") = "/dev/sg0"
+  DDLPA_DEBUG: ddlpa_collect_siblings() found "/dev/sr0"
+  DDLPA_DEBUG: ddlpa_collect_siblings() found "/dev/scd0"
+  DDLPA_DEBUG: ddlpa_collect_siblings() found "/dev/sg0"
+  Cannot exclusively open '/dev/sg0'
+  Reason given    : Failed to open O_RDWR | O_NDELAY | O_EXCL : '/dev/sr0'
+  Error condition : 16 'Device or resource busy'
+
+With hdc, of course, things are trivial
+  DDLPA_DEBUG: ddlpa_std_by_rdev("/dev/hdc") = "/dev/hdc"
+  DDLPA_DEBUG: ddlpa_occupy() O_EXCL : '/dev/hdc'
+  ---------------------------------------------- Lock gained
+  ddlpa: opened           /dev/hdc
+  slept 1 seconds of 1
+
+
+Ted Ts'o provided program  open-cd-excl  which allows to explore open(2) on
+device files with combinations of read-write, O_EXCL, and fcntl().
+(This does not mean that Ted endorsed our project yet. He helps exploring.)
+
+Friendly in the sense of DDLP-A would be any run which uses at least one of
+the options -e (i.e. O_EXCL) or -f (i.e. F_SETLK, applied to a file
+descriptor which was obtained from a standard device file path).
+The code is available under GPL at
+  http://libburnia.pykix.org/browser/libburn/trunk/test/open-cd-excl.c?format=txt
+To be compiled by
+  cc -g -Wall -o open-cd-excl open-cd-excl.c
+
+Options:
+  -e : open O_EXCL
+  -f : aquire lock by fcntl(F_SETLK) after sucessful open
+  -i : do not wait in case of success but exit 0 immediately
+  -r : open O_RDONLY , with -f use F_RDLCK
+  -w : open O_RDWR   , with -f use F_WRLCK
+  plus the path of the devce file to open.
+
+Friendly Programs would use gestures like:
+  ./open-cd-excl -e -r /dev/sr0
+  ./open-cd-excl -e -w /dev/sg1
+  ./open-cd-excl -e -w /dev/black-drive
+  ./open-cd-excl -f -r /dev/sg1
+  ./open-cd-excl -e -f -w /dev/sr0
+
+Ignorant programs would use and cause potential trouble by:
+  ./open-cd-excl -r /dev/sr0
+  ./open-cd-excl -w /dev/sg1
+  ./open-cd-excl -f -w /dev/black-drive
+where "/dev/black-drive" is _not_ a symbolic link to
+any of /dev/sr* /dev/scd* /dev/sg* /dev/hd*, but has an own inode.
+
+Prone to failure without further reason is:
+  ./open-cd-excl -e -r /dev/sg1
+
+
+----------------------------------------------------------------------------
+
+                                  DDLP-B
+
+This protocol relies on proxy lock files in some filesystem directory. It can
+be embedded into DDLP-A or it can be used be used standalone, outside DDLP-A.
+
+DDLP-A shall be kept by DDLP-B from trying to access any device file which
+might already be in use. There is a problematic gesture in DDLP-A when SCSI
+address parameters are to be retrieved. For now this gesture seems to be
+harmless. But one never knows.
+Vice versa DDLP-B may get from DDLP-A the service to search for SCSI device
+file siblings. So they are best as a couple.
+
+But they are not perfect. Not even as couple. fcntl() locking is flawed.
+ 
+
+There is a proxy file locking protocol described in FHS:
+  http://www.pathname.com/fhs/pub/fhs-2.3.html#VARLOCKLOCKFILES
+
+But it has shortcommings (see below). Decisive obstacle for its usage are the
+possibility for stale locks and the lack of shared locks.
+
+DDLP-B rather defines a "path prefix" which is advised to be
+  /tmp/ddlpb-lock-
+This prefix will get appended "device specific suffixes" and then form the path
+of a "lockfile".
+Not the existence of a lockfile but its occupation by an fcntl(F_SETLK) will
+constitute a lock. Lockfiles may get prepared by the sysadmin in directories
+where normal users are not allowed to create new files. Their rw-permissions
+then act as additional access restriction to the device files.
+The use of fcntl(F_SETLK) will prevent any stale locks after the process ended.
+It will also allow to obtain shared locks as well as exclusive locks.
+
+There are two classes of device specific suffixes:
+
+- Device file path suffix. Absolute paths only. "/" gets replaced by "_-". 
+  Eventual "_-" in path gets replaced by "_-_-". The leading group of "_-"
+  is always interpreted as a group of "/", though.  E.g.:
+    /dev/sr0           <-> "_-dev_-sr0"
+    /mydevs/burner/nec <-> "_-mydevs_-burners_-nec"
+    /dev/rare_-name    <-> "_-dev_-rare_-_-name"
+    ///strange/dev/x   <-> "_-_-_-strange_-dev_-x"
+
+- st_rdev suffix. A hex representation of struct stat.st_rdev. Capital letters.
+  The number of characters is pare with at most one leading 0. I.e. bytewise
+  printf("%2.2X") beginning with the highest order byte that is not zero.
+  E.g. : "0B01", "2200", "01000000000004001"
+
+If a lockfile does not exist and cannot be created then this shall not keep
+a program from working on a device. But if a lockfile exists and if permissions
+or locking state do not allow to obtain a lock of the appropirate type, then
+this shall prevent any opening of device file in question resp. shall cause
+immediate close(2) of an already opened device file.
+
+The vulnerable programs shall not start their operation before they locked a
+wide collection of drive representations.
+
+Non-vulnerable programs shall take care to lock the suffix resulting from the
+path they will be using and the suffix from the st_rdev from that path.
+The latter is to be obtained by call stat(2).
+
+Locks get upheld as long as their file descriptor is not closed or no other
+incident as described in man 2 fcntl releases the lock.
+
+So with shared locks there are no imandatory further activities after they
+have been obtained.
+
+In case of exclusive locks, the file has to have been opened for writing and
+must be truncated to 0 bytes length immediately after obtaining the lock.
+When releasing an exclusive lock it is a nice gesture to
+already do this truncation.
+Then a /var/lock/ compatible first line has to be written.
+E.g. by:  printf("%10u\n",(unsigned) getpid()) yielding "      1230\n".
+
+Any further lines are optional. They shall have the form Name=Value and must
+be printable cleartext. If such further lines exist, then the last one must
+have the name "endmark".
+Defined Names are:
+  hostid   =hostname of the machine where the process number of line 1 is valid
+  start    =start time of lock in seconds since 1970. E.g: 1177147634.592410
+  program  =self chosen name of the program which obtained the lock
+  argv0    =argv[0] of that program
+  mainpath =device file path which will be used for operations by that program
+  path     =device file path which lead to the lock
+  st_rdev  =st_rdev suffix which is associated with path
+  scsi_hcil=eventual SCSI parameters Host,Channel,Id,Lun
+  scsi_bus =eventual SCSI parameter Bus
+  endmark  =declares the info as complete.
+Any undefined name or a line without "=" shall be handled as comment.
+"=" in the value is allowed. Any line beginning with an "=" character is an
+extension of the previous value.
+
+If programs encounter an exclusive lock, they are invited to read the content
+of the lockfile anyway. But they should be aware that the info might be in the
+progress of emerging. There is a race condition possible in the short time
+between obtaining the exclusive lock and erasing the file content.
+If it is not crucial to obtain most accurate info then one may take the newline
+of the first line as indicator of a valid process number and the "endmark"
+name as indicator that the preceding lines are valid.
+Very cautious readers should obtain the info twice with a decent waiting period
+inbetween. Only if both results are identical they should be considered valid.
+
+
+There is no implementation of DDLP-B yet.
+
+
+ 
+----------------------------------------------------------------------------
+What are the Stumble Stones ?
+----------------------------------------------------------------------------
+
+Any of the considered locking mechanisms has decisive shortcommings
+which keeps it from being the solution to all known legitimate use cases.
+
+The attempt has failed to compose a waterproof locking mechanism from means of
+POSIX, FHS and from hardly documented Linux open(O_EXCL) on device files.
+The resulting mechanisms would need about 1000 lines of code and still do
+not close all gaps resp. cover the well motivated use cases.
+This attempt you see above: DDLP-A and DDLP-B.
+
+
+Summary of the reasons why the established locking mechanisms do not suffice:
+
+None of the mechanisms can take care of the double device driver identity
+sr versus sg. To deduce the one device file from the other involves the need
+to open many other (possibly unrelated) device files with the risk to disturb
+them.
+This hard to solve problem is aggravated by the following facts.
+
+Shortcommings of Linux specific open(O_EXCL) :
+
+- O_EXCL | O_RDONLY does not succeed with /dev/sg*
+- O_EXCL cannot provide shared locks for programs which only want to lock
+  against burn programs but not against their own peers.
+- O_EXCL keeps from obtaining information by harmless activities.
+- O_EXCL already has a meaning with devices which are mounted as filesystems.
+  This priority meaning is more liberal than the one needed for CD/DV recording
+  protection.
+
+Shortcommings of POSIX fcntl(F_SETLK) :
+
+- fcntl() demands an open file descriptor. open(2) might have side effects.
+- fcntl() locks can be released inadvertedly by submodules which just open and
+  close the same file (inode ?) without refering to fcntl locks in any way.
+  See man 2 fcntl "This is bad:". 
+  Stacking of software modules is a widely used design pattern. But fcntl()
+  cannot cope with that.
+
+Shortcommings of FHS /var/lock/ :
+
+- Stale locks are possible.
+- It is necessary to create a file (using the _old_ meaning of O_EXCL flag ?)
+  but /var/lock/ might not be available early during system start and it often
+  has restrictive permission settings.
+- There is no way to indicate a difference between exclusive and shared locks.
+- The FHS prescription relies entirely on the basename of the device file path.
+

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,5 +1,25 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
+
+/* 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
+*/
+
+
 #include "libburn.h"
 #include "transport.h"
 #include "drive.h"
@@ -7,9 +27,12 @@
 #include "options.h"
 #include "async.h"
 #include "init.h"
+#include "file.h"
 #include "back_hacks.h"
 
 #include <pthread.h>
+#include <sys/types.h>
+#include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -53,6 +76,12 @@ struct write_opts
 	struct burn_disc *disc;
 };
 
+struct fifo_opts
+{
+	struct burn_source *source;
+	int flag;
+};
+
 
 struct w_list
 {
@@ -67,10 +96,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)
 {
@@ -86,6 +117,11 @@ static void add_worker(struct burn_drive *d, WorkerFunc f, void *data)
 {
 	struct w_list *a;
 	struct w_list *tmp;
+	pthread_attr_t *attr_pt = NULL;
+
+#ifdef Libburn_create_detached_threadS
+	pthread_attr_t attr;
+#endif
 
 	a = malloc(sizeof(struct w_list));
 	a->drive = d;
@@ -96,26 +132,65 @@ 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;
 
+#ifdef Libburn_detach_done_workeR
+	int ret;
+	char msg[80];
+#endif
+
 	for (a = workers; a; l = a, a = a->next)
 		if (a->thread == th) {
 			if (l)
 				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.
+			*/
+			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,8 +205,13 @@ 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;
 }
 
@@ -165,12 +245,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;
@@ -189,7 +270,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;
 		}
@@ -211,9 +292,6 @@ 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()); */
@@ -233,12 +311,17 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 			0, 0);
 		return;
 	}
+	/* 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 */
+	/* 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() */
 	if ((drive->current_profile != 0x0a &&
 	     drive->current_profile != 0x13 &&
 	     drive->current_profile != 0x14 &&
@@ -247,6 +330,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)
 	   ) {
 		libdax_msgs_submit(libdax_messenger, drive->global_index,
 			0x00020130,
@@ -287,6 +372,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 */
 
@@ -320,7 +413,13 @@ void burn_disc_format(struct burn_drive *drive, off_t size, int flag)
 
 static void *write_disc_worker_func(struct w_list *w)
 {
+	struct burn_drive *d = w->u.write.drive;
+
+	d->thread_pid = getpid();
+	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 
 	 */
@@ -334,17 +433,6 @@ 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
-
-
-	/* 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;
 
 	/* ts A61006 */
 	/* a ssert(!SCAN_GOING()); */
@@ -357,8 +445,24 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 			0, 0);
 		return;
 	}
+
+	/* 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;
+
+	if (opts->drive->drive_role == 0) {
+		libdax_msgs_submit(libdax_messenger, opts->drive->global_index,
+			0x00020146,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+			"Drive is a virtual placeholder (null-drive)", 0, 0);
+		return;
+	}
+
 	/* ts A61007 : obsolete Assert in spc_select_write_params() */
-	if (!opts->drive->mdata->valid) {
+	if (opts->drive->drive_role == 1 && !opts->drive->mdata->valid) {
 		libdax_msgs_submit(libdax_messenger,
 				opts->drive->global_index, 0x00020113,
 				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
@@ -372,48 +476,13 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 	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
-		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,
 				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 				reasons, 0, 0);
 		return;
-#endif /* Libburn_precheck_write_ruleS */
-
 	}
 
-
-#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;
-
-	/* <<< 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;
@@ -425,6 +494,40 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 	add_worker(opts->drive, (WorkerFunc) write_disc_worker_func, &o);
 }
 
+
+static void *fifo_worker_func(struct w_list *w)
+{
+	burn_fifo_source_shoveller(w->u.fifo.source, w->u.fifo.flag);
+	remove_worker(pthread_self());
+	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 = calloc(fs->chunksize, fs->chunks);
+	if (fs->buf == NULL) {
+		/* >>> could not start ring buffer */;
+		return -1;
+	}
+
+	o.source = source;
+	o.flag = flag;
+	add_worker(NULL, (WorkerFunc) fifo_worker_func, &o);
+	fs->is_started = 1;
+	return 1;
+}
+
+
+#ifdef Libburn_has_burn_async_join_alL
+
+/* ts A71019 : never used */
 void burn_async_join_all(void)
 {
 	void *ret;
@@ -432,3 +535,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,10 @@
 
 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);
+
+
 #endif /* BURN__ASYNC_H */

libburn/ddlpa.c

@@ -0,0 +1,614 @@
+
+/* ddlpa
+   Implementation of Delicate Device Locking Protocol level A.
+   Copyright (C) 2007 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under any of the following licenses: GPL, LGPL, BSD. Choose one.
+
+
+   Compile as test program:
+
+     cc -g -Wall \
+        -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1 -D_LARGEFILE64_SOURCE \
+        -DDDLPA_C_STANDALONE -o ddlpa ddlpa.c
+
+   The system macros enable 64-bit off_t and open(2) flag O_LARGEFILE, which
+   are not absolutely necessary but explicitely take into respect that
+   our devices can offer more than 2 GB of addressable data. 
+
+   Run test program:
+
+     ./ddlpa /dev/sr0 15
+     ./ddlpa 0,0,0    15
+
+*/
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <scsi/scsi.h>
+
+
+/* All callers of ddlpa must do this */
+#include "ddlpa.h"
+
+
+/* 1 = Enable progress message on stderr, 0 = normal silent operation */
+static int ddlpa_debug_mode = 1;
+
+
+/* #define _GNU_SOURCE  or  _LARGEFILE64_SOURCE  to get real O_LARGEFILE */
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0
+#endif
+
+
+/* ----------------------- private -------------------- */
+
+
+static int ddlpa_new(struct ddlpa_lock **lck, int o_flags, int ddlpa_flags)
+{
+	int i;
+	struct ddlpa_lock *o;
+
+	o = *lck = (struct ddlpa_lock *) malloc(sizeof(struct ddlpa_lock));
+	if (o == NULL)
+		return ENOMEM;
+	for (i = 0; i < sizeof(struct ddlpa_lock); i++)
+		((char *) o)[i] = 0;
+	o->path = NULL;
+	o->fd = -1;
+	for (i = 0; i < DDLPA_MAX_SIBLINGS; i++)
+		o->sibling_fds[i] = -1;
+	o->errmsg = NULL;
+
+	o->o_flags = o_flags;
+	o->ddlpa_flags = ddlpa_flags;
+	return 0;
+}
+
+
+static int ddlpa_enumerate(struct ddlpa_lock *o, int *idx,
+			char path[DDLPA_MAX_STD_LEN + 1])
+{
+	if (*idx < 0)
+		*idx = 0;
+
+	if (*idx < 26)
+		sprintf(path, "/dev/hd%c", 'a' + *idx);
+	else if (*idx < 256 + 26)
+		sprintf(path, "/dev/sr%d", *idx - 26);
+	else if (*idx < 2 * 256 + 26)
+		sprintf(path, "/dev/scd%d", *idx - 256 - 26);
+	else if (*idx < 3 * 256 + 26)
+		sprintf(path, "/dev/sg%d", *idx - 2 * 256 - 26);
+	else
+		return 1;
+	(*idx)++;
+	return 0;
+}
+
+
+static int ddlpa_std_by_rdev(struct ddlpa_lock *o)
+{
+	int idx = 0;
+	char try_path[DDLPA_MAX_STD_LEN+1];
+	struct stat path_stbuf, try_stbuf;
+
+	if (!o->path_is_valid)
+		return EFAULT;
+	if (stat(o->path, &path_stbuf) == -1)
+		return errno;
+
+	while (ddlpa_enumerate(o, &idx, try_path) == 0) {
+		if (stat(try_path, &try_stbuf) == -1)
+			continue;
+		if (path_stbuf.st_rdev != try_stbuf.st_rdev)
+			continue;
+		strcpy(o->std_path, try_path);
+
+		if (ddlpa_debug_mode)
+			fprintf(stderr,
+			   "DDLPA_DEBUG: ddlpa_std_by_rdev(\"%s\") = \"%s\"\n",
+			    o->path, o->std_path);
+
+		return 0;
+	}
+	return ENOENT;
+}
+
+
+/* Caution : these tests are valid only with standard paths */
+
+static int ddlpa_is_scsi(struct ddlpa_lock *o, char *path)
+{
+	return (strncmp(path, "/dev/s", 6) == 0);
+}
+
+static int ddlpa_is_sg(struct ddlpa_lock *o, char *path)
+{
+	return (strncmp(path, "/dev/sg", 7) == 0);
+}
+
+static int ddlpa_is_sr(struct ddlpa_lock *o, char *path)
+{
+	return (strncmp(path, "/dev/sr", 7) == 0);
+}
+
+static int ddlpa_is_scd(struct ddlpa_lock *o, char *path)
+{
+	return (strncmp(path, "/dev/scd", 8) == 0);
+}
+
+
+static int ddlpa_fcntl_lock(struct ddlpa_lock *o, int fd, int l_type)
+{
+	struct flock lockthing;
+	int ret;
+
+	memset(&lockthing, 0, sizeof(lockthing));
+	lockthing.l_type = l_type;
+	lockthing.l_whence = SEEK_SET;
+	lockthing.l_start = 0;
+	lockthing.l_len = 0;
+	ret = fcntl(fd, F_SETLK, &lockthing);
+	if (ret == -1)
+		return EBUSY;
+	return 0;
+}
+
+
+static int ddlpa_occupy(struct ddlpa_lock *o, char *path, int *fd,
+			int no_o_excl)
+{
+	int ret, o_flags, o_rw, l_type;
+	char *o_rwtext;
+
+	o_flags = o->o_flags | O_NDELAY;
+	if(!no_o_excl)
+		o_flags |= O_EXCL;
+	o_rw = (o_flags) & (O_RDONLY | O_WRONLY | O_RDWR);
+	o_rwtext = (o_rw == O_RDONLY ? "O_RDONLY" :
+			(o_rw == O_WRONLY ? "O_WRONLY" :
+			(o_rw == O_RDWR ? "O_RDWR  " : "O_?rw-mode?")));
+
+	*fd = open(path, o_flags);
+	if (*fd == -1) {
+		o->errmsg = malloc(strlen(path)+160);
+		if (o->errmsg)
+			sprintf(o->errmsg,
+				"Failed to open %s | O_NDELAY %s: '%s'", 
+				o_rwtext,
+				(o_flags & O_EXCL ? "| O_EXCL " : ""), path);
+		return (errno ? errno : EBUSY);
+	}
+	if (o_rw == O_RDWR || o_rw == O_WRONLY)
+		l_type = F_WRLCK;
+	else
+		l_type = F_RDLCK;
+	ret = ddlpa_fcntl_lock(o, *fd, l_type);
+	if (ret) {
+		o->errmsg = malloc(strlen(path)+160);
+		if (o->errmsg)
+			sprintf(o->errmsg,
+				"Failed to lock fcntl(F_WRLCK) : '%s'",path);
+		close(*fd);
+		*fd = -1;
+		return ret;
+	}
+	if (ddlpa_debug_mode)
+		fprintf(stderr, "DDLPA_DEBUG: ddlpa_occupy() %s %s: '%s'\n",
+			o_rwtext,
+			(no_o_excl ? "       " : "O_EXCL "), path);
+	return 0;
+}
+
+
+static int ddlpa_obtain_scsi_adr(struct ddlpa_lock *o, char *path,
+			int *bus, int *host, int *channel, int *id, int *lun)
+{
+	int fd, ret, open_mode = O_RDONLY | O_NDELAY;
+	struct my_scsi_idlun {
+		int x;
+		int host_unique_id;
+	};
+	struct my_scsi_idlun idlun;
+
+	fd = open(path, open_mode);
+	if (fd == -1)
+		return (errno ? errno : EBUSY);
+	if (ioctl(fd, SCSI_IOCTL_GET_BUS_NUMBER, bus) == -1)
+		*bus = -1;
+	ret = ioctl(fd, SCSI_IOCTL_GET_IDLUN, &idlun);
+	close(fd);
+	if (ret  == -1)
+		return (errno ? errno : EIO);
+	*host =    (idlun.x >> 24) & 255;
+	*channel = (idlun.x >> 16) & 255;
+	*id =      (idlun.x)       & 255;
+	*lun =     (idlun.x >> 8 ) & 255;
+	return 0;
+}
+
+
+static int ddlpa_collect_siblings(struct ddlpa_lock *o)
+{
+	int idx = 0, ret, have_sg = 0, have_sr = 0, have_scd = 0;
+	dev_t path_dev;
+	ino_t path_inode;
+	struct stat stbuf;
+	char *path, try_path[DDLPA_MAX_STD_LEN+1];
+	int t_bus, t_host, t_channel, t_id, t_lun;
+	
+	if (o->ddlpa_flags & DDLPA_OPEN_GIVEN_PATH)
+		path = o->path;
+	else
+		path = o->std_path;
+	if (path[0] == 0 || o->num_siblings != 0)
+		return EFAULT;
+	if (!ddlpa_is_scsi(o, o->std_path))
+		return EFAULT;
+
+	if (stat(path, &stbuf) == -1)
+		return errno;
+	path_inode = stbuf.st_ino;
+	path_dev = stbuf.st_dev;
+	o->rdev = stbuf.st_rdev;
+	o->dev = stbuf.st_dev;
+	o->ino = stbuf.st_ino;
+	ret = ddlpa_obtain_scsi_adr(o, path,
+				&(o->bus), &(o->host), &(o->channel),
+				&(o->id), &(o->lun));
+	if (ret) {
+		o->errmsg = strdup(
+			"Cannot obtain SCSI parameters host,channel,id,lun");
+		return ret;
+	}
+	o->hcilb_is_valid = 1;
+
+	while (ddlpa_enumerate(o, &idx, try_path) == 0) {
+		if (!ddlpa_is_scsi(o, try_path))
+			continue;
+		if (stat(try_path, &stbuf) == -1)
+			continue;
+		ret = ddlpa_obtain_scsi_adr(o, try_path, 
+				&t_bus, &t_host, &t_channel, &t_id, &t_lun);
+		if (ret) {
+
+			/* >>> interpret error, memorize busy, no permission */
+
+			continue;
+		}
+		if (t_host != o->host || t_channel != o->channel ||
+		    t_id != o->id     || t_lun != o->lun)
+			continue;
+
+		if (o->num_siblings >= DDLPA_MAX_SIBLINGS) {
+			o->errmsg = 
+				strdup("Too many matching device files found");
+			return ERANGE;
+		}
+		if (ddlpa_is_sg(o, try_path))
+			have_sg = 1;
+		else if (ddlpa_is_sr(o, try_path))
+                	have_sr = 1;
+		else if (ddlpa_is_scd(o, try_path))
+                	have_scd = 1;
+		strcpy(o->sibling_paths[o->num_siblings], try_path);
+		o->sibling_rdevs[o->num_siblings] = stbuf.st_rdev;
+		o->sibling_devs[o->num_siblings] = stbuf.st_dev;
+		o->sibling_inodes[o->num_siblings] = stbuf.st_ino;
+
+		if (ddlpa_debug_mode)
+			fprintf(stderr,
+		"DDLPA_DEBUG: ddlpa_collect_siblings() found   \"%s\"\n",
+			try_path);
+
+		(o->num_siblings)++;
+	}
+	if (have_sg && have_sr && have_scd)
+		return 0;
+	if (o->ddlpa_flags & DDLPA_ALLOW_MISSING_SGRCD)
+		return 0;
+
+	o->errmsg = strdup("Did not find enough siblings");
+
+	/* >>> add more info about busy and forbidden paths */
+
+	return EBUSY;
+}
+
+
+static int ddlpa_std_by_btl(struct ddlpa_lock *o)
+{
+	int idx = 0, ret;
+	char try_path[DDLPA_MAX_STD_LEN+1];
+	int t_bus, t_host, t_channel, t_id, t_lun;
+
+	if (!o->inbtl_is_valid)
+		return EFAULT;
+
+	while (ddlpa_enumerate(o, &idx, try_path) == 0) {
+		if (!ddlpa_is_sr(o, try_path))
+			continue;
+		ret = ddlpa_obtain_scsi_adr(o, try_path, 
+				&t_bus, &t_host, &t_channel, &t_id, &t_lun);
+		if (ret) {
+
+			/* >>> interpret error, memorize busy, no permission */
+
+			continue;
+		}
+		if (t_bus != o->in_bus || t_id != o->in_target ||
+		    t_lun != o->in_lun)
+			continue;
+		strcpy(o->std_path, try_path);
+
+		if (ddlpa_debug_mode)
+			fprintf(stderr,
+			 "DDLPA_DEBUG: ddlpa_std_by_btl(%d,%d,%d) = \"%s\"\n",
+			 t_bus, t_id, t_lun, o->std_path);
+
+		return 0;
+	}
+
+	/* >>> add more info about busy and forbidden paths */
+
+	return ENOENT;
+}
+
+
+static int ddlpa_open_all(struct ddlpa_lock *o)
+{
+	int i, j, ret, no_o_excl;
+
+	if (ddlpa_is_scsi(o, o->std_path)) {
+		ret = ddlpa_collect_siblings(o);
+		if (ret)
+			return ret;
+		for (i = 0; i < o->num_siblings; i++) {
+
+			/* Watch out for the main personality of the drive. */
+			/* No need to occupy identical path or softlink path */
+			if (o->sibling_devs[i] == o->dev &&
+			    o->sibling_inodes[i] == o->ino)
+					continue;
+			/* There may be the same rdev but different inode. */
+			no_o_excl = (o->sibling_rdevs[i] == o->rdev);
+		
+			/* Look for multiply registered device drivers with
+			   distinct inodes. */	
+			for (j = 0; j < i; j++) {
+				if (o->sibling_devs[j] == o->sibling_devs[i] &&
+			   	  o->sibling_inodes[j] == o->sibling_inodes[i])
+					break;
+				if (o->sibling_rdevs[j] == o->sibling_rdevs[i])
+					no_o_excl = 1;
+			}
+			if (j < i)
+				continue;   /* inode is already occupied */
+
+			ret = ddlpa_occupy(o, o->sibling_paths[i],
+					   &(o->sibling_fds[i]), no_o_excl);
+			if (ret)
+				return ret;
+		}
+	}
+
+	if (o->ddlpa_flags & DDLPA_OPEN_GIVEN_PATH)
+		ret = ddlpa_occupy(o, o->path, &(o->fd), 0);
+	else
+		ret = ddlpa_occupy(o, o->std_path, &(o->fd), 0);
+	if (ret)
+		return ret;	
+
+	/* >>> use fcntl() to adjust O_NONBLOCK */;
+
+	return 0;
+}
+
+
+/* ----------------------- public -------------------- */
+
+
+int ddlpa_destroy(struct ddlpa_lock **lockbundle)
+{
+	struct ddlpa_lock *o;
+	int i;
+
+	o= *lockbundle;
+	if (o == NULL)
+		return 0;
+	for (i = 0; i < o->num_siblings; i++)
+		if (o->sibling_fds[i] != -1)
+			close(o->sibling_fds[i]);
+	if(o->fd != -1)
+		close(o->fd);
+	if (o->path != NULL)
+		free(o->path);
+	if (o->errmsg != NULL)
+		free(o->errmsg);
+	free((char *) o);
+	*lockbundle = NULL;
+	return 0;
+}
+
+
+int ddlpa_lock_path(char *path, int o_flags, int ddlpa_flags,
+			struct ddlpa_lock **lockbundle, char **errmsg)
+{
+	struct ddlpa_lock *o;
+	int ret;
+
+	*errmsg = NULL;
+	if (ddlpa_new(&o, o_flags, ddlpa_flags))
+		return ENOMEM;
+	*lockbundle = o;
+
+	o->path = strdup(path);
+	if (o->path == NULL)
+		return ENOMEM;
+	o->path_is_valid = 1;
+
+	ret = ddlpa_std_by_rdev(o);
+	if (ret) {
+		*errmsg = strdup(
+		  "Cannot find equivalent of given path among standard paths");	
+		return ret;
+	}
+        ret = ddlpa_open_all(o);
+	if (ret) {
+		*errmsg = o->errmsg;
+		o->errmsg = NULL;
+		ddlpa_destroy(&o);
+	}
+	return ret;
+}
+
+
+int ddlpa_lock_btl(int bus, int target, int lun,
+			int  o_flags, int ddlpa_flags,
+			struct ddlpa_lock **lockbundle, char **errmsg)
+{
+	struct ddlpa_lock *o;
+	int ret;
+
+	*errmsg = NULL;
+	ddlpa_flags &= ~DDLPA_OPEN_GIVEN_PATH;
+	if (ddlpa_new(&o, o_flags, ddlpa_flags))
+		return ENOMEM;
+	*lockbundle = o;
+	
+	o->in_bus = bus;
+	o->in_target = target;
+	o->in_lun = lun;
+	o->inbtl_is_valid = 1;
+	ret = ddlpa_std_by_btl(o);
+	if (ret) {
+		*errmsg = strdup(
+		  "Cannot find /dev/sr* with given Bus,Target,Lun");	
+		return ret;
+	}
+        ret = ddlpa_open_all(o);
+	if (ret) {
+		*errmsg = o->errmsg;
+		o->errmsg = NULL;
+		ddlpa_destroy(&o);
+		return ret;
+	}
+	return 0;
+}
+
+
+#ifdef DDLPA_C_STANDALONE
+
+/* ----------------------------- Test / Demo -------------------------- */
+
+
+int main(int argc, char **argv)
+{
+	struct ddlpa_lock *lck = NULL;
+	char *errmsg = NULL, *opened_path = NULL, *my_path = NULL;
+	int i, ret, fd = -1, duration = -1, bus = -1, target = -1, lun = -1;
+
+	if (argc < 3) {
+usage:;
+		fprintf(stderr, "usage: %s  device_path  duration\n", argv[0]);
+		exit(1);
+	}
+	my_path = argv[1];
+	sscanf(argv[2], "%d", &duration);
+	if (duration < 0)
+		goto usage;
+
+
+	/* For our purpose, only O_RDWR is a suitable access mode.
+	   But in order to allow experiments, o_flags are freely adjustable.
+
+	   Warning: Do _not_ set an own O_EXCL flag with the following calls !
+
+	   (This freedom to fail may get removed in a final version.)
+	*/
+	if (my_path[0] != '/' && my_path[0] != '.' &&
+	    strchr(my_path, ',') != NULL) {
+		/* 
+		   cdrecord style dev=Bus,Target,Lun
+		*/
+
+		sscanf(my_path, "%d,%d,%d", &bus, &target, &lun);
+		ret = ddlpa_lock_btl(bus, target, lun, O_RDWR | O_LARGEFILE,
+					 0, &lck, &errmsg);
+	} else {
+		/*
+		   This substitutes for:
+			fd = open(my_path, O_RDWR | O_EXCL | O_LARGEFILE);
+
+		*/
+
+		ret = ddlpa_lock_path(my_path, O_RDWR | O_LARGEFILE,
+					 0, &lck, &errmsg);
+	}
+	if (ret) {
+		fprintf(stderr, "Cannot exclusively open '%s'\n", my_path);
+		if (errmsg != NULL)
+			fprintf(stderr, "Reason given    : %s\n",
+				errmsg);
+		free(errmsg);
+		fprintf(stderr, "Error condition : %d '%s'\n",
+			ret, strerror(ret));
+		exit(2);
+	}
+	fd = lck->fd;
+
+	printf("---------------------------------------------- Lock gained\n");
+
+
+	/* Use fd for the usual operations on the device depicted by my_path.
+	*/
+
+
+	/* This prints an overview of the impact of the lock */
+	if (lck->ddlpa_flags & DDLPA_OPEN_GIVEN_PATH)
+		opened_path = lck->path;
+	else
+        	opened_path = lck->std_path;
+	printf("ddlpa: opened           %s", opened_path);
+
+	if (strcmp(opened_path, lck->std_path) != 0)
+		printf(" (an alias of '%s')", lck->std_path);
+	printf("\n");
+	if (lck->num_siblings > 0) {
+		printf("ddlpa: opened siblings:");
+		for (i = 0; i < lck->num_siblings; i++)
+			if (lck->sibling_fds[i] != -1)
+				printf(" %s", lck->sibling_paths[i]);
+		printf("\n");
+	}
+
+
+	/* This example waits a while. So other lock candidates can collide. */
+	for (i = 0; i < duration; i++) {
+		sleep(1);
+		fprintf(stderr, "\rslept %d seconds of %d", i + 1, duration);
+	}
+	fprintf(stderr, "\n");
+
+
+	/* When finally done with the drive, this substitutes for:
+		close(fd);
+	*/
+	if (ddlpa_destroy(&lck)) {
+		/* Well, man 2 close says it can fail. */
+		exit(3);
+	}
+	exit(0);
+}
+
+
+#endif /* DDLPA_C_STANDALONE */
+

libburn/ddlpa.h

@@ -0,0 +1,107 @@
+
+/* ddlpa
+   Implementation of Delicate Device Locking Protocol level A.
+   Copyright (C) 2007 Thomas Schmitt <scdbackup@gmx.net>
+   Provided under any of the following licenses: GPL, LGPL, BSD. Choose one.
+
+   See ../doc/ddlp.txt for a description of the protocol.
+*/
+
+#ifndef DDLPA_H_INCLUDED
+#define DDLPA_H_INCLUDED 1
+
+
+/* An upper limit for the length of standard paths and sibling paths */
+#define DDLPA_MAX_STD_LEN 15
+
+/* An upper limit for the number of siblings */
+#define DDLPA_MAX_SIBLINGS 5
+
+struct ddlpa_lock {
+
+	/* Recorded input parameters of locking call */
+	char *path;
+	int  path_is_valid;
+	int  in_bus, in_target, in_lun;
+	int  inbtl_is_valid;
+	int  ddlpa_flags;
+	int  o_flags;
+
+	/* Result of locking call */
+	char std_path[DDLPA_MAX_STD_LEN + 1];
+	int  fd;
+	dev_t rdev;
+	dev_t dev;
+	ino_t ino;
+	int  host, channel, id, lun, bus;
+	int  hcilb_is_valid;
+	int  num_siblings;
+	char sibling_paths[DDLPA_MAX_SIBLINGS][DDLPA_MAX_STD_LEN + 1];
+	int  sibling_fds[DDLPA_MAX_SIBLINGS];
+	dev_t sibling_rdevs[DDLPA_MAX_SIBLINGS];
+	dev_t sibling_devs[DDLPA_MAX_SIBLINGS];
+	ino_t sibling_inodes[DDLPA_MAX_SIBLINGS];
+
+	/* Is NULL if all goes well. Else it may contain a text message. */
+	char *errmsg;
+};
+
+
+
+/** Lock a recorder by naming a device file path. Allocate a new container.
+    @param path        Gives the file system path of the recorder
+                       as known to the calling program.
+    @param o_flags     flags for open(2). Do not use O_EXCL here because this
+                       is done automatically whenever appropriate.
+                       Advised is O_RDWR | O_LARGEFILE, eventually | O_NDELAY.
+    @param ddlpa_flags 0 = default behavior: the standard path will be opened
+                           and treated by fcntl(F_SETLK)
+                       DDLPA_OPEN_GIVEN_PATH causes the input parameter "path"
+                       to be used with open(2) and fcntl(2).
+                       DDLPA_ALLOW_MISSING_SGRCD allows to grant a lock
+                       although not all three, a sg, a sr and a scd device
+                       file have been found during sibling search. Normally
+                       this is counted as failure due to EBUSY. 
+    @param lockbundle  gets allocated and then represents the locking state
+    @param errmsg      if *errmsg is not NULL after the call, it contains an
+                       error message. Then to be released by free(3).
+                       It is NULL in case of success or lack of memory.
+    @return            0=success , else an errno compatible error number
+*/
+int ddlpa_lock_path(char *path, int  o_flags, int ddlpa_flags, 
+                    struct ddlpa_lock **lockbundle, char **errmsg);
+
+
+/** Lock a recorder by naming a Bus,Target,Lun number triple.
+    Allocate a new container.
+    @param bus         parameter to match ioctl(SCSI_IOCTL_GET_BUS_NUMBER)
+    @param target      parameter to match ioctl(SCSI_IOCTL_GET_IDLUN) &0xff
+    @param lun         parameter to match ioctl(SCSI_IOCTL_GET_IDLUN) &0xff00
+    @param o_flags     see ddlpa_lock_path().
+    @param ddlpa_flags see ddlpa_lock_path(). Flag DDLPA_OPEN_GIVEN_PATH
+                       will be ignored.
+    @param lockbundle  see ddlpa_lock_path().
+    @param errmsg      see ddlpa_lock_path().
+    @return            0=success , else an errno compatible error number
+*/
+int ddlpa_lock_btl(int bus, int target, int lun,
+                   int  o_flags, int ddlpa_flags,
+                   struct ddlpa_lock **lockbundle, char **errmsg);
+
+
+/** Release the lock by closing all filedescriptors and freeing memory.
+    @param lockbundle  the lock which is to be released. 
+                       *lockbundle will be set to NULL by this call.
+    @return            0=success , 1=failure
+*/
+int ddlpa_destroy(struct ddlpa_lock **lockbundle);
+
+
+
+/** Definitions of macros used in above functions */
+
+#define DDLPA_OPEN_GIVEN_PATH 1
+#define DDLPA_ALLOW_MISSING_SGRCD 2
+
+
+#endif /* DDLPA_H_INCLUDED */

libburn/drive.h

@@ -43,7 +43,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 +53,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);
@@ -111,4 +114,15 @@ 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 */
+int burn_drive_find_by_thread_pid(struct burn_drive **d, pid_t pid);
+
+
 #endif /* __DRIVE */

libburn/file.c

@@ -2,12 +2,21 @@
 
 #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 "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 */
@@ -93,14 +102,14 @@ 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);
@@ -108,15 +117,30 @@ struct burn_source *burn_file_source_new(const char *path, const char *subpath)
 		}
 	}
 	fs = malloc(sizeof(struct burn_source_file));
-	fs->datafd = fd1;
 
-	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;
@@ -139,14 +163,23 @@ 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));
+	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 +187,356 @@ 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 struct timespec sleeptime = { 0, 50000000}; /* 50 ms */
+
+	return nanosleep(&sleeptime, NULL);
+}
+
+
+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;
+
+	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;
+			}
+			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);
+*/
+
+	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;
+
+	if (fs->inp != NULL)
+		burn_source_free(fs->inp);
+	if (fs->buf != NULL)
+		free(fs->buf);
+	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;
+	char *bufpt;
+
+	fs->thread_pid = getpid();
+	fs->thread_pid_valid = 1;
+
+	bufsize = fs->chunksize * fs->chunks;
+	while (!fs->end_of_consumption) {
+
+		/* wait for enough buffer space available */
+		wpos = fs->buf_writepos;
+		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->chunksize)
+					trans_end = 1;
+			}
+			if (free_bytes >= fs->chunksize)
+		break;
+			fifo_sleep(0);
+		}
+
+		/* prepare the receiving memory */
+		bufpt = fs->buf + wpos;
+		if (trans_end) {
+			bufpt = calloc(fs->chunksize, 1);
+			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->chunksize);
+		else
+			ret = fs->inp->read_xt( fs->inp,
+				 (unsigned char *) bufpt, fs->chunksize);
+		if (ret > 0)
+			fs->in_counter += ret;
+		else if (ret == 0)
+	break; /* EOF */
+		else {
+			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;
+		}
+
+		/* activate read chunk */
+		if (ret > fs->chunksize) /* beware of ill custom burn_source */
+			ret = fs->chunksize;
+		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->chunksize - (bufsize - wpos));
+			free(bufpt);
+			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.
+	*/
+	free(fs->buf); /* Give up fifo buffer. Next fifo might start soon. */
+	fs->buf = NULL;
+
+	return (fs->input_error == 0);
+}
+
+
+int burn_fifo_cancel(struct burn_source *source)
+{
+	struct burn_source_fifo *fs = source->data;
+
+	burn_source_cancel(fs->inp);
+	return(1);
+}
+
+
+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 = malloc(sizeof(struct burn_source_fifo));
+	if (fs == NULL)
+		return NULL;
+	fs->is_started = 0;
+	fs->thread_pid = 0;
+	fs->thread_pid_valid = 0;
+	fs->inp = NULL; /* set later */
+	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;
+
+	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;
+}
+

libburn/file.h

@@ -5,13 +5,58 @@
 
 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;
+
+	int thread_pid;
+	int thread_pid_valid;
+
+	/* the burn_source for which this fifo is acting as proxy */
+	struct burn_source *inp;
+
+	/* <<< 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;
+};
+
+
+/** 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);
+
+
 #endif /* LIBBURN__FILE_H */

libburn/init.c

@@ -8,12 +8,18 @@
 #include <stdio.h>
 #include <signal.h>
 #include <string.h>
+#include <stdlib.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,9 +32,22 @@ struct libdax_msgs *libdax_messenger= NULL;
 
 int burn_running = 0;
 
-/* ts A60813 : wether to use O_EXCL and/or O_NONBLOCK in libburn/sg.c */
+/* ts A60813 : Linux: wether to use O_EXCL on open() of device files */
 int burn_sg_open_o_excl = 1;
 
+/* ts A70403 : 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 :
+    0= default family
+    1= sr
+    2= scd
+   (3= st)
+    4= sg
+*/
+int burn_sg_use_family = 0;
+
 /* O_NONBLOCK was hardcoded in enumerate_ata() which i hardly use.
    For enumerate_sg() it seems ok.
    So it should stay default mode until enumerate_ata() without O_NONBLOCK
@@ -40,7 +59,6 @@ int burn_sg_open_o_nonblock = 1;
 	    to unconditional abort of the process  */
 int burn_sg_open_abort_busy = 0;
 
-
 /* ts A61002 */
 
 #include "cleanup.h"
@@ -48,6 +66,10 @@ 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;
+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;
 
 
 /* ts A70223 : wether implemented untested profiles are supported */
@@ -94,11 +116,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" */
@@ -119,10 +142,11 @@ void burn_preset_device_open(int exclusive, int blocking, int abort_on_busy)
 	/* a ssert(burn_running); */
 	if (!burn_running)
 		return;	
-
-	burn_sg_open_o_excl= exclusive;
-	burn_sg_open_o_nonblock= !blocking;
-	burn_sg_open_abort_busy= !!abort_on_busy;
+	burn_sg_open_o_excl = exclusive & 3;
+	burn_sg_fcntl_f_setlk = !!(exclusive & 32);
+	burn_sg_use_family = (exclusive >> 2) & 7;
+	burn_sg_open_o_nonblock = !blocking;
+	burn_sg_open_abort_busy = !!abort_on_busy;
 }
 
 
@@ -186,6 +210,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)
@@ -212,40 +238,116 @@ 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_FATAL;
+	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 = 0x00040001;
+		}
+	}
+	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);
+	if (ret <= 0)
+		*sevno = LIBDAX_MSGS_SEV_FATAL;
+	return ret;
+}
+
+
 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
+	fprintf(stderr,
+		"libburn_ABORT: pid = %d , abort_control_pid = %d , sig= %d\n",
+		getpid(), abort_control_pid, signum);
+#endif
+
+	/* 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());
+		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);
@@ -253,10 +355,13 @@ int burn_builtin_abort_handler(void *handle, int signum, int flag)
 		"%sABORT : Wait the normal burning time before any kill -9\n",
 		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);
 }
 
@@ -275,8 +380,10 @@ void burn_set_signal_handling(void *handle, burn_abort_handler_t 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();
+	abort_control_pid = getpid();
 	Cleanup_set_handlers(handle, (Cleanup_app_handler_T) handler, mode|4);
+	burn_global_signal_handle = handle;
+	burn_global_signal_handler = handler;
 }
 
 
@@ -286,3 +393,16 @@ 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;
+}
+

libburn/init.h

@@ -5,4 +5,17 @@
 
 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;
+
+
 #endif /* BURN__INIT_H */

libburn/libburn.h

@@ -251,8 +251,16 @@ enum burn_drive_status
 
 	/* ts A61223 */
 	/** The drive is formatting media */
-	BURN_DRIVE_FORMATTING
+	BURN_DRIVE_FORMATTING,
 
+	/* ts A70822 */
+	/** The drive is busy in synchronous read (if you see this then it
+	    has been interrupted) */
+	BURN_DRIVE_READING_SYNC,
+	/** The drive is busy in synchronous write (if you see this then it
+	    has been interrupted) */
+	BURN_DRIVE_WRITING_SYNC
+	
 };
 
     
@@ -291,7 +299,7 @@ struct burn_toc_entry
 	/** Track start time frames for normal tracks */
 	unsigned char pframe;
 
-	/* Indicates wether extension data are valid and eventually override
+	/* Indicates whether extension data are valid and eventually override
 	   older elements in this structure:
 	     bit0= DVD extension is valid
 	*/
@@ -310,39 +318,158 @@ struct burn_toc_entry
 };
 
 
-/** Data source for tracks */
+/** Data source interface for tracks.
+    This allows to use arbitrary program code as provider of track input data.
+
+    Objects compliant to this interface are either provided by the application
+    or by API calls of libburn: burn_fd_source_new() , burn_file_source_new(),
+    and burn_fifo_source_new().
+
+    The API calls allow to use any file object as data source. Consider to feed
+    an eventual custom data stream asynchronously into a pipe(2) and to let
+    libburn handle the rest. 
+    In this case the following rule applies:
+    Call burn_source_free() exactly once for every source obtained from
+    libburn API. You MUST NOT otherwise use or manipulate its components.
+
+    In general, burn_source objects can be freed as soon as they are attached
+    to track objects. The track objects will keep them alive and dispose them
+    when they are no longer needed. With a fifo burn_source it makes sense to
+    keep the own reference for inquiring its state while burning is in
+    progress.
+
+    ---
+
+    The following description of burn_source applies only to application
+    implemented burn_source objects. You need not to know it for API provided
+    ones.
+
+    If you really implement an own passive data producer by this interface,
+    then beware: it can do anything and it can spoil everything.
+
+    In this case the functions (*read), (*get_size), (*set_size), (*free_data)
+    MUST be implemented by the application and attached to the object at
+    creation time.
+    Function (*read_sub) is allowed to be NULL or it MUST be implemented and
+    attached.
+
+    burn_source.refcount MUST be handled properly: If not exactly as many
+    references are freed as have been obtained, then either memory leaks or
+    corrupted memory are the consequence.
+    All objects which are referred to by *data must be kept existent until
+    (*free_data) is called via burn_source_free() by the last referer.
+*/
 struct burn_source {
-	/** Reference count for the data source. Should be 1 when a new source
-            is created.  Increment it to take a reference for yourself. Use
-            burn_source_free to destroy your reference to it. */
+
+	/** Reference count for the data source. MUST be 1 when a new source
+            is created and thus the first reference is handed out. Increment
+            it to take more references for yourself. Use burn_source_free()
+            to destroy your references to it. */
 	int refcount;
 
-	/** Read data from the source */
-	int (*read)(struct burn_source *,
-	                                   unsigned char *buffer,
-	                                   int size);
 
-	/** Read subchannel data from the source (NULL if lib generated) */
-	int (*read_sub)(struct burn_source *,
-	                                       unsigned char *buffer,
-	                                       int size);
+	/** Read data from the source. Semantics like with read(2), but MUST
+	    either deliver the full buffer as defined by size or MUST deliver
+	    EOF (return 0) or failure (return -1) at this call or at the
+	    next following call. I.e. the only incomplete buffer may be the
+	    last one from that source.
+	    libburn will read a single sector by each call to (*read).
+	    The size of a sector depends on BURN_MODE_*. The known range is
+	    2048 to 2352.
 
-	/** Get the size of the source's data */
-	off_t (*get_size)(struct burn_source *);
+	    IMPORTANT:
+	    If this function pointer is NULL, then the struct burn_source is of
+	    version >= 1 and the job of .(*read)() is done by .(*read_xt)().
+	    See below, member .version.
+	*/
+	int (*read)(struct burn_source *, unsigned char *buffer, int size);
 
-	/** Set the size of the source's data */
+
+	/** Read subchannel data from the source (NULL if lib generated) 
+	    WARNING: This is an obscure feature with CD raw write modes.
+	    Unless you checked the libburn code for correctness in that aspect
+	    you should not rely on raw writing with own subchannels.
+	    ADVICE: Set this pointer to NULL.
+	*/
+	int (*read_sub)(struct burn_source *, unsigned char *buffer, int size);
+
+
+	/** Get the size of the source's data. Return 0 means unpredictable
+	    size. If application provided (*get_size) allows return 0, then
+	    the application MUST provide a fully functional (*set_size).
+	*/
+	off_t (*get_size)(struct burn_source *); 
+
+
+	/* ts A70125 : BROKE BINARY BACKWARD COMPATIBILITY AT libburn-0.3.1. */
+	/** Program the reply of (*get_size) to a fixed value. It is advised
+	    to implement this by a attribute  off_t fixed_size;  in *data .
+	    The read() function does not have to take into respect this fake
+	    setting. It is rather a note of libburn to itself. Eventually
+	    necessary truncation or padding is done in libburn. Truncation
+	    is usually considered a misburn. Padding is considered ok.
+
+	    libburn is supposed to work even if (*get_size) ignores the
+            setting by (*set_size). But your application will not be able to
+	    enforce fixed track sizes by  burn_track_set_size() and possibly
+	    even padding might be left out.
+	*/
 	int (*set_size)(struct burn_source *source, off_t size);
 
-	/** Clean up the source specific data */
+
+	/** Clean up the source specific data. This function will be called
+	    once by burn_source_free() when the last referer disposes the
+	    source.
+	*/
 	void (*free_data)(struct burn_source *);
 
+
 	/** Next source, for when a source runs dry and padding is disabled
-	    THIS IS AUTOMATICALLY HANDLED, DO NOT TOUCH
+	    WARNING: This is an obscure feature. Set to NULL at creation and
+	             from then on leave untouched and uninterpreted.
 	*/
 	struct burn_source *next;
 
-	/** Source specific data */
+
+	/** Source specific data. Here the various source classes express their
+	    specific properties and the instance objects store their individual
+	    management data.
+            E.g. data could point to a struct like this:
+		struct app_burn_source
+		{
+			struct my_app *app_handle;
+			... other individual source parameters ...
+			off_t fixed_size;
+		};
+
+	    Function (*free_data) has to be prepared to clean up and free
+	    the struct.
+	*/
 	void *data;
+
+
+	/* ts A71222 : Supposed to be binary backwards compatible extension. */
+
+	/** Valid only if above member .(*read)() is NULL. This indicates a
+	    version of struct burn_source younger than 0.
+	    From then on, member .version tells which further members exist
+	    in the memory layout of struct burn_source. libburn will only touch
+	    those announced extensions.
+
+	    Versions:
+	     0  has .(*read)() != NULL, not even .version is present.
+             1  has .version, .(*read_xt)(), .(*cancel)()
+	*/
+	int version;
+
+	/** This substitutes for (*read)() in versions above 0. */
+	int (*read_xt)(struct burn_source *, unsigned char *buffer, int size);
+
+	/** Informs the burn_source that the consumer of data prematurely
+	    ended reading. This call may or may not be issued by libburn
+	    before (*free_data)() is called.
+	*/
+	int (*cancel)(struct burn_source *source);
 };
 
 
@@ -355,12 +482,12 @@ struct burn_drive_info
 	char product[17];
 	/** Revision of the drive */
 	char revision[5];
-	/** Location of the drive in the filesystem. */
+
+	/** Invalid: Was: "Location of the drive in the filesystem." */
+	/** This string has no meaning any more. Once it stored the persistent
+	    drive address. Now always use function  burn_drive_d_get_adr()  to
+	    inquire a persistent address.           ^^^^^^ ALWAYS ^^^^^^^^ */
 	char location[17];
-	/** This is currently the string which is used as persistent
-	    drive address. But be warned: there is NO GUARANTEE that this
-	    will stay so. Always use function  burn_drive_get_adr() to
-	    inquire a persistent address.       ^^^^^^ ALWAYS ^^^^^^ */
 
 	/** Can the drive read DVD-RAM discs */
 	unsigned int read_dvdram:1;
@@ -455,8 +582,9 @@ struct burn_progress {
 	/* ts A61119 */
 	/** The number of bytes sent to the drive buffer */
 	off_t buffered_bytes;
-	/** The minimum number of buffered bytes. (Caution: Before surely
-	    one buffer size of bytes was processed, this value is 0xffffffff.) 
+	/** The minimum number of bytes stored in buffer during write.
+            (Caution: Before surely one buffer size of bytes was processed,
+                      this value is 0xffffffff.) 
 	*/
 	unsigned buffer_min_fill;
 };
@@ -572,13 +700,22 @@ void burn_set_verbosity(int level);
     after burn_initialize() and before any bus scan. But not mandatory at all.
     Parameter value 1 enables a feature, 0 disables.  
     Default is (1,0,0). Have a good reason before you change it.
-    @param exclusive 1 = Try to open only devices which are not marked as busy
+    @param exclusive Linux only:
+                     0 = no attempt to make drive access exclusive.
+                     1 = Try to open only devices which are not marked as busy
                      and try to mark them busy if opened sucessfully. (O_EXCL)
                      There are kernels which simply don't care about O_EXCL.
                      Some have it off, some have it on, some are switchable.
                      2 = in case of a SCSI device, also try to open exclusively
-                     the matching /dev/sr, /dev/scd and /dev/st .
-                     0 = no attempt to make drive access exclusive.
+                         the matching /dev/sr, /dev/scd and /dev/st .
+                     One may select a device SCSI file family by adding
+                      0 = default family
+                      4 = /dev/sr%d
+                      8 = /dev/scd%d
+                     16 = /dev/sg%d
+                     Do not use other values !
+                     Add 32 to demand an exclusive lock by fcntl(,F_SETLK,)
+                     after open() has succeeded.
     @param blocking  Try to wait for drives which do not open immediately but
                      also do not return an error as well. (O_NONBLOCK)
                      This might stall indefinitely with /dev/hdX hard disks.
@@ -592,7 +729,8 @@ void burn_preset_device_open(int exclusive, int blocking, int abort_on_busy);
 /* ts A70223 */
 /** Allows the use of media types which are implemented in libburn but not yet
     tested. The list of those untested profiles is subject to change.
-    Currently it contains: 0x15 "DVD-R/DL Sequential".
+    Currently it contains: 0x15 "DVD-R/DL sequential recording",
+                           0x2b "DVD+R/DL"
     If you really test such media, then please report the outcome on
     libburn-hackers@pykix.org
     If ever then this call should be done soon after burn_initialize() before
@@ -603,20 +741,70 @@ void burn_allow_untested_profiles(int yes);
 
 
 /* ts A60823 */
-/** Aquire a drive with known persistent address.This is the sysadmin friendly
-    way to open one drive and to leave all others untouched. It bundles
-    the following API calls to form a non-obtrusive way to use libburn:
+/** Aquire a drive with known persistent address.
+
+    This is the sysadmin friendly way to open one drive and to leave all
+    others untouched. It bundles the following API calls to form a
+    non-obtrusive way to use libburn:
       burn_drive_add_whitelist() , burn_drive_scan() , burn_drive_grab()
     You are *strongly urged* to use this call whenever you know the drive
     address in advance.
+
     If not, then you have to use directly above calls. In that case, you are
     *strongly urged* to drop any unintended drive which will be exclusively
     occupied and not closed by burn_drive_scan().
     This can be done by shutting down the library including a call to
     burn_finish(). You may later start a new libburn session and should then
     use the function described here with an address obtained after
-    burn_drive_scan() via burn_drive_get_adr(&(drive_infos[driveno]), adr) .
+    burn_drive_scan() via burn_drive_d_get_adr(drive_infos[driveno].drive,adr).
     Another way is to drop the unwanted drives by burn_drive_info_forget().
+
+    Operating on multiple drives:
+
+    Different than with burn_drive_scan() it is allowed to call
+    burn_drive_scan_and_grab() without giving up any other scanned drives. So
+    this call can be used to get a collection of more than one aquired drives.
+    The attempt to aquire the same drive twice will fail, though.
+
+    Pseudo-drives:
+
+    burn_drive_scan_and_grab() is able to aquire virtual drives which will
+    accept options much like a MMC burner drive. Many of those options will not
+    cause any effect, though. The address of a pseudo-drive begins with
+    prefix "stdio:" followed by a path.
+    Examples:  "stdio:/tmp/pseudo_drive" , "stdio:/dev/null" , "stdio:-"
+
+    If the path is empty, the result is a null-drive = drive role 0.
+    It pretends to have loaded no media and supports no reading or writing.
+
+    If the path leads to an existing regular file, or to a not yet existing
+    file, or to an existing block device, then the result is a random access
+    stdio-drive capable of reading and writing = drive role 2.
+
+    If the path leads to an existing file of any type other than directory,
+    then the result is a sequential write-only stdio-drive = drive role 3.
+
+    The special address form "stdio:/dev/fd/<number>" is interpreted literally
+    as reference to open file descriptor <number>. This address form coincides
+    with real files on some systems, but it is in fact hardcoded in libburn.
+    Special address "stdio:-" means stdout = "stdio:/dev/fd/1".
+    The role of such a drive is determined by the file type obtained via
+    fstat(<number>).
+   
+    Roles 2 and 3 perform all their eventual data transfer activities on a file
+    via standard i/o functions open(2), lseek(2), read(2), write(2), close(2).
+    The media profile is reported as 0xffff. Write space information from those
+    media is not necessarily realistic.
+
+    The capabilities of role 2 resemble DVD-RAM but it can simulate writing.
+    If the path does not exist in the filesystem yet, it is attempted to create
+    it as a regular file as soon as write operations are started.
+
+    The capabilities of role 3 resemble a blank DVD-R.
+
+    One may distinguish pseudo-drives from MMC drives by call
+    burn_drive_get_drive_role().
+
     @param drive_infos On success returns a one element array with the drive
                   (cdrom/burner). Thus use with driveno 0 only. On failure
                   the array has no valid elements at all.
@@ -625,9 +813,10 @@ void burn_allow_untested_profiles(int yes);
                   function again.
                   This is a result from call burn_drive_scan(). See there.
                   Use with driveno 0 only.
-    @param adr    The persistent address of the desired drive. Either obtained
-                  by burn_drive_get_adr() or guessed skillfully by application
-                  resp. its user.
+    @param adr    The persistent address of the desired drive. Either once
+                  obtained by burn_drive_d_get_adr() or composed skillfully by
+                  application resp. its user. E.g. "/dev/sr0".
+                  Consider to preprocess it by burn_drive_convert_fs_adr().
     @param load   Nonzero to make the drive attempt to load a disc (close its
                   tray door, etc).
     @return       1 = success , 0 = drive not found , -1 = other error
@@ -650,9 +839,14 @@ void burn_drive_clear_whitelist(void);
 
 
 /** Scan for drives. This function MUST be called until it returns nonzero.
-    No drives may be in use when this is called.
-    All drive pointers are invalidated by using this function. Do NOT store
-    drive pointers across calls to this function or death AND pain will ensue.
+    In case of re-scanning:
+    All pointers to struct burn_drive and all struct burn_drive_info arrays
+    are invalidated by using this function. Do NOT store drive pointers across
+    calls to this function !
+    To avoid invalid pointers one MUST free all burn_drive_info arrays
+    by burn_drive_info_free() before calling burn_drive_scan() a second time.
+    If there are drives left, then burn_drive_scan() will refuse to work.
+
     After this call all drives depicted by the returned array are subject
     to eventual (O_EXCL) locking. See burn_preset_device_open(). This state
     ends either with burn_drive_info_forget() or with burn_drive_release().
@@ -699,15 +893,25 @@ void burn_drive_info_free(struct burn_drive_info drive_infos[]);
 #define BURN_DRIVE_ADR_LEN 1024
 
 /** Inquire the persistent address of the given drive.
-    @param drive_info The drive to inquire. Usually some &(drive_infos[driveno])
+    @param drive The drive to inquire.
+    @param adr   An application provided array of at least BURN_DRIVE_ADR_LEN
+                 characters size. The persistent address gets copied to it.
+    @return >0 success , <=0 error (due to libburn internal problem)
+*/
+int burn_drive_d_get_adr(struct burn_drive *drive, char adr[]);
+
+/** Inquire the persistent address of a drive via a given drive_info object.
+    (Note: This is a legacy call.)
+    @param drive_info The drive to inquire.Usually some &(drive_infos[driveno])
     @param adr   An application provided array of at least BURN_DRIVE_ADR_LEN
                  characters size. The persistent address gets copied to it.
     @return >0 success , <=0 error (due to libburn internal problem)
 */
 int burn_drive_get_adr(struct burn_drive_info *drive_info, char adr[]);
 
+
 /* ts A60922 ticket 33 */
-/** Evaluate wether the given address would be a possible persistent drive
+/** Evaluate whether the given address would be a possible persistent drive
     address of libburn.
     @return 1 means yes, 0 means no
 */
@@ -746,7 +950,7 @@ int burn_drive_convert_scsi_adr(int bus_no, int host_no, int channel_no,
 /* ts A60923 - A61005 */
 /** Try to obtain bus,host,channel,target,lun from path. If there is an SCSI
     address at all, then this call should succeed with a persistent
-    drive address obtained via burn_drive_get_adr(). It is also supposed to
+    drive address obtained via burn_drive_d_get_adr(). It is also supposed to
     succeed with any device file of a (possibly emulated) SCSI device.
     @return     1 = success , 0 = failure , -1 = severe error
 */
@@ -765,14 +969,26 @@ int burn_drive_grab(struct burn_drive *drive, int load);
 
 
 /** Release a drive. This should not be done until the drive is no longer
-    busy (see burn_drive_get_status). The drive is (O_EXCL) unlocked
-    afterwards.
+    busy (see burn_drive_get_status).
+    Linux: The drive device file is not reserved afterwards. (O_EXCL, F_SETLK).
 	@param drive The drive to release.
 	@param eject Nonzero to make the drive eject the disc in it.
 */
 void burn_drive_release(struct burn_drive *drive, int eject);
 
 
+/* ts A70918 */
+/** Like burn_drive_release() but keeping the drive tray closed and its
+    eject button disabled. This physically locked drive state will last until
+    the drive is grabbed again and released via burn_drive_release().
+    Programs like eject, cdrecord, growisofs will break that ban too.
+    @param drive The drive to release and leave locked.
+    @param flag Bitfield for control purposes (unused yet, submit 0)
+    @return 1 means success, <=0 means failure
+*/
+int burn_drive_leave_locked(struct burn_drive *d, int flag);
+
+
 /** Returns what kind of disc a drive is holding. This function may need to be
     called more than once to get a proper status from it. See burn_disc_status
     for details.
@@ -874,14 +1090,18 @@ off_t burn_disc_available_space(struct burn_drive *d,
 /* ts A61202 */
 /** Tells the MMC Profile identifier of the loaded media. The drive must be
     grabbed in order to get a non-zero result.
-    libburn currently writes only to profiles 0x09 "CD-R", 0x0a "CD-RW",
-    0x11 "DVD-R", 0x12 "DVD-RAM", 0x13 "DVD-RW restricted overwrite",
-    0x14 "DVD-RW Sequential Recording" or 0x1a "DVD+RW".
-    If enabled by burn_allow_untested_profiles() it also writes to profile
-    0x15 "DVD-R/DL Sequential Recording".
+    libburn currently writes only to profiles 
+    0x09 "CD-R",                          0x0a "CD-RW",
+    0x11 "DVD-R sequential recording",    0x12 "DVD-RAM",
+    0x13 "DVD-RW restricted overwrite",   0x14 "DVD-RW sequential recording",
+    0x1a "DVD+RW",                        0x1b "DVD+R".
+    If enabled by burn_allow_untested_profiles() it also writes to profiles
+    0x15 "DVD-R/DL sequential recording", 0x2b "DVD+R/DL".
+    Writeable stdio-drives return this profile
+    0xffff "stdio file"
     @param d The drive where the media is inserted.
     @param pno Profile Number as of mmc5r03c.pdf, table 89
-    @param name Profile Name (e.g "CD-RW", unknown profiles have empty name)
+    @param name Profile Name (see above list, unknown profiles have empty name)
     @return 1 profile is valid, 0 no profile info available 
 */
 int burn_disc_get_profile(struct burn_drive *d, int *pno, char name[80]);
@@ -906,6 +1126,15 @@ enum burn_drive_status burn_drive_get_status(struct burn_drive *drive,
 */
 struct burn_write_opts *burn_write_opts_new(struct burn_drive *drive);
 
+
+/* ts A70901 */
+/** Inquires the drive associated with a burn_write_opts object.
+    @param opts object to inquire
+    @return pointer to drive
+*/
+struct burn_drive *burn_write_opts_get_drive(struct burn_write_opts *opts);
+
+
 /** Frees a write_opts struct created with burn_write_opts_new
     @param opts write_opts to free
 */
@@ -1026,7 +1255,7 @@ void burn_disc_read(struct burn_drive *drive, const struct burn_read_opts *o);
 
 
 /* ts A70219 */
-/** Examines a completed setup for burn_disc_write() wether it is permissible
+/** Examines a completed setup for burn_disc_write() whether it is permissible
     with drive and media. This function is called by burn_disc_write() but
     an application might be interested in this check in advance.
     @param o The options for the writing operation.
@@ -1038,9 +1267,6 @@ void burn_disc_read(struct burn_drive *drive, const struct burn_read_opts *o);
 int burn_precheck_write(struct burn_write_opts *o, struct burn_disc *disc,
                         char reasons[BURN_REASONS_LEN], int silent);
 
-/* <<< enabling switch for internal usage and trust in this function */
-#define Libburn_precheck_write_ruleS 1
-
 
 /** Write a disc in the drive. The drive must be grabbed successfully before
     calling this function. Always ensure that the drive reports a status of
@@ -1048,6 +1274,9 @@ int burn_precheck_write(struct burn_write_opts *o, struct burn_disc *disc,
     Note: write_type BURN_WRITE_SAO is currently not capable of writing a mix
     of data and audio tracks. You must use BURN_WRITE_TAO for such sessions.
     To be set by burn_write_opts_set_write_type(). 
+    Note: This function is not suitable for overwriting data in the middle of
+    a valid data area because it is allowed to append trailing data.
+    For exact random access overwriting use burn_random_access_write().
     @param o The options for the writing operation.
     @param disc The struct burn_disc * that described the disc to be created
 */
@@ -1062,7 +1291,7 @@ void burn_drive_cancel(struct burn_drive *drive);
 
 
 /* ts A61223 */
-/** Inquire wether the most recent write run was successful. Reasons for
+/** Inquire whether the most recent write run was successful. Reasons for
     non-success may be: rejection of burn parameters, abort during fatal errors
     during write, a call to burn_drive_cancel() by the application thread.
     @param d The drive to inquire.
@@ -1103,7 +1332,9 @@ int burn_msf_to_lba(int m, int s, int f);
 */
 void burn_lba_to_msf(int lba, int *m, int *s, int *f);
 
-/** Create a new disc */
+/** Create a new disc
+    @return Pointer to a burn_disc object or NULL on failure.
+*/
 struct burn_disc *burn_disc_create(void);
 
 /** Delete disc and decrease the reference count on all its sessions
@@ -1111,7 +1342,9 @@ struct burn_disc *burn_disc_create(void);
 */
 void burn_disc_free(struct burn_disc *d);
 
-/** Create a new session */
+/** Create a new session
+    @return Pointer to a burn_session object or NULL on failure.
+ */
 struct burn_session *burn_session_create(void);
 
 /** Free a session (and decrease reference count on all tracks inside)
@@ -1175,7 +1408,7 @@ void burn_track_define_data(struct burn_track *t, int offset, int tail,
 
 
 /* ts A61024 */
-/** Define wether a track shall swap bytes of its input stream.
+/** Define whether a track shall swap bytes of its input stream.
     @param t The track to change
     @param swap_source_bytes 0=do not swap, 1=swap byte pairs
     @return 1=success , 0=unacceptable value
@@ -1235,13 +1468,17 @@ enum burn_source_status burn_track_set_source(struct burn_track *t,
 */
 int burn_track_set_default_size(struct burn_track *t, off_t size);
 
-
 /** Free a burn_source (decrease its refcount and maybe free it)
 	@param s Source to free
 */
 void burn_source_free(struct burn_source *s);
 
-/** Creates a data source for an image file (and maybe subcode file) */
+/** Creates a data source for an image file (and maybe subcode file)
+    @param path The file address for the main channel payload.
+    @param subpath Eventual address for subchannel data. Only used in exotic
+                   raw write modes. Submit NULL for normal tasks.
+    @return Pointer to a burn_source object, NULL indicates failure
+*/
 struct burn_source *burn_file_source_new(const char *path,
 					 const char *subpath);
 
@@ -1249,13 +1486,80 @@ struct burn_source *burn_file_source_new(const char *path,
     readable filedescriptor, an eventually open readable subcodes file
     descriptor and eventually a fixed size in bytes.
     @param datafd The source of data.
-    @param subfd The eventual source for subcodes. Not used if -1.
+    @param subfd The eventual source of subchannel data. Only used in exotic
+                 raw write modes. Submit -1 for normal tasks.
     @param size The eventual fixed size of eventually both fds. 
                 If this value is 0, the size will be determined from datafd.
+    @return Pointer to a burn_source object, NULL indicates failure
 */
 struct burn_source *burn_fd_source_new(int datafd, int subfd, off_t size);
 
 
+/* ts A70930 */
+/** Creates a fifo which acts as proxy for an already existing data source.
+    The fifo provides a ring buffer which shall smoothen the data stream
+    between burn_source and writer thread. Each fifo serves only for one
+    data source and gets attached to one track as its only data source
+    by burn_track_set_source().
+    A fifo starts its life in "standby" mode with no buffer space allocated.
+    As soon as its track requires bytes, the fifo establishes a worker thread
+    and allocates its buffer. After input has ended and all buffer content is
+    consumed, the buffer space gets freed and the worker thread ends.
+    This happens asynchronously. So expect two buffers and worker threads to
+    exist for a short time between tracks. Be modest in your size demands if
+    multiple tracks are to be expected. 
+    @param inp        The burn_source for which the fifo shall act as proxy.
+                      It can be disposed by burn_source_free() immediately
+                      after this call.
+    @param chunksize  The size in bytes of a chunk. Use 2048 for sources
+                      suitable for BURN_BLOCK_MODE1 and 2352 for sources
+                      which deliver for BURN_BLOCK_AUDIO.
+                      Some variations of burn_source might work only with
+                      a particular chunksize. E.g. libisofs demands 2048.
+    @param chunks     The number of chunks to be allocated in ring buffer.
+                      This value must be >= 2.
+    @param flag       Bitfield for control purposes (unused yet, submit 0).
+    @return           A pointer to the newly created burn_source.
+                      Later both burn_sources, inp and the returned fifo, have
+                      to be disposed by calling burn_source_free() for each.
+                      inp can be freed immediately, the returned fifo may be
+                      kept as handle for burn_fifo_inquire_status().
+*/
+struct burn_source *burn_fifo_source_new(struct burn_source *inp,
+                                         int chunksize, int chunks, int flag);
+
+/* ts A71003 */
+/** Inquires state and fill parameters of a fifo burn_source which was created
+    by burn_fifo_source_new() . Do not use with other burn_source variants.
+    @param fifo  The fifo object to inquire
+    @param size  The total size of the fifo
+    @param free_bytes  The current free capacity of the fifo
+    @param status_text  Returns a pointer to a constant text, see below
+    @return  <0 reply invalid, >=0 fifo status code:
+             bit0+1=input status, bit2=consumption status, i.e:
+             0="standby"   : data processing not started yet
+             1="active"    : input and consumption are active
+             2="ending"    : input has ended without error
+             3="failing"   : input had error and ended,
+             4="unused"    : ( consumption has ended before processing start )
+             5="abandoned" : consumption has ended prematurely
+             6="ended"     : consumption has ended without input error
+             7="aborted"   : consumption has ended after input error
+*/
+int burn_fifo_inquire_status(struct burn_source *fifo, int *size, 
+                            int *free_bytes, char **status_text);
+
+
+/* ts A70328 */
+/** Sets a fixed track size after the data source object has already been
+    created.
+    @param t The track to operate on
+    @param size the number of bytes to use as track size
+    @return <=0 indicates failure , >0 success
+*/
+int burn_track_set_size(struct burn_track *t, off_t size);
+
+
 /** Tells how long a track will be on disc
     >>> NOTE: Not reliable with tracks of undefined length
 */
@@ -1270,12 +1574,51 @@ int burn_track_get_counters(struct burn_track *t,
 
 
 /** Sets drive read and write speed
+    Note: "k" is 1000, not 1024. 1xCD = 176.4 k/s, 1xDVD = 1385 k/s.
+          Fractional speeds should be rounded up. Like 4xCD = 706.
     @param d The drive to set speed for
-    @param read Read speed in k/s (0 is max)
-    @param write Write speed in k/s (0 is max)
+    @param read Read speed in k/s (0 is max, -1 is min).
+    @param write Write speed in k/s (0 is max, -1 is min). 
 */
 void burn_drive_set_speed(struct burn_drive *d, int read, int write);
 
+
+/* ts A70711 */
+/** Controls the behavior with writing when the drive buffer is suspected to
+    be full. To check and wait for enough free buffer space before writing
+    will move the task of waiting from the operating system's device driver
+    to libburn. While writing is going on and waiting is enabled, any write
+    operation will be checked whether it will fill the drive buffer up to
+    more than max_percent. If so, then waiting will happen until the buffer
+    fill is predicted with at most min_percent.
+    Thus: if min_percent < max_percent then transfer rate will oscillate. 
+    This may allow the driver to operate on other devices, e.g. a disk from
+    which to read the input for writing. On the other hand, this checking might
+    reduce maximum throughput to the drive or even get misled by faulty buffer
+    fill replies from the drive.
+    If a setting parameter is < 0, then this setting will stay unchanged
+    by the call.
+    Known burner or media specific pitfalls:
+    To have max_percent larger than the burner's best reported buffer fill has
+    the same effect as min_percent==max_percent. Some burners do not report
+    their full buffer with all media types. Some are not suitable because
+    they report their buffer fill with delay.
+    @param d The drive to control
+    @param enable 0= disable , 1= enable waiting , (-1 = do not change setting)
+    @param min_usec Shortest possible sleeping period (given in micro seconds)
+    @param max_usec Longest possible sleeping period (given in micro seconds)
+    @param timeout_sec If a single write has to wait longer than this number
+                       of seconds, then waiting gets disabled and mindless
+                       writing starts. A value of 0 disables this timeout.
+    @param min_percent Minimum of desired buffer oscillation: 25 to 100
+    @param max_percent Maximum of desired buffer oscillation: 25 to 100
+    @return 1=success , 0=failure
+*/
+int burn_drive_set_buffer_waiting(struct burn_drive *d, int enable,
+                                int min_usec, int max_usec, int timeout_sec,
+                                int min_percent, int max_percent);
+
+
 /* these are for my debugging, they will disappear */
 void burn_structure_print_disc(struct burn_disc *d);
 void burn_structure_print_session(struct burn_session *s);
@@ -1328,9 +1671,19 @@ void burn_write_opts_set_toc_entries(struct burn_write_opts *opts,
 */
 void burn_write_opts_set_format(struct burn_write_opts *opts, int format);
 
-/** Sets the simulate value for the write_opts struct
+/** Sets the simulate value for the write_opts struct . 
+    This corresponds to the Test Write bit in MMC mode page 05h. Several media
+    types do not support this. See struct burn_multi_caps.might_simulate for
+    actual availability of this feature. 
+    If the media is suitable, the drive will perform burn_write_disc() as a
+    simulation instead of effective write operations. This means that the
+    media content and burn_disc_get_status() stay unchanged.
+    Note: With stdio-drives, the target file gets eventually created, opened,
+          lseeked, and closed, but not written. So there are effects on it.
+    Warning: Call burn_random_access_write() will never do simulation because
+             it does not get any burn_write_opts.
     @param opts The write opts to change
-    @param sim If non-zero, the drive will perform a simulation instead of a burn
+    @param sim  Non-zero enables simulation, 0 enables real writing
     @return Returns 1 on success and 0 on failure.
 */
 int  burn_write_opts_set_simulate(struct burn_write_opts *opts, int sim);
@@ -1359,6 +1712,7 @@ void burn_write_opts_set_mediacatalog(struct burn_write_opts *opts, unsigned cha
 /* ts A61106 */
 /** Sets the multi flag which eventually marks the emerging session as not
     being the last one and thus creating a BURN_DISC_APPENDABLE media.
+    @param opts The option object to be manipulated
     @param multi 1=media will be appendable, 0=media will be closed (default) 
 */
 void burn_write_opts_set_multi(struct burn_write_opts *opts, int multi);
@@ -1366,11 +1720,14 @@ void burn_write_opts_set_multi(struct burn_write_opts *opts, int multi);
 
 /* ts A61222 */
 /** Sets a start address for writing to media and write modes which allow to
-    choose this address at all (DVD+RW, DVD-RAM, formatted DVD-RW only for
+    choose this address at all (for now: DVD+RW, DVD-RAM, formatted DVD-RW).
     now). The address is given in bytes. If it is not -1 then a write run
     will fail if choice of start address is not supported or if the block
     alignment of the address is not suitable for media and write mode.
-    (Alignment to 32 kB blocks is advised with DVD media.)
+    Alignment to 32 kB blocks is supposed to be safe with DVD media.
+    Call burn_disc_get_multi_caps() can obtain the necessary media info. See
+    resulting struct burn_multi_caps elements .start_adr , .start_alignment ,
+    .start_range_low , .start_range_high .
     @param opts The write opts to change
     @param value The address in bytes (-1 = start at default address)
 */
@@ -1381,7 +1738,7 @@ void burn_write_opts_set_start_byte(struct burn_write_opts *opts, off_t value);
 /** Caution: still immature and likely to change. Problems arose with
     sequential DVD-RW on one drive.
 
-    Controls wether the whole available space of the media shall be filled up
+    Controls whether the whole available space of the media shall be filled up
     by the last track of the last session.
     @param opts The write opts to change
     @param fill_up_media If 1 : fill up by last track, if 0 = do not fill up
@@ -1392,7 +1749,8 @@ void burn_write_opts_set_fillup(struct burn_write_opts *opts,
 
 /* ts A70303 */
 /** Eventually makes libburn ignore the failure of some conformance checks:
-    - the check wether CD write+block type is supported by the drive
+    - the check whether CD write+block type is supported by the drive
+    - the check whether the media profile supports simulated burning 
     @param opts The write opts to change
     @param use_force 1=ignore above checks, 0=refuse work on failed check
 */
@@ -1495,6 +1853,26 @@ int burn_drive_get_read_speed(struct burn_drive *d);
 int burn_drive_get_speedlist(struct burn_drive *d,
                              struct burn_speed_descriptor **speed_list);
 
+/* ts A70713 */
+/** Look up the fastest speed descriptor which is not faster than the given
+    speed_goal. If it is 0, then the fastest one is chosen among the
+    descriptors with the highest end_lba. If it is -1 then the slowest speed
+    descriptor is chosen regardless of end_lba. Parameter flag decides whether
+    the speed goal means write speed or read speed.
+    @param d Drive to query
+    @param speed_goal Upper limit for speed,
+                      0=search for maximum speed , -1 search for minimum speed
+    @param best_descr Result of the search, NULL if no match
+    @param flag Bitfield for control purposes
+                bit0= look for best read speed rather than write speed
+                bit1= look for any source type (else look for source==2 first
+	              and for any other source type only with CD media)
+    @return >0 indicates a valid best_descr, 0 = no valid best_descr
+*/
+int burn_drive_get_best_speed(struct burn_drive *d, int speed_goal,
+                        struct burn_speed_descriptor **best_descr, int flag);
+
+
 /* ts A61226 */
 /** Dispose a speed descriptor list copy which was obtained by
     burn_drive_get_speedlist().
@@ -1581,6 +1959,10 @@ struct burn_multi_caps {
 
 	/** Wether the current profile indicates CD media. 1=yes, 0=no */
 	int current_is_cd_profile;
+
+        /* ts A70528, added to version 0.3.7 */
+	/** Wether the current profile is able to perform simulated write */
+	int might_simulate;
 };
 
 /** Allocates a struct burn_multi_caps (see above) and fills it with values
@@ -1655,6 +2037,8 @@ int burn_track_get_mode(struct burn_track *track);
 int burn_session_get_hidefirst(struct burn_session *session);
 
 /** Returns the library's version in its parts
+    This is the runtime counterpart of the three build time macros
+    burn_header_version_* below.
     @param major The major version number
     @param minor The minor version number
     @param micro The micro version number
@@ -1662,10 +2046,38 @@ int burn_session_get_hidefirst(struct burn_session *session);
 void burn_version(int *major, int *minor, int *micro);
 
 
+/* ts A80129 */
+/** These three release version numbers tell the revision of this header file
+    and of the API it describes. They are memorized by applications at build
+    time.
+    Immediately after burn_initialize() an application should do this check:
+      burn_version(&major, &minor, &micro);
+      if(major > burn_header_version_major
+         || (major == burn_header_version_major
+             && (minor > burn_header_version_minor
+                 || (minor == burn_header_version_minor
+                     && micro >= burn_header_version_micro)))) {
+          ... Young enough. Go on with program run ....
+      } else {
+          ... Too old. Do not use this libburn version ...
+      }
+
+*/
+#define burn_header_version_major  0
+#define burn_header_version_minor  4
+#define burn_header_version_micro  2
+/** Note:
+    Above version numbers are also recorded in configure.ac and indirectly
+    lead to the reply of burn_version().
+    So the version triples in configure.ac and libburn.h must be kept equal.
+    In future versions the triple of libburn.h will be decisive alone.
+*/
+
+
 /* ts A60924 : ticket 74 */
 /** Control queueing and stderr printing of messages from libburn.
-    Severity may be one of "NEVER", "FATAL", "SORRY", "WARNING", "HINT",
-    "NOTE", "UPDATE", "DEBUG", "ALL".
+    Severity may be one of "NEVER", "ABORT", "FATAL", "FAILURE", "SORRY",
+    "WARNING", "HINT", "NOTE", "UPDATE", "DEBUG", "ALL".
     @param queue_severity Gives the minimum limit for messages to be queued.
                           Default: "NEVER". If you queue messages then you
                           must consume them by burn_msgs_obtain().
@@ -1684,8 +2096,9 @@ int burn_msgs_set_severities(char *queue_severity,
 /** Obtain the oldest pending libburn message from the queue which has at
     least the given minimum_severity. This message and any older message of
     lower severity will get discarded from the queue and is then lost forever.
-    @param minimum_severity  may be one of "NEVER", "FATAL", "SORRY",
-                      "WARNING", "HINT", "NOTE", "UPDATE", "DEBUG", "ALL".
+    @param minimum_severity  may be one of "NEVER", "ABORT", "FATAL",
+                      "FAILURE", "SORRY", "WARNING", "HINT", "NOTE", "UPDATE",
+                      "DEBUG", "ALL".
                       To call with minimum_severity "NEVER" will discard the
                       whole queue.
     @param error_code Will become a unique error code as liste in
@@ -1701,10 +2114,52 @@ int burn_msgs_obtain(char *minimum_severity,
                      char severity[]);
 
 
+/* ts A70922 */
+/** Submit a message to the libburn queueing system. It will be queued or
+    printed as if it was generated by libburn itself.
+    @param error_code The unique error code of your message.
+                      Submit 0 if you do not have reserved error codes within
+                      the libburnia project.
+    @param msg_text   Not more than BURN_MSGS_MESSAGE_LEN characters of
+                      message text.
+    @param os_errno   Eventual errno related to the message. Submit 0 if
+                      the message is not related to a operating system error.
+    @param severity   One of "ABORT", "FATAL", "FAILURE", "SORRY", "WARNING",
+                      "HINT", "NOTE", "UPDATE", "DEBUG". Defaults to "FATAL".
+    @param d          An eventual drive to which the message shall be related.
+                      Submit NULL if the message is not specific to a
+                      particular drive object.
+    @return           1 if message was delivered, <=0 if failure
+*/
+int burn_msgs_submit(int error_code, char msg_text[], int os_errno,
+                     char severity[], struct burn_drive *d);
+
+
+/* ts A71016 */
+/** Convert a severity name into a severity number, which gives the severity
+    rank of the name.
+    @param severity_name A name as with burn_msgs_submit(), e.g. "SORRY".
+    @param severity_number The rank number: the higher, the more severe.
+    @param flag Bitfield for control purposes (unused yet, submit 0)
+    @return >0 success, <=0 failure
+*/
+int burn_text_to_sev(char *severity_name, int *severity_number, int flag);
+
+
+/* ts A70915 */
+/** Replace the messenger object handle of libburn by a compatible handle
+    obtained from a related library. 
+    See also: libisofs, API function iso_get_messenger().
+    @param messenger The foreign but compatible message handle.
+    @return 1 : success, <=0 : failure
+*/
+int burn_set_messenger(void *messenger);
+
+
 /* ts A61002 */
-/* The prototype of a handler function suitable for burn_set_abort_handling().
-   Such a function has to return -2 if it does not want the process to
-   exit with value 1.
+/** The prototype of a handler function suitable for burn_set_abort_handling().
+    Such a function has to return -2 if it does not want the process to
+    exit with value 1.
 */
 typedef int (*burn_abort_handler_t)(void *handle, int signum, int flag);
 
@@ -1724,6 +2179,102 @@ typedef int (*burn_abort_handler_t)(void *handle, int signum, int flag);
 void burn_set_signal_handling(void *handle, burn_abort_handler_t handler, 
 			     int mode);
 
+
+/* ts A70811 */
+/** Write data in random access mode.
+    The drive must be grabbed successfully before calling this function which
+    circumvents usual libburn session processing and rather writes data without
+    preparations or finalizing. This will work only with overwriteable media
+    which are also suitable for burn_write_opts_set_start_byte(). The same
+    address alignment restrictions as with this function apply. I.e. for DVD
+    it is best to align to 32 KiB blocks (= 16 LBA units). The amount of data
+    to be written is subject to the same media dependent alignment rules.
+    Again, 32 KiB is most safe.
+    Call burn_disc_get_multi_caps() can obtain the necessary media info. See
+    resulting struct burn_multi_caps elements .start_adr , .start_alignment ,
+    .start_range_low , .start_range_high .
+    Other than burn_disc_write() this is a synchronous call which returns
+    only after the write transaction has ended (sucessfully or not). So it is
+    wise not to transfer giant amounts of data in a single call.
+    Important: Data have to fit into the already formatted area of the media.
+    @param d            The drive to which to write 
+    @param byte_address The start address of the write in byte
+                        (1 LBA unit = 2048 bytes) (do respect media alignment)
+    @param data         The bytes to be written
+    @param data_count   The number of those bytes (do respect media alignment)
+                        data_count == 0 is permitted (e.g. to flush the
+                        drive buffer without further data transfer).
+    @param flag         Bitfield for control purposes:
+                        bit0 = flush the drive buffer after eventual writing
+    @return 1=sucessful , <=0 : number of tranfered bytes * -1
+*/
+int burn_random_access_write(struct burn_drive *d, off_t byte_address,
+                             char *data, off_t data_count, int flag);
+
+
+/* ts A70812 */
+/** Read data in random access mode.
+    The drive must be grabbed successfully before calling this function.
+    With all currently supported drives and media the byte_address has to
+    be aligned to 2048 bytes. Only data tracks with 2048 bytes per sector
+    can be read this way. I.e. not CD-audio, not CD-video-stream ...
+    This is a synchronous call which returns only after the full read job
+    has ended (sucessfully or not). So it is wise not to read giant amounts
+    of data in a single call.
+    @param d            The drive to which to write
+    @param byte_address The start address of the read in byte (aligned to 2048)
+    @param data         A memory buffer capable of taking data_size bytes
+    @param data_size    The amount of data to be read. This does not have to
+                        be aligned to any block size.
+    @param data_count   The amount of data actually read (interesting on error)
+    @param flag         Bitfield for control purposes:
+                        bit0= - reserved -
+                        bit1= do not submit error message if read error
+    @return 1=sucessful , <=0 an error occured
+*/
+int burn_read_data(struct burn_drive *d, off_t byte_address,
+                   char data[], off_t data_size, off_t *data_count, int flag);
+
+
+/* A70904 */
+/** Inquire whether the drive object is a real MMC drive or a pseudo-drive
+    created by a stdio: address.
+    @param d      The drive to inquire
+    @return       0= null-drive
+                  1= real MMC drive
+                  2= stdio-drive, random access, read-write
+                  3= stdio-drive, sequential, write-only
+*/
+int burn_drive_get_drive_role(struct burn_drive *d);
+
+
+/* ts A70923 */
+/** Find out whether a given address string would lead to the given drive
+    object. This should be done in advance for track source addresses
+    with parameter drive_role set to 2. 
+    Although a real MMC drive should hardly exist as two drive objects at
+    the same time, this can easily happen with stdio-drives. So if more than
+    one drive is used by the application, then this gesture is advised:
+      burn_drive_d_get_adr(d2, adr2);
+      if (burn_drive_equals_adr(d1, adr2, burn_drive_get_drive_role(d2)))
+        ... Both drive objects point to the same storage facility ...
+ 
+    @param d1      Existing drive object
+    @param adr2    Address string to be tested. Prefix "stdio:" overrides
+                   parameter drive_role2 by either 0 or 2 as appropriate.
+                   The string must be shorter than BURN_DRIVE_ADR_LEN.
+    @param drive_role2  Role as burn_drive_get_drive_role() would attribute
+                   to adr2 if it was a drive. Use value 2 for checking track
+                   sources resp. pseudo-drive addresses without "stdio:".
+                   Use 1 for checking drive addresses including those with
+                   prefix "stdio:".
+    @return        1= adr2 leads to d1 , 0= adr2 seems not to lead to d1,
+                   -1 = adr2 is bad
+*/
+int burn_drive_equals_adr(struct burn_drive *d1, char *adr2, int drive_role2);
+
+
+
 #ifndef DOXYGEN
 
 BURN_END_DECLS

libburn/libdax_audioxtr.c

@@ -34,7 +34,7 @@ int libdax_audioxtr_new(struct libdax_audioxtr **xtr, char *path, int flag)
  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_msgs.c

@@ -1,7 +1,8 @@
 
 /* libdax_msgs
    Message handling facility of libdax.
-   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
+   Copyright (C) 2006 - 2008 Thomas Schmitt <scdbackup@gmx.net>,
+   provided under GPL version 2
 */
 
 #include <stdio.h>
@@ -39,7 +40,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 +109,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);
 }
 
@@ -137,6 +138,7 @@ int libdax_msgs_new(struct libdax_msgs **m, int flag)
  (*m)= o= (struct libdax_msgs *) malloc(sizeof(struct libdax_msgs));
  if(o==NULL)
    return(-1);
+ o->refcount= 1;
  o->oldest= NULL;
  o->youngest= NULL;
  o->count= 0;
@@ -152,43 +154,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 +184,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 +252,8 @@ 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,"SORRY",5)==0)
    *severity= LIBDAX_MSGS_SEV_SORRY;
  else if(strncmp(severity_name,"WARNING",7)==0)
@@ -254,8 +280,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\nSORRY\nWARNING\nHINT\nNOTE\nUPDATE\nDEBUG\nALL";
    return(1);
  }
  *severity_name= "";
@@ -265,6 +290,8 @@ 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_SORRY)
    *severity_name= "SORRY";
  else if(severity>=LIBDAX_MSGS_SEV_WARNING)
@@ -287,7 +314,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,7 +352,7 @@ 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;

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
+   Copyright (C) 2006-2008 Thomas Schmitt <scdbackup@gmx.net>,
+   provided under GPL version 2
 */
 
 
@@ -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,7 +113,7 @@ 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.
@@ -113,15 +140,47 @@ 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 important parts of an action
+    failed but processing may go on if one accepts deviations from the
+    desired result.
+
+    E.g.: One of several libisofs input files cannot be found.
+          A speed setting cannot be made.
+
+    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
+
+/** Non-fatal error indicating that a complete action failed and that
+    only a thorough new setup of preconditions will give hope for success.
+
+    E.g.: No media is inserted in the output drive.
+          No write mode can be found for inserted media.
+          All libisofs input files are inaccessible.
+
+    After FAILURE a function should end very soon with a return value
+    indicating failure.
+*/
+#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 +193,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 +205,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 +230,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 +269,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 +346,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);
 
 
@@ -276,7 +366,7 @@ int libdax_msgs_item_get_rank(struct libdax_msgs_item *item,
 
 
 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 +374,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
 
 
 ------------------------------------------------------------------------------
@@ -300,9 +391,11 @@ Range "scdbackup"          :  0x00020000 to 0x0002ffff
  0x00020002 (SORRY,HIGH)   = Encountered error when closing drive
  0x00020003 (SORRY,HIGH)   = Could not grab drive
  0x00020004 (NOTE,HIGH)    = Opened O_EXCL scsi sibling
- 0x00020005 (FATAL,HIGH)   = Failed to open device
+ 0x00020005 (SORRY,HIGH)   = Failed to open device
  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
            
  General library operations:
 
@@ -312,7 +405,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
@@ -365,12 +458,89 @@ 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 (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 (FATAL,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
 
  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
+
+ General:
+ 0x00031001 (SORRY,HIGH)    = Cannot read file (ignored)
+ 0x00031002 (FATAL,HIGH)    = Cannot read file (operation canceled)
+
+ Image reading:
+ 0x00031000 (FATAL,HIGH)    = Unsupported ISO-9660 image
+ 0x00031001 (HINT,MEDIUM)   = Unsupported Vol Desc that will be ignored
+ 0x00031002 (FATAL,HIGH)    = Damaged ISO-9660 image
+ 0x00031003 (SORRY,HIGH)    = Cannot read previous image file
  
+ Rock-Ridge:
+ 0x00030101 (HINT,MEDIUM)   = Unsupported SUSP entry that will be ignored
+ 0x00030102 (SORRY,HIGH)    = Wrong/damaged SUSP entry
+ 0x00030103 (WARNING,MEDIUM)= Multiple SUSP ER entries where found
+ 0x00030111 (SORRY,HIGH)    = Unsupported RR feature
+ 0x00030112 (SORRY,HIGH)    = Error in a Rock Ridge entry
+ 
+ El-Torito:
+ 0x00030201 (HINT,MEDIUM)   = Unsupported Boot Vol Desc that will be ignored
+ 0x00030202 (SORRY,HIGH)    = Wrong El-Torito catalog
+ 0x00030203 (HINT,MEDIUM)   = Unsupported El-Torito feature
+ 0x00030204 (SORRY,HIGH)    = Invalid file to be an El-Torito image
+ 0x00030205 (WARNING,MEDIUM)= Cannot properly patch isolinux image
+ 0x00030206 (WARNING,MEDIUM)= Copying El-Torito from a previous image without
+                              enought info about it
+ 
+ Joliet:
+ 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
+
 
 ------------------------------------------------------------------------------
 

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

@@ -68,6 +68,11 @@ int mmc_compose_mode_page_5(struct burn_drive *d,
                             const struct burn_write_opts *o,
                             unsigned char *pd);
 
+/* 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);
+
+
 
 /* mmc5r03c.pdf 4.3.4.4.1 d) "The maximum number of RZones is 2 302." */
 #define BURN_MMC_FAKE_TOC_MAX_SIZE 2302

libburn/options.c

@@ -124,16 +124,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)
+		return 0;
 	if (opts->drive->mdata->underrun_proof) {
 		opts->underrun_proof = underrun_proof;
 		return 1;
@@ -265,6 +275,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 +308,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 +337,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 +380,13 @@ void burn_write_opts_set_force(struct burn_write_opts *opts, int use_force)
 }
 
 
+/* 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/os-linux.h

@@ -42,7 +42,10 @@ 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 65536
+*/
+#define BURN_OS_TRANSPORT_BUFFER_SIZE 32768
 
 
 /* To hold the index number of the most recently delivered address from
@@ -52,6 +55,10 @@ SIGKILL, SIGCHLD, SIGSTOP, SIGURG, SIGWINCH
 typedef int burn_drive_enumerator_t;
 
 
+/* Parameters for sibling list. See sibling_fds, sibling_fnames */
+#define BURN_OS_SG_MAX_SIBLINGS 5
+#define BURN_OS_SG_MAX_NAMELEN 16
+
 /* The list of operating system dependent elements in struct burn_drive.
    Usually they are initialized in  sg-*.c:enumerate_common().
 */
@@ -60,5 +67,7 @@ int fd; \
  \
 /* ts A60926 : trying to lock against growisofs /dev/srN, /dev/scdN */ \
 int sibling_count; \
-int sibling_fds[LIBBURN_SG_MAX_SIBLINGS];
+int sibling_fds[BURN_OS_SG_MAX_SIBLINGS]; \
+/* ts A70409 : DDLP */ \
+char sibling_fnames[BURN_OS_SG_MAX_SIBLINGS][BURN_OS_SG_MAX_NAMELEN];
 

libburn/read.c

@@ -12,6 +12,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"
@@ -31,6 +34,12 @@
 #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
@@ -280,3 +289,177 @@ 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;
+
+	*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);
+		return 0;
+	}
+	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 0;
+	} else if (d->drive_role == 3) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020151,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+			"Read attempt on write-only drive", 0, 0);
+		return 0;
+	}
+	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);
+		return 0;
+	}
+
+	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);
+		return 0;
+	}
+
+	if (d->drive_role != 1) {
+
+/* <<< We need _LARGEFILE64_SOURCE defined by the build system.
+*/
+#ifndef O_LARGEFILE
+#define O_LARGEFILE 0
+#endif
+
+		fd = open(d->devname, O_RDONLY | O_LARGEFILE);
+		if (fd == -1) {
+			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; goto ex;
+		}
+		if (lseek(fd, byte_address, SEEK_SET) == -1) {
+			if (!(flag & 2))
+				libdax_msgs_submit(libdax_messenger,
+				  d->global_index,
+				  0x00020147,
+				  LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				  "Cannot address start byte", 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 */
+			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;
+			}
+			ret = 0; goto ex;
+		}
+		memcpy(wpt, d->buffer->data, cpy_size);
+		wpt += cpy_size;
+		*data_count += cpy_size;
+	}
+
+	ret = 1;
+ex:;
+	if (fd != -1)
+		close(fd);
+	d->buffer = NULL;
+	d->busy = BURN_DRIVE_IDLE;
+	return ret;
+}

libburn/sbc.c

@@ -3,39 +3,76 @@
 /* scsi block commands */
 
 #include <string.h>
+#include <unistd.h>
 
 #include "transport.h"
 #include "sbc.h"
+#include "spc.h"
 #include "options.h"
 
+
+/* 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);
+
+
 /* 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 };
+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 };
 
 void sbc_load(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "load") <= 0)
+		return;
+
+	scsi_init_command(&c, SBC_LOAD, sizeof(SBC_LOAD));
+/*
 	memcpy(c.opcode, SBC_LOAD, sizeof(SBC_LOAD));
-	c.retry = 1;
 	c.oplen = sizeof(SBC_LOAD);
-	c.dir = NO_TRANSFER;
 	c.page = NULL;
+*/
+	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;
 
-	c.page = NULL;
+	if (mmc_function_spy(d, "eject") <= 0)
+		return;
+
+	scsi_init_command(&c, SBC_UNLOAD, sizeof(SBC_UNLOAD));
+/*
 	memcpy(c.opcode, SBC_UNLOAD, sizeof(SBC_UNLOAD));
-	c.oplen = 1;
 	c.oplen = sizeof(SBC_UNLOAD);
 	c.page = NULL;
+*/
+
+	c.opcode[1] |= 1; /* ts A70918 : Immed */
+
+	c.page = NULL;
 	c.dir = NO_TRANSFER;
 	d->issue_command(d, &c);
+	if (c.error)
+		return;
+	/* ts A70918 : Wait long. A late eject could surprise or hurt user. */
+	spc_wait_unit_attention(d, 1800, "STOP UNIT (+ EJECT)", 0);
 }
 
 /* ts A61118 : is it necessary to tell the drive to get ready for use ? */
@@ -43,13 +80,25 @@ int sbc_start_unit(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "start_unit") <= 0)
+		return 0;
+
+	scsi_init_command(&c, SBC_START_UNIT, sizeof(SBC_START_UNIT));
+/*
 	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;
+*/
+	c.retry = 1;
+
+	c.opcode[1] |= 1; /* ts A70918 : Immed */
+
+	c.dir = NO_TRANSFER;
 	d->issue_command(d, &c);
-	return (c.error==0);
+	if (c.error)
+		return 0;
+	/* ts A70918 : now asynchronous */
+	return spc_wait_unit_attention(d, 1800, "START UNIT", 0);
 }
 
 

libburn/sector.c

@@ -123,7 +123,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) */
@@ -218,7 +223,8 @@ 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) {
+	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)

libburn/sg-freebsd-port.c

@@ -48,6 +48,8 @@ sg_issue_command()      sends a SCSI command to the drive, receives reply,
 
 sg_obtain_scsi_adr()    tries to obtain SCSI address parameters.
 
+burn_os_stdio_capacity()  estimates the emulated media space of stdio-drives.
+
 
 Porting hints are marked by the text "PORTING:".
 Send feedback to libburn-hackers@pykix.org .
@@ -74,6 +76,10 @@ Send feedback to libburn-hackers@pykix.org .
 #include <err.h> /* XXX */
 
 
+/* ts A70909 : >>> untestet yet wether this compiles */
+#include <sys/statvfs.h>
+
+
 /** PORTING : ------ libburn portable headers and definitions ----- */
 
 #include "transport.h"
@@ -557,3 +563,69 @@ int sg_is_enumerable_adr(char* adr)
 	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[4096], *cpt;
+	long blocks;
+	int open_mode = O_RDWR, fd, ret;
+	off_t add_size = 0;
+
+	testpath[0] = 0;
+	blocks = *bytes / 512;
+	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)
+			return -1;
+
+#ifdef Libburn_if_this_was_linuX
+
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		if(burn_sg_open_o_excl)
+			open_mode |= O_EXCL;
+		fd = open(path, open_mode);
+		if (fd == -1)
+			return -2;
+		ret = ioctl(fd, BLKGETSIZE, &blocks);
+		close(fd);
+		if (ret == -1)
+			return -2;
+		*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
+		return 0;
+
+	if (testpath[0]) {	
+		if (statvfs(testpath, &vfsbuf) == -1)
+			return -2;
+		*bytes = add_size + ((off_t) vfsbuf.f_bsize) *
+						(off_t) vfsbuf.f_bavail;
+	}
+	return 1;
+}
+

libburn/sg-freebsd.c

@@ -18,6 +18,10 @@
 #include <err.h> /* XXX */
 
 
+/* ts A70909 : >>> untestet yet wether this compiles */
+#include <sys/statvfs.h>
+
+
 #include "transport.h"
 #include "drive.h"
 #include "sg.h"
@@ -46,8 +50,9 @@ 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 A61021 : Moved most code from scsi_enumerate_drives under
@@ -386,7 +391,7 @@ 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)) {
@@ -400,7 +405,7 @@ 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 : ----- would release ");
+	mmc_function_spy(NULL, "enumerate_common : ----- would release ");
 
 }
 
@@ -448,7 +453,8 @@ int sg_grab(struct burn_drive *d)
 	int count;
 	struct cam_device *cam;
 
-	mmc_function_spy("sg_grab");
+	if (mmc_function_spy(d, "sg_grab") <= 0)
+		return 0;
 
 	if (burn_drive_is_open(d)) {
 		d->released = 0;
@@ -483,14 +489,15 @@ int sg_grab(struct burn_drive *d)
 
 int sg_release(struct burn_drive *d)
 {
-	mmc_function_spy("sg_release");
+	if (mmc_function_spy(d, "sg_release") <= 0)
+		return 0;
 
 	if (d->cam == NULL) {
 		burn_print(1, "release an ungrabbed drive.  die\n");
 		return 0;
 	}
 
-	mmc_function_spy("sg_release ----------- closing.");
+	mmc_function_spy(NULL, "sg_release ----------- closing.");
 
 	sg_close_drive(d);
 	d->released = 1;
@@ -506,7 +513,7 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	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, buf);
 
 	if (d->cam == NULL) {
 		c->error = 0;
@@ -598,3 +605,69 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	return 1;
 }
 
+
+/* 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[4096], *cpt;
+	long blocks;
+	int open_mode = O_RDWR, fd, ret;
+	off_t add_size = 0;
+
+	testpath[0] = 0;
+	blocks = *bytes / 512;
+	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)
+			return -1;
+
+#ifdef Libburn_if_this_was_linuX
+
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		if(burn_sg_open_o_excl)
+			open_mode |= O_EXCL;
+		fd = open(path, open_mode);
+		if (fd == -1)
+			return -2;
+		ret = ioctl(fd, BLKGETSIZE, &blocks);
+		close(fd);
+		if (ret == -1)
+			return -2;
+		*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
+		return 0;
+
+	if (testpath[0]) {	
+		if (statvfs(testpath, &vfsbuf) == -1)
+			return -2;
+		*bytes = add_size + ((off_t) vfsbuf.f_bsize) *
+						(off_t) vfsbuf.f_bavail;
+	}
+	return 1;
+}
+

libburn/sg-linux.c

@@ -48,6 +48,8 @@ sg_issue_command()      sends a SCSI command to the drive, receives reply,
 
 sg_obtain_scsi_adr()    tries to obtain SCSI address parameters.
 
+burn_os_stdio_capacity()  estimates the emulated media space of stdio-drives.
+
 
 Porting hints are marked by the text "PORTING:".
 Send feedback to libburn-hackers@pykix.org .
@@ -71,14 +73,32 @@ Hint: You should also look into sg-freebsd-port.c, which is a younger and
 #include <sys/poll.h>
 #include <linux/hdreg.h>
 #include <stdlib.h>
-#include <scsi/sg.h>
+#include <sys/utsname.h>
 #include <scsi/scsi.h>
+#include <sys/statvfs.h>
 
-/* ts A61211 : to recognize CD devices on /dev/sr* */
+/* for ioctl(BLKGETSIZE) */
+#include <linux/fs.h>
+
+
+#include <scsi/sg.h>
+/* Values within sg_io_hdr_t indicating success after ioctl(SG_IO) : */
+/* .host_status : from http://tldp.org/HOWTO/SCSI-Generic-HOWTO/x291.html */
+#define Libburn_sg_host_oK 0
+/* .driver_status : from http://tldp.org/HOWTO/SCSI-Generic-HOWTO/x322.html */
+#define Libburn_sg_driver_oK 0
+
+
+/* ts A61211 : to eventually recognize CD devices on /dev/sr* */
+#include <limits.h>
 #include <linux/cdrom.h>
 
 
-/* ts A61211 : preparing for exploration of recent Linux ATA adventures */
+/** Indication of the Linux kernel this software is running on */
+/* -1 = not evaluated , 0 = unrecognizable , 1 = 2.4 , 2 = 2.6 */
+static int sg_kernel_age = -1;
+
+
 /** PORTING : Device file families for bus scanning and drive access.
     Both device families must support the following ioctls:
       SG_IO,
@@ -104,22 +124,22 @@ static int linux_sg_enumerate_debug = 0;
    in the range of 0 to 31 . The resulting addresses must provide SCSI
    address parameters Host, Channel, Id, Lun and also Bus.
    E.g.: "/dev/sg%d"
+   sr%d is supposed to map only CD-ROM style devices. Additionally a test
+   with ioctl(CDROM_DRIVE_STATUS) is made to assert that it is such a drive,
+
+   This initial setting may be overridden in sg_select_device_family() by 
+   settings made via burn_preset_device_open().
 */
-/* NEW INFO: If hard disks at /dev/sr allow ioctl(CDROM_DRIVE_STATUS), they
-             are in danger.
-             If you want it less dangerous:
-               #undef CDROM_DRIVE_STATUS
-             but then you might need linux_sg_accept_any_type = 1 which
-             is _more dangerous_.
-*/
-/* !!! DO NOT SET TO sr%d UNLESS YOU PROTECTED ALL INDISPENSIBLE DEVICES
-       by chmod -rw . A test wether non-CD devices are properly excluded would
-       be well needed though. Heroic disks, scanners, etc. wanted !!! */
 static char linux_sg_device_family[80] = {"/dev/sg%d"};
 
+/* Set this to 1 if you want the default linux_sg_device_family chosen
+   depending on kernel release: sg for <2.6 , sr for >=2.6
+*/
+static int linux_sg_auto_family = 1;
+
 
 /* Set this to 1 in order to accept any TYPE_* (see scsi/scsi.h) */
-/* NEW INFO: Try with 0 first. There is hope via CDROM_DRIVE_STATUS. */
+/* But try with 0 first. There is hope via CDROM_DRIVE_STATUS. */
 /* !!! DO NOT SET TO 1 UNLESS YOU PROTECTED ALL INDISPENSIBLE DEVICES
        chmod -rw !!! */
 static int linux_sg_accept_any_type = 0;
@@ -168,19 +188,23 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 			     int channel_no, int target_no, int lun_no);
 
 
-/* >>> ts A61115 : this needs mending. A Linux aspect shows up in cdrskin. */
 /* ts A60813 : storage objects are in libburn/init.c
-   wether to use O_EXCL
+   wether to use O_EXCL with open(2) of devices
+   wether to use fcntl(,F_SETLK,) after open(2) of devices
+   what device family to use : 0=default, 1=sr, 2=scd, (3=st), 4=sg
    wether to use O_NOBLOCK with open(2) on devices
    wether to take O_EXCL rejection as fatal error */
 extern int burn_sg_open_o_excl;
+extern int burn_sg_fcntl_f_setlk;
+extern int burn_sg_use_family;
 extern int burn_sg_open_o_nonblock;
 extern int burn_sg_open_abort_busy;
 
 
 /* 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);
 
 
 /* ------------------------------------------------------------------------ */
@@ -188,6 +212,53 @@ int mmc_function_spy(char * text);
 /*            (Public functions are listed below)                           */
 /* ------------------------------------------------------------------------ */
 
+/* ts A70413 */
+/* This finds out wether the software is running on kernel >= 2.6
+*/
+static void sg_evaluate_kernel(void)
+{
+	struct utsname buf;
+	if (sg_kernel_age >= 0)
+		return;
+
+	sg_kernel_age = 0;
+	if (uname(&buf) == -1)
+		return;
+	sg_kernel_age = 1;
+	if (strcmp(buf.release, "2.6") >= 0)
+		sg_kernel_age = 2;
+}
+
+
+/* ts A70314 */
+/* This installs the device file family if one was chosen explicitely
+   by burn_preset_device_open()
+*/
+static void sg_select_device_family(void)
+{
+
+	/* >>> ??? do we need a mutex here ? */
+	/* >>> (It might be concurrent but is supposed to have always
+	        the same effect. Any race condition should be harmless.) */
+
+	if (burn_sg_use_family == 1)
+		strcpy(linux_sg_device_family, "/dev/sr%d");
+	else if (burn_sg_use_family == 2)
+		strcpy(linux_sg_device_family, "/dev/scd%d");
+	else if (burn_sg_use_family == 3)
+		strcpy(linux_sg_device_family, "/dev/st%d");
+	else if (burn_sg_use_family == 4)
+		strcpy(linux_sg_device_family, "/dev/sg%d");
+	else if (linux_sg_auto_family) {
+		sg_evaluate_kernel();
+		if (sg_kernel_age >= 2)
+			strcpy(linux_sg_device_family, "/dev/sr%d");
+		else
+			strcpy(linux_sg_device_family, "/dev/sg%d");
+		linux_sg_auto_family = 0;
+	}
+}
+
 
 static int sgio_test(int fd)
 {
@@ -229,12 +300,86 @@ static int sg_handle_busy_device(char *fname, int os_errno)
 }
 
 
+/* ts A60925 : ticket 74 */
+static int sg_close_drive_fd(char *fname, int driveno, int *fd, int sorry)
+{
+	int ret, os_errno, sevno= LIBDAX_MSGS_SEV_DEBUG;
+	char msg[4096+100];
+
+	if(*fd < 0)
+		return(0);
+	ret = close(*fd);
+	*fd = -1337;
+	if(ret != -1) {
+		/* ts A70409 : DDLP-B */
+		/* >>> release single lock on fname */
+		return 1;
+	}
+	os_errno= errno;
+
+	sprintf(msg, "Encountered error when closing drive '%s'", fname);
+	if (sorry)
+		sevno = LIBDAX_MSGS_SEV_SORRY;
+	libdax_msgs_submit(libdax_messenger, driveno, 0x00020002,
+			sevno, LIBDAX_MSGS_PRIO_HIGH, msg, os_errno, 0);
+	return 0;	
+}
+
+
+/* ts A70401 : 
+   fcntl() has the unappealing property to work only after open().
+   So libburn will by default use open(O_EXCL) first and afterwards
+   as second assertion will use fcntl(F_SETLK). One lock more should not harm.
+*/
+static int sg_fcntl_lock(int *fd, char *fd_name, int l_type, int verbous)
+{
+	struct flock lockthing;
+	char msg[81];
+	int ret;
+
+	if (!burn_sg_fcntl_f_setlk)
+		return 1;
+
+	memset(&lockthing, 0, sizeof(lockthing));
+	lockthing.l_type = l_type;
+	lockthing.l_whence = SEEK_SET;
+	lockthing.l_start = 0;
+	lockthing.l_len = 0;
+/*
+        fprintf(stderr,"LIBBURN_EXPERIMENTAL: fcntl(%d, F_SETLK, %s)\n",
+                *fd, l_type == F_WRLCK ? "F_WRLCK" : "F_RDLCK");
+*/
+
+	ret = fcntl(*fd, F_SETLK, &lockthing);
+	if (ret == -1) {
+		if (verbous) {
+			sprintf(msg, "Device busy. Failed to fcntl-lock '%s'",
+					fd_name);
+			libdax_msgs_submit(libdax_messenger, -1, 0x00020008,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				msg, errno, 0);
+		}
+		close(*fd);
+		*fd = -1;
+
+		/* ts A70409 : DDLP-B */
+		/* >>> release single lock on fd_name */
+
+		return(0);
+	}
+	return 1;
+}
+
+
 /* ts A60926 */
 static int sg_open_drive_fd(char *fname, int scan_mode)
 {
 	int open_mode = O_RDWR, fd;
 	char msg[81];
 
+	/* ts A70409 : DDLP-B */
+	/* >>> obtain single lock on fname */
+
 	/* ts A60813 - A60927
 	   O_EXCL with devices is a non-POSIX feature
 	   of Linux kernels. Possibly introduced 2002.
@@ -244,17 +389,22 @@ static int sg_open_drive_fd(char *fname, int scan_mode)
 	/* ts A60813
 	   O_NONBLOCK was already hardcoded in ata_ but not in sg_.
 	   There must be some reason for this. So O_NONBLOCK is
-	   default mode for both now. Disable on own risk. */
+	   default mode for both now. Disable on own risk.
+	   ts A70411
+           Switched to O_NDELAY for LKML statement 2007/4/11/141 by Alan Cox:
+	   "open() has side effects. The CD layer allows you to open
+            with O_NDELAY if you want to avoid them." 
+	*/
 	if(burn_sg_open_o_nonblock)
-		open_mode |= O_NONBLOCK;
+		open_mode |= O_NDELAY;
 
 /* <<< debugging
 	fprintf(stderr,
 		"\nlibburn: experimental: o_excl= %d , o_nonblock= %d, abort_on_busy= %d\n",
 	burn_sg_open_o_excl,burn_sg_open_o_nonblock,burn_sg_open_abort_busy);
 	fprintf(stderr,
-		"libburn: experimental: O_EXCL= %d , O_NONBLOCK= %d\n",
-		!!(open_mode&O_EXCL),!!(open_mode&O_NONBLOCK));
+		"libburn: experimental: O_EXCL= %d , O_NDELAY= %d\n",
+		!!(open_mode&O_EXCL),!!(open_mode&O_NDELAY));
 */
           
 	fd = open(fname, open_mode);
@@ -273,50 +423,25 @@ static int sg_open_drive_fd(char *fname, int scan_mode)
 			return -1;
 		sprintf(msg, "Failed to open device '%s'",fname);
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020005,
-				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 				msg, errno, 0);
 		return -1;
 	}
+	sg_fcntl_lock(&fd, fname, F_WRLCK, 1);
 	return fd;
 }
 
 
-/* ts A60925 : ticket 74 */
-static int sg_close_drive_fd(char *fname, int driveno, int *fd, int sorry)
-{
-	int ret, os_errno, sevno= LIBDAX_MSGS_SEV_DEBUG;
-	char msg[4096+100];
-
-	if(*fd < 0)
-		return(0);
-	ret = close(*fd);
-	*fd = -1337;
-	if(ret != -1)
-		return 1;
-	os_errno= errno;
-
-	if (fname != NULL)
-		sprintf(msg, "Encountered error when closing drive '%s'",
-			fname);
-	else
-		sprintf(msg, "Encountered error when closing drive");
-
-	if (sorry)
-		sevno = LIBDAX_MSGS_SEV_SORRY;
-	libdax_msgs_submit(libdax_messenger, driveno, 0x00020002,
-			sevno, LIBDAX_MSGS_PRIO_HIGH, msg, os_errno, 0);
-	return 0;	
-}
-
-
 /* ts A60926 */
-static int sg_release_siblings(int sibling_fds[], int *sibling_count)
+static int sg_release_siblings(int sibling_fds[],
+				char sibling_fnames[][BURN_OS_SG_MAX_NAMELEN],
+				int *sibling_count)
 {
 	int i;
 	char msg[81];
 
 	for(i= 0; i < *sibling_count; i++)
-		sg_close_drive_fd(NULL, -1, &(sibling_fds[i]), 0);
+		sg_close_drive_fd(sibling_fnames[i], -1, &(sibling_fds[i]), 0);
 	if(*sibling_count > 0) {
 		sprintf(msg, "Closed %d O_EXCL scsi siblings", *sibling_count);
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020007,
@@ -334,7 +459,8 @@ static int sg_close_drive(struct burn_drive *d)
 
 	if (!burn_drive_is_open(d))
 		return 0;
-	sg_release_siblings(d->sibling_fds, &(d->sibling_count));
+	sg_release_siblings(d->sibling_fds, d->sibling_fnames,
+				&(d->sibling_count));
 	ret = sg_close_drive_fd(d->devname, d->global_index, &(d->fd), 0);
 	return ret;
 }
@@ -342,29 +468,45 @@ static int sg_close_drive(struct burn_drive *d)
 
 /* ts A60926 */
 static int sg_open_scsi_siblings(char *path, int driveno,
-			  int sibling_fds[], int *sibling_count,
-			  int host_no, int channel_no, int id_no, int lun_no)
+			int sibling_fds[],
+			char sibling_fnames[][BURN_OS_SG_MAX_NAMELEN],
+			int *sibling_count,
+			int host_no, int channel_no, int id_no, int lun_no)
 {
 	int tld, i, ret, fd, i_bus_no = -1;
 	int i_host_no = -1, i_channel_no = -1, i_target_no = -1, i_lun_no = -1;
 	char msg[161], fname[81];
+	struct stat stbuf;
+	dev_t last_rdev = 0, path_rdev;
 
-	static char tldev[][81]= {"/dev/sr%d", "/dev/scd%d", "/dev/st%d", 
-				  "/dev/sg%d", ""};
+	static char tldev[][81]= {"/dev/sr%d", "/dev/scd%d", "/dev/sg%d", ""};
+					/* ts A70609: removed "/dev/st%d" */
 
+	if(stat(path, &stbuf) == -1)
+		return 0;
+	path_rdev = stbuf.st_rdev;
+
+        sg_select_device_family();
 	if (linux_sg_device_family[0] == 0)
 		return 1;
 
 	if(host_no < 0 || id_no < 0 || channel_no < 0 || lun_no < 0)
 		return(2);
 	if(*sibling_count > 0)
-		sg_release_siblings(sibling_fds, sibling_count);
+		sg_release_siblings(sibling_fds, sibling_fnames,
+					sibling_count);
 		
 	for (tld = 0; tldev[tld][0] != 0; tld++) {
 		if (strcmp(tldev[tld], linux_sg_device_family)==0)
 	continue;
 		for (i = 0; i < 32; i++) {
 			sprintf(fname, tldev[tld], i);
+			if(stat(fname, &stbuf) == -1)
+		continue;
+			if (path_rdev == stbuf.st_rdev)
+		continue;
+			if (*sibling_count > 0 && last_rdev == stbuf.st_rdev)
+		continue;
 			ret = sg_obtain_scsi_adr(fname, &i_bus_no, &i_host_no,
 				&i_channel_no, &i_target_no, &i_lun_no);
 			if (ret <= 0)
@@ -378,7 +520,7 @@ static int sg_open_scsi_siblings(char *path, int driveno,
 			if (fd < 0)
 				goto failed;
 
-			if (*sibling_count>=LIBBURN_SG_MAX_SIBLINGS) {
+			if (*sibling_count>=BURN_OS_SG_MAX_SIBLINGS) {
 				sprintf(msg, "Too many scsi siblings of '%s'",
 					path);
 				libdax_msgs_submit(libdax_messenger,
@@ -388,18 +530,20 @@ static int sg_open_scsi_siblings(char *path, int driveno,
 				goto failed;
 			}
 			sprintf(msg, "Opened O_EXCL scsi sibling '%s' of '%s'",
-				 fname, path);
+				fname, path);
 			libdax_msgs_submit(libdax_messenger, driveno,
 				0x00020004,
 				LIBDAX_MSGS_SEV_NOTE, LIBDAX_MSGS_PRIO_HIGH,
 				msg, 0, 0);
 			sibling_fds[*sibling_count] = fd;
+			strcpy(sibling_fnames[*sibling_count], fname);
 			(*sibling_count)++;
+			last_rdev= stbuf.st_rdev;
 		}
 	}
 	return 1;
 failed:;
-	sg_release_siblings(sibling_fds, sibling_count);
+	sg_release_siblings(sibling_fds, sibling_fnames, sibling_count);
 	return 0;
 }
 
@@ -477,10 +621,13 @@ static void ata_enumerate(void)
 static void sg_enumerate(void)
 {
 	struct sg_scsi_id sid;
-	int i, fd, sibling_fds[LIBBURN_SG_MAX_SIBLINGS], sibling_count= 0, ret;
+	int i, fd, sibling_fds[BURN_OS_SG_MAX_SIBLINGS], sibling_count= 0, ret;
 	int sid_ret = 0;
 	int bus_no= -1, host_no= -1, channel_no= -1, target_no= -1, lun_no= -1;
 	char fname[10];
+	char sibling_fnames[BURN_OS_SG_MAX_SIBLINGS][BURN_OS_SG_MAX_NAMELEN];
+
+        sg_select_device_family();
 
 	if (linux_sg_enumerate_debug)
 	  fprintf(stderr, "libburn_debug: linux_sg_device_family = %s\n",
@@ -520,6 +667,16 @@ static void sg_enumerate(void)
 			    "ioctl(SG_GET_SCSI_ID) failed, errno=%d  '%s' , ",
 			    errno, strerror(errno));
 
+			if (sgio_test(fd) == -1) {
+				if (linux_sg_enumerate_debug)
+			  		fprintf(stderr,
+				 "FATAL: sgio_test() failed: errno=%d  '%s'",
+						errno, strerror(errno));
+
+				sg_close_drive_fd(fname, -1, &fd, 0);
+	continue;
+			}
+
 #ifdef CDROM_DRIVE_STATUS
 			/* ts A61211 : not widening old acceptance range */
 			if (strcmp(linux_sg_device_family,"/dev/sg%d") != 0) {
@@ -581,7 +738,8 @@ static void sg_enumerate(void)
 		/* ts A60927 : trying to do locking with growisofs */
 		if(burn_sg_open_o_excl>1) {
 			ret = sg_open_scsi_siblings(
-					fname, -1, sibling_fds, &sibling_count,
+					fname, -1, sibling_fds, sibling_fnames,
+					&sibling_count,
 					sid.host_no, sid.channel,
 					sid.scsi_id, sid.lun);
 			if (ret<=0) {
@@ -591,7 +749,8 @@ static void sg_enumerate(void)
 	continue;
 			}
 			/* the final occupation will be done in sg_grab() */
-			sg_release_siblings(sibling_fds, &sibling_count);
+			sg_release_siblings(sibling_fds, sibling_fnames,
+						&sibling_count);
 		}
 #ifdef SCSI_IOCTL_GET_BUS_NUMBER
 		if(bus_no == -1)
@@ -645,7 +804,7 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 	/* Adapter specific handles and data */
 	out.fd = -1337;
 	out.sibling_count = 0;
-	for(i= 0; i<LIBBURN_SG_MAX_SIBLINGS; i++)
+	for(i= 0; i<BURN_OS_SG_MAX_SIBLINGS; i++)
 		out.sibling_fds[i] = -1337;
 
 	/* PORTING: ---------------- end of non portable part ------------ */
@@ -698,6 +857,7 @@ int sg_give_next_adr(burn_drive_enumerator_t *idx,
 	if (initialize == -1)
 		return 0;
 
+        sg_select_device_family();
 	if (linux_sg_device_family[0] == 0)
 		sg_limit = 0;
 	if (linux_ata_device_family[0] == 0)
@@ -781,7 +941,8 @@ int sg_grab(struct burn_drive *d)
 
 /* ts A60821
    <<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("sg_grab");
+	if (mmc_function_spy(d, "sg_grab") <= 0)
+		return 0;
 
 
 	/* ts A60813 - A60927
@@ -793,9 +954,12 @@ int sg_grab(struct burn_drive *d)
 		open_mode |= O_EXCL;
 
 	/* ts A60813
-	   O_NONBLOCK was hardcoded here. So it should stay default mode. */
+	   O_NONBLOCK was hardcoded here. So it should stay default mode.
+	   ts A70411
+           Switched to O_NDELAY for LKML statement 2007/4/11/141
+	*/
 	if(burn_sg_open_o_nonblock)
-		open_mode |= O_NONBLOCK;
+		open_mode |= O_NDELAY;
 
 	/* ts A60813 - A60822
 	   After enumeration the drive fd is probably still open.
@@ -806,14 +970,17 @@ int sg_grab(struct burn_drive *d)
 
 		/* ts A60821
    		<<< debug: for tracing calls which might use open drive fds */
-		mmc_function_spy("sg_grab ----------- opening");
+		mmc_function_spy(NULL, "sg_grab ----------- opening");
+
+		/* ts A70409 : DDLP-B */
+		/* >>> obtain single lock on d->devname */
 
 		/* ts A60926 */
 		if(burn_sg_open_o_excl>1) {
 			fd = -1;
 			ret = sg_open_scsi_siblings(d->devname,
 					d->global_index,d->sibling_fds,
-					&(d->sibling_count),
+					d->sibling_fnames,&(d->sibling_count),
 					d->host, d->channel, d->id, d->lun);
 			if(ret <= 0)
 				goto drive_is_in_use;
@@ -821,6 +988,11 @@ int sg_grab(struct burn_drive *d)
 
 		fd = open(d->devname, open_mode);
 		os_errno = errno;
+		if (fd >= 0) {
+			sg_fcntl_lock(&fd, d->devname, F_WRLCK, 1);
+			if (fd < 0)
+				goto drive_is_in_use;
+		}
 	} else
 		fd= d->fd;
 
@@ -856,7 +1028,8 @@ int sg_release(struct burn_drive *d)
 {
 	/* ts A60821
    	<<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("sg_release");
+	if (mmc_function_spy(d, "sg_release") <= 0)
+		return 0;
 
 	if (d->fd < 1) {
 		burn_print(1, "release an ungrabbed drive.  die\n");
@@ -865,13 +1038,78 @@ int sg_release(struct burn_drive *d)
 
 	/* ts A60821
    	<<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("sg_release ----------- closing");
+	mmc_function_spy(NULL, "sg_release ----------- closing");
 
 	sg_close_drive(d);
 	return 0;
 }
 
 
+/** ts A70518: 
+    Debugging log facility. Controlled by existence of macros:
+     Libburn_log_sg_commandS          enables logging to file
+                                        /tmp/libburn_sg_command_log
+     Libburn_fflush_log_sg_commandS   enables fflush after each output line
+     Libburn_log_sg_command_stderR    enables additional log to stderr
+*/
+/*
+#define Libburn_log_sg_commandS 1
+#define Libburn_fflush_log_sg_commandS 1
+#define Libburn_log_sg_command_stderR 1
+*/
+
+#ifdef Libburn_log_sg_commandS
+
+/** Logs command (before execution) */
+static int sg_log_cmd(struct command *c, FILE *fp, int flag)
+{
+	int i;
+
+	if (fp != NULL) {
+		for(i = 0; i < 16 && i < c->oplen; i++)
+  			fprintf(fp,"%2.2x ", c->opcode[i]);
+		fprintf(fp, "\n");
+#ifdef Libburn_fflush_log_sg_commandS
+		fflush(fp);
+#endif
+	}
+	if (fp == stderr)
+		return 1;
+#ifdef Libburn_log_sg_command_stderR
+	sg_log_cmd(c, stderr, flag);
+#endif
+	return 1;
+}
+
+
+/** logs outcome of a sg command. flag&1 causes an error message */
+static int sg_log_err(struct command *c, FILE *fp, 
+		sg_io_hdr_t *s,
+		int flag)
+{
+      	if(fp!=NULL) {
+		if(flag & 1)
+  			fprintf(fp,
+			"+++ key=%X  asc=%2.2Xh  ascq=%2.2Xh   (%6d ms)\n",
+				s->sbp[2], s->sbp[12], s->sbp[13],s->duration);
+		else
+			fprintf(fp,"%6d ms\n", s->duration);
+#ifdef Libburn_fflush_log_sg_commandS
+		fflush(fp);
+#endif
+	}
+	if (fp == stderr)
+		return 1;
+#ifdef Libburn_log_sg_command_stderR
+	sg_log_err(c, stderr, s, flag);
+#endif
+	return 1;
+}
+
+
+#endif /* Libburn_log_sg_commandS */
+
+
 /** 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.
@@ -886,15 +1124,10 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	int done = 0, no_c_page = 0;
 	int err;
 	sg_io_hdr_t s;
-/*
-#define Libburn_log_sg_commandS 1
-*/
 
 #ifdef Libburn_log_sg_commandS
 	/* ts A61030 */
 	static FILE *fp= NULL;
-	static int fpcount= 0;
-	int i;
 #endif /* Libburn_log_sg_commandS */
 
 	/* <<< ts A60821
@@ -902,7 +1135,7 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	char buf[161];
 	sprintf(buf,"sg_issue_command   d->fd= %d  d->released= %d\n",
 		d->fd,d->released);
-	mmc_function_spy(buf);
+	mmc_function_spy(NULL, buf);
 
 #ifdef Libburn_log_sg_commandS
 	/* ts A61030 */
@@ -910,12 +1143,7 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 		fp= fopen("/tmp/libburn_sg_command_log","a");
 		fprintf(fp,"\n-----------------------------------------\n");
 	}
-	if(fp!=NULL) {
-		for(i=0;i<10;i++)
-	  		fprintf(fp,"%2.2x ", c->opcode[i]);
-		fprintf(fp,"\n");
-		fpcount++;
-	}
+	sg_log_cmd(c,fp,0);
 #endif /* Libburn_log_sg_commandS */
 	  
 
@@ -950,7 +1178,15 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	if (c->page && !no_c_page) {
 		s.dxferp = c->page->data;
 		if (c->dir == FROM_DRIVE) {
-			s.dxfer_len = BUFFER_SIZE;
+
+			/* ts A70519 : kernel 2.4 usb-storage seems to
+					expect exact dxfer_len for data
+					fetching commands.
+			*/
+			if (c->dxfer_len >= 0)
+				s.dxfer_len = c->dxfer_len;
+			else
+				s.dxfer_len = BUFFER_SIZE;
 /* touch page so we can use valgrind */
 			memset(c->page->data, 0, BUFFER_SIZE);
 		} else {
@@ -1013,16 +1249,27 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 ex:;
 	if (c->error) {
 		scsi_notify_error(d, c, s.sbp, s.sb_len_wr, 0);
+	} else if (s.host_status != Libburn_sg_host_oK || 
+	    s.driver_status != Libburn_sg_driver_oK) {
+		char msg[161];
+
+		sprintf(msg,
+			"SCSI command %2.2Xh indicates host or driver error:",
+			(unsigned int) c->opcode[0]);
+		sprintf(msg+strlen(msg),
+			" host_status= %xh , driver_status= %xh",
+			(unsigned int) s.host_status,
+			(unsigned int) s.driver_status);
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+				0x0002013b,
+				LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
+				msg, 0, 0);
+	}
 
 #ifdef Libburn_log_sg_commandS
-        	if(fp!=NULL) {
-  			fprintf(fp,"+++ key=%X  asc=%2.2Xh  ascq=%2.2Xh\n",
-				s.sbp[2], s.sbp[12], s.sbp[13]);
-			fpcount++;
-		}
+	sg_log_err(c, fp, &s, c->error != 0);
 #endif /* Libburn_log_sg_commandS */
 
-	}
 	return 1;
 }
 
@@ -1034,19 +1281,33 @@ ex:;
 int sg_obtain_scsi_adr(char *path, int *bus_no, int *host_no, int *channel_no,
                        int *target_no, int *lun_no)
 {
-	int fd, ret, l;
+	int fd, ret, l, open_mode = O_RDONLY;
 	struct my_scsi_idlun {
 		int x;
 		int host_unique_id;
 	};
  	struct my_scsi_idlun idlun;
 
+
 	l = strlen(linux_ata_device_family) - 2;
 	if (l > 0 && strncmp(path, linux_ata_device_family, l) == 0 
 	    && path[7] >= 'a' && path[7] <= 'z' && path[8] == 0)
 		return 0; /* on RIP 14 all hdx return SCSI adr 0,0,0,0 */
 
-	fd = open(path, O_RDONLY | O_NONBLOCK);
+	/* ts A70409 : DDLP-B */
+	/* >>> obtain single lock on path */
+
+	if(burn_sg_open_o_nonblock)
+		open_mode |= O_NDELAY;
+	if(burn_sg_open_o_excl) {
+		/* O_EXCL | O_RDONLY does not work with /dev/sg* on 
+		   SuSE 9.0 (kernel 2.4) and SuSE 9.3 (kernel 2.6) */
+		/* so skip it for now */;
+	}
+	fd = open(path, open_mode);
+	if(fd < 0)
+		return 0;
+	sg_fcntl_lock(&fd, path, F_RDLCK, 0);
 	if(fd < 0)
 		return 0;
 
@@ -1102,3 +1363,60 @@ int sg_is_enumerable_adr(char *adr)
 }
 
 
+/* 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 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;
+	struct statvfs vfsbuf;
+	char testpath[4096], *cpt;
+	long blocks;
+	int open_mode = O_RDONLY, fd, ret;
+	off_t add_size = 0;
+
+	testpath[0] = 0;
+	blocks = *bytes / 512;
+	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)
+			return -1;
+	} else if(S_ISBLK(stbuf.st_mode)) {
+		fd = open(path, open_mode);
+		if (fd == -1)
+			return -2;
+		ret = ioctl(fd, BLKGETSIZE, &blocks);
+		close(fd);
+		if (ret == -1)
+			return -2;
+		*bytes = ((off_t) blocks) * (off_t) 512;
+	} else if(S_ISREG(stbuf.st_mode)) {
+		add_size = stbuf.st_blocks * (off_t) 512;
+		strcpy(testpath, path);
+	} else
+		return 0;
+
+	if (testpath[0]) {	
+		if (statvfs(testpath, &vfsbuf) == -1)
+			return -2;
+		*bytes = add_size + ((off_t) vfsbuf.f_bsize) *
+						(off_t) vfsbuf.f_bavail;
+	}
+	return 1;
+}
+

libburn/sg.h

@@ -31,4 +31,6 @@ int scsi_enumerate_drives(void);
 
 int sg_drive_is_open(struct burn_drive * d);
 
+int burn_os_stdio_capacity(char *path, off_t *bytes);
+
 #endif /* __SG */

libburn/source.c

@@ -18,8 +18,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 +32,24 @@ 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;
+}
+

libburn/source.h

@@ -5,4 +5,6 @@
 
 struct burn_source *burn_source_new(void);
 
+int burn_source_cancel(struct burn_source *src);
+
 #endif /*__SOURCE*/

libburn/spc.c

@@ -27,9 +27,15 @@
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
 
+/* 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);
+
 
 /* spc command set */
-static unsigned char SPC_INQUIRY[] = { 0x12, 0, 0, 0, 255, 0 };
+/* ts A70519 : allocation length byte 3+4 was 0,255 */
+static unsigned char SPC_INQUIRY[] = { 0x12, 0, 0, 0, 36, 0 };
 
 /*static char SPC_TEST[]={0,0,0,0,0,0};*/
 static unsigned char SPC_PREVENT[] = { 0x1e, 0, 0, 0, 1, 0 };
@@ -40,28 +46,144 @@ static unsigned char SPC_MODE_SELECT[] =
 static unsigned char SPC_REQUEST_SENSE[] = { 0x03, 0, 0, 0, 18, 0 };
 static unsigned char SPC_TEST_UNIT_READY[] = { 0x00, 0, 0, 0, 0, 0 };
 
-int spc_test_unit_ready(struct burn_drive *d)
+
+/* ts A70519 : An initializer for the abstract SCSI command structure */
+int scsi_init_command(struct command *c, unsigned char *opcode, int oplen)
+{
+	if (oplen > 16)
+		return 0;
+	memcpy(c->opcode, opcode, oplen);
+	c->oplen = oplen;
+	c->dir = NO_TRANSFER;
+	c->dxfer_len = -1;
+	memset(c->sense, 0, sizeof(c->sense));
+	c->error = 0;
+	c->retry = 0;
+	c->page = NULL;
+	return 1;
+}
+
+
+int spc_test_unit_ready_r(struct burn_drive *d, int *key, int *asc, int *ascq)
 {
 	struct command c;
 
-	c.retry = 0;
+	if (mmc_function_spy(d, "test_unit_ready") <= 0)
+		return 0;
+
+	scsi_init_command(&c, SPC_TEST_UNIT_READY,sizeof(SPC_TEST_UNIT_READY));
+/*
 	c.oplen = sizeof(SPC_TEST_UNIT_READY);
 	memcpy(c.opcode, SPC_TEST_UNIT_READY, sizeof(SPC_TEST_UNIT_READY));
 	c.page = NULL;
+*/
+	c.retry = 0;
 	c.dir = NO_TRANSFER;
 	d->issue_command(d, &c);
-	if (c.error)
+	if (c.error) {
+		*key= c.sense[2];
+		*asc= c.sense[12];
+		*ascq= c.sense[13];
 		return (c.sense[2] & 0xF) == 0;
+	}
 	return 1;
 }
 
+int spc_test_unit_ready(struct burn_drive *d)
+{
+	int key,asc,ascq;
+
+	return spc_test_unit_ready_r(d, &key, &asc, &ascq);
+}
+
+
+/* ts A70315 */
+/** @param flag bit0=do not wait 0.1 seconds before first test unit ready */
+/** Wait until the drive state becomes clear or until max_usec elapsed */
+int spc_wait_unit_attention(struct burn_drive *d, int max_sec, char *cmd_text,
+				int flag)
+{
+	int i, ret = 1, key = 0, asc = 0, ascq = 0;
+	char msg[160];
+
+	if (!(flag & 1))
+		usleep(100000);
+	for(i = !(flag & 1); i < max_sec * 10; i++) {
+		ret = spc_test_unit_ready_r(d, &key, &asc, &ascq);
+
+/* <<< 
+		fprintf(stderr,
+"libburn_EXPERIMENTAL: i= %d  ret= %d  key= %X  asc= %2.2X  ascq= %2.2X\n",
+		i, ret, (unsigned) key, (unsigned) asc, (unsigned) ascq);
+*/
+
+		if(ret > 0) /* ready */
+	break;
+		if(key!=0x2 || asc!=0x4) {
+			if (key == 0x2 && asc == 0x3A) {
+				ret = 1; /* medium not present = ok */
+/* <<<
+  ts A70912 :
+  My LG GSA-4082B on asynchronous load:
+    first it reports no media 2,3A,00,
+    then it reports not ready 2,04,00,
+    further media inquiry retrieves wrong data
+
+				if(i<=100)
+					goto slumber;
+*/
+	break;
+			}
+			if (key == 0x6 && asc == 0x28 && ascq == 0x00)
+				/* media change notice = try again */
+				goto slumber;
+
+			sprintf(msg,
+		"Asynchromous SCSI error on %s: key=%X asc=%2.2Xh ascq=%2.2Xh",
+			 	cmd_text, (unsigned) key, (unsigned) asc,
+				(unsigned) ascq);
+			libdax_msgs_submit(libdax_messenger, d->global_index,
+				0x0002014d,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				msg, 0, 0);
+			d->cancel = 1;
+	break;
+		}
+slumber:;
+		usleep(100000);
+	}
+
+	sprintf(msg, "Async %s %s after %d.%d seconds",
+		cmd_text, (ret > 0 ? "succeeded" : "failed"), i / 10, i % 10);
+	libdax_msgs_submit(libdax_messenger, d->global_index, 0x00020150,
+		LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_LOW, msg, 0, 0);
+
+	if (i < max_sec * 10)
+		return (ret > 0);
+
+	sprintf(msg, "Timeout (%d s) with asynchronous SCSI command %s\n",
+	 	max_sec, cmd_text);
+	libdax_msgs_submit(libdax_messenger, d->global_index, 0x0002014f,
+		LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH, msg, 0, 0);
+	return 0;
+}
+
+
 void spc_request_sense(struct burn_drive *d, struct buffer *buf)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "request_sense") <= 0)
+		return;
+
+	scsi_init_command(&c, SPC_REQUEST_SENSE, sizeof(SPC_REQUEST_SENSE));
 	c.retry = 0;
+/*
 	c.oplen = sizeof(SPC_REQUEST_SENSE);
 	memcpy(c.opcode, SPC_REQUEST_SENSE, sizeof(SPC_REQUEST_SENSE));
+*/
+	c.dxfer_len= c.opcode[4];
+	c.retry = 0;
 	c.page = buf;
 	c.page->sectors = 0;
 	c.page->bytes = 0;
@@ -73,6 +195,9 @@ int spc_get_erase_progress(struct burn_drive *d)
 {
 	struct buffer b;
 
+	if (mmc_function_spy(d, "get_erase_progress") <= 0)
+		return 0;
+
 	spc_request_sense(d, &b);
 	return (b.data[16] << 8) | b.data[17];
 }
@@ -83,24 +208,32 @@ void spc_inquiry(struct burn_drive *d)
 	struct burn_scsi_inquiry_data *id;
 	struct command c;
 
+	if (mmc_function_spy(d, "inquiry") <= 0)
+		return;
+
+	scsi_init_command(&c, SPC_INQUIRY, sizeof(SPC_INQUIRY));
+/*
 	memcpy(c.opcode, SPC_INQUIRY, sizeof(SPC_INQUIRY));
-	c.retry = 1;
 	c.oplen = sizeof(SPC_INQUIRY);
+*/
+	c.dxfer_len= (c.opcode[3] << 8) | c.opcode[4];
+	c.retry = 1;
 	c.page = &buf;
 	c.page->bytes = 0;
 	c.page->sectors = 0;
 	c.dir = FROM_DRIVE;
 	d->issue_command(d, &c);
-
 	id = (struct burn_scsi_inquiry_data *)d->idata;
-	id->vendor[8] = 0;
-	id->product[16] = 0;
-	id->revision[4] = 0;
-
+	memset(id->vendor, 0, 9);
+	memset(id->product, 0, 17);
+	memset(id->revision, 0, 5);
+	if (c.error) {
+		id->valid = -1;
+		return;
+	}
 	memcpy(id->vendor, c.page->data + 8, 8);
 	memcpy(id->product, c.page->data + 16, 16);
 	memcpy(id->revision, c.page->data + 32, 4);
-
 	id->valid = 1;
 	return;
 }
@@ -109,10 +242,16 @@ void spc_prevent(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "prevent") <= 0)
+		return;
+
+	scsi_init_command(&c, SPC_PREVENT, sizeof(SPC_PREVENT));
+/*
 	memcpy(c.opcode, SPC_PREVENT, sizeof(SPC_PREVENT));
-	c.retry = 1;
 	c.oplen = sizeof(SPC_PREVENT);
 	c.page = NULL;
+*/
+	c.retry = 1;
 	c.dir = NO_TRANSFER;
 	d->issue_command(d, &c);
 }
@@ -121,19 +260,30 @@ void spc_allow(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "allow") <= 0)
+		return;
+
+	scsi_init_command(&c, SPC_ALLOW, sizeof(SPC_ALLOW));
+/*
 	memcpy(c.opcode, SPC_ALLOW, sizeof(SPC_ALLOW));
-	c.retry = 1;
 	c.oplen = sizeof(SPC_ALLOW);
 	c.page = NULL;
+*/
+	c.retry = 1;
 	c.dir = NO_TRANSFER;
 	d->issue_command(d, &c);
 }
 
-void spc_sense_caps(struct burn_drive *d)
+/*
+ts A70518 : Do not call with *alloc_len < 8
+*/
+/** flag&1= do only inquire alloc_len */
+static int spc_sense_caps_al(struct burn_drive *d, int *alloc_len, int flag)
 {
 	struct buffer buf;
 	struct scsi_mode_data *m;
 	int size, page_length, num_write_speeds = 0, i, speed, ret;
+	int old_alloc_len, was_error = 0;
 	unsigned char *page;
 	struct command c;
 	struct burn_speed_descriptor *sd;
@@ -141,15 +291,30 @@ void spc_sense_caps(struct burn_drive *d)
 	/* ts A61225 : 1 = report about post-MMC-1 speed descriptors */
 	static int speed_debug = 0;
 
+	if (*alloc_len < 8)
+		return 0;
+
+	memset(&buf, 0, sizeof(buf));
+	scsi_init_command(&c, SPC_MODE_SENSE, sizeof(SPC_MODE_SENSE));
+/*
 	memcpy(c.opcode, SPC_MODE_SENSE, sizeof(SPC_MODE_SENSE));
-	c.retry = 1;
 	c.oplen = sizeof(SPC_MODE_SENSE);
+*/
+	c.dxfer_len = *alloc_len;
+	c.opcode[7] = (c.dxfer_len >> 8) & 0xff;
+	c.opcode[8] = c.dxfer_len & 0xff;
+	c.retry = 1;
 	c.opcode[2] = 0x2A;
 	c.page = &buf;
 	c.page->bytes = 0;
 	c.page->sectors = 0;
 	c.dir = FROM_DRIVE;
 	d->issue_command(d, &c);
+	if (c.error) {
+		memset(&buf, 0, sizeof(buf));
+		d->mdata->valid = -1;
+		was_error = 1;
+	}
 
 	size = c.page->data[0] * 256 + c.page->data[1];
 	m = d->mdata;
@@ -162,6 +327,14 @@ void spc_sense_caps(struct burn_drive *d)
 	   set of speed descriptors. In MMC-5 E.11 it is declared "legacy".
 	*/
 	page_length = page[1];
+	old_alloc_len = *alloc_len;
+	*alloc_len = page_length + 8;
+	if (flag & 1)
+		return !was_error;
+	if (page_length + 8 > old_alloc_len)
+		page_length = old_alloc_len - 8;
+	if (page_length < 22)
+		return 0;
 
 	m->valid = 0;
 	burn_mdata_free_subs(m);
@@ -211,6 +384,18 @@ void spc_sense_caps(struct burn_drive *d)
 
 	num_write_speeds = page[30] * 256 + page[31];
 	m->max_write_speed = m->min_write_speed = m->cur_write_speed;
+
+        if (32 + 4 * num_write_speeds > page_length + 2) {
+		char msg[161];
+
+		sprintf(msg, "Malformed capabilities page 2Ah received (len=%d, #speeds=%d)", page_length, num_write_speeds);
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+				0x0002013c,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				msg, 0, 0);
+		return 0;
+	}
+
 	for (i = 0; i < num_write_speeds; i++) {
 		speed = page[32 + 4*i + 2] * 256 + page[32 + 4*i + 3];
 
@@ -252,6 +437,27 @@ try_mmc_get_performance:;
 		fprintf(stderr,
 	  "LIBBURN_DEBUG: ACh min_write_speed = %d , max_write_speed = %d\n",
 		m->min_write_speed, m->max_write_speed);
+	return !was_error;
+}
+
+
+void spc_sense_caps(struct burn_drive *d)
+{
+	int alloc_len, start_len = 22, ret;
+
+	if (mmc_function_spy(d, "sense_caps") <= 0)
+		return;
+
+	/* first command execution to learn Allocation Length */
+	alloc_len = start_len;
+	ret = spc_sense_caps_al(d, &alloc_len, 1);
+/*
+	fprintf(stderr,"LIBBURN_DEBUG: 5Ah alloc_len = %d , ret = %d\n",
+			alloc_len, ret);
+*/
+	if (alloc_len >= start_len && ret > 0)
+		/* second execution with announced length */
+		spc_sense_caps_al(d, &alloc_len, 0);
 }
 
 
@@ -259,13 +465,22 @@ void spc_sense_error_params(struct burn_drive *d)
 {
 	struct buffer buf;
 	struct scsi_mode_data *m;
-	int size;
+	int size, alloc_len = 12 ;
 	unsigned char *page;
 	struct command c;
 
+	if (mmc_function_spy(d, "sense_error_params") <= 0)
+		return;
+
+	scsi_init_command(&c, SPC_MODE_SENSE, sizeof(SPC_MODE_SENSE));
+/*
 	memcpy(c.opcode, SPC_MODE_SENSE, sizeof(SPC_MODE_SENSE));
-	c.retry = 1;
 	c.oplen = sizeof(SPC_MODE_SENSE);
+*/
+	c.dxfer_len = alloc_len;
+	c.opcode[7] = (c.dxfer_len >> 8) & 0xff;
+	c.opcode[8] = c.dxfer_len & 0xff;
+	c.retry = 1;
 	c.opcode[2] = 0x01;
 	c.page = &buf;
 	c.page->bytes = 0;
@@ -287,9 +502,15 @@ void spc_select_error_params(struct burn_drive *d,
 	struct buffer buf;
 	struct command c;
 
+	if (mmc_function_spy(d, "select_error_params") <= 0)
+		return;
+
+	scsi_init_command(&c, SPC_MODE_SELECT, sizeof(SPC_MODE_SELECT));
+/*
 	memcpy(c.opcode, SPC_MODE_SELECT, sizeof(SPC_MODE_SELECT));
-	c.retry = 1;
 	c.oplen = sizeof(SPC_MODE_SELECT);
+*/
+	c.retry = 1;
 	c.opcode[8] = 8 + 2 + d->mdata->retry_page_length;
 	c.page = &buf;
 	c.page->bytes = 0;
@@ -318,17 +539,26 @@ void spc_sense_write_params(struct burn_drive *d)
 {
 	struct buffer buf;
 	struct scsi_mode_data *m;
-	int size, dummy;
+	int size, dummy, alloc_len = 10;
 	unsigned char *page;
 	struct command c;
 
+	if (mmc_function_spy(d, "sense_write_params") <= 0)
+		return;
+
 	/* ts A61007 : Done in soft at only caller burn_drive_grab() */
 	/* a ssert(d->mdata->cdr_write || d->mdata->cdrw_write ||
 	       d->mdata->dvdr_write || d->mdata->dvdram_write); */
 
+	scsi_init_command(&c, SPC_MODE_SENSE, sizeof(SPC_MODE_SENSE));
+/*
 	memcpy(c.opcode, SPC_MODE_SENSE, sizeof(SPC_MODE_SENSE));
-	c.retry = 1;
 	c.oplen = sizeof(SPC_MODE_SENSE);
+*/
+	c.dxfer_len = alloc_len;
+	c.opcode[7] = (c.dxfer_len >> 8) & 0xff;
+	c.opcode[8] = c.dxfer_len & 0xff;
+	c.retry = 1;
 	c.opcode[2] = 0x05;
 	c.page = &buf;
 	c.page->bytes = 0;
@@ -336,12 +566,16 @@ void spc_sense_write_params(struct burn_drive *d)
 	c.dir = FROM_DRIVE;
 	d->issue_command(d, &c);
 
-	size = c.page->data[0] * 256 + c.page->data[1];
+	/* ts A71128 : do not interpret reply if error */
 	m = d->mdata;
-	page = c.page->data + 8;
-	burn_print(1, "write page length 0x%x\n", page[1]);
-	m->write_page_length = page[1];
-	m->write_page_valid = 1;
+	if(!c.error) {
+		size = c.page->data[0] * 256 + c.page->data[1];
+		page = c.page->data + 8;
+		burn_print(1, "write page length 0x%x\n", page[1]);
+		m->write_page_length = page[1];
+		m->write_page_valid = 1;
+	} else
+		m->write_page_valid = 0;
 	mmc_read_disc_info(d);
 
 	/* ts A70212 : try to setup d->media_capacity_remaining */
@@ -373,6 +607,9 @@ void spc_select_write_params(struct burn_drive *d,
 	struct buffer buf;
 	struct command c;
 
+	if (mmc_function_spy(d, "select_write_params") <= 0)
+		return;
+
 	/* ts A61007 : All current callers are safe. */
 	/* a ssert(o->drive == d); */
 
@@ -383,9 +620,12 @@ void spc_select_write_params(struct burn_drive *d,
 		o->block_type,spc_block_type(o->block_type));
 	*/
 
+	scsi_init_command(&c, SPC_MODE_SELECT, sizeof(SPC_MODE_SELECT));
+/*
 	memcpy(c.opcode, SPC_MODE_SELECT, sizeof(SPC_MODE_SELECT));
-	c.retry = 1;
 	c.oplen = sizeof(SPC_MODE_SELECT);
+*/
+	c.retry = 1;
 	c.opcode[8] = 8 + 2 + d->mdata->write_page_length;
 	c.page = &buf;
 	c.page->bytes = 0;
@@ -410,6 +650,9 @@ void spc_select_write_params(struct burn_drive *d,
 
 void spc_getcaps(struct burn_drive *d)
 {
+	if (mmc_function_spy(d, "getcaps") <= 0)
+		return;
+
 	spc_inquiry(d);
 	spc_sense_caps(d);
 	spc_sense_error_params(d);
@@ -429,6 +672,9 @@ void spc_probe_write_modes(struct burn_drive *d)
 	int last_try = 0;
 	struct command c;
 
+	if (mmc_function_spy(d, "spc_probe_write_modes") <= 0)
+		return;
+
 	/* ts A70213 : added pseudo try_write_type 4 to set a suitable mode */
 	while (try_write_type != 5) {
 		burn_print(9, "trying %d, %d\n", try_write_type,
@@ -443,9 +689,12 @@ void spc_probe_write_modes(struct burn_drive *d)
 			try_block_type = useable_block_type;
 			last_try= 1;
 		}
+		scsi_init_command(&c, SPC_MODE_SELECT,sizeof(SPC_MODE_SELECT));
+/*
 		memcpy(c.opcode, SPC_MODE_SELECT, sizeof(SPC_MODE_SELECT));
-		c.retry = 1;
 		c.oplen = sizeof(SPC_MODE_SELECT);
+*/
+		c.retry = 1;
 		c.opcode[8] = 8 + 2 + 0x32;
 		c.page = &buf;
 
@@ -592,11 +841,8 @@ int burn_scsi_setup_drive(struct burn_drive *d, int bus_no, int host_no,
 	d->silent_on_scsi_error = 0;
 
 
-	d->idata = malloc(sizeof(struct burn_scsi_inquiry_data));
-	d->idata->valid = 0;
-	d->mdata = malloc(sizeof(struct scsi_mode_data));
-	d->mdata->valid = 0;
-	d->mdata->speed_descriptors = NULL;
+	d->idata = calloc(1, sizeof(struct burn_scsi_inquiry_data));
+	d->mdata = calloc(1, sizeof(struct scsi_mode_data));
 
 	/* ts A61007 : obsolete Assert in drive_getcaps() */
 	if(d->idata == NULL || d->mdata == NULL) {
@@ -605,6 +851,9 @@ int burn_scsi_setup_drive(struct burn_drive *d, int bus_no, int host_no,
 	                "Could not allocate new drive object", 0, 0);
 		return -1;
 	}
+	d->idata->valid = 0;
+	d->mdata->valid = 0;
+	d->mdata->speed_descriptors = NULL;
 	if(!(flag & 1)) {
 		ret = spc_setup_drive(d);
 		if (ret<=0)

libburn/spc.h

@@ -20,8 +20,17 @@ void spc_probe_write_modes(struct burn_drive *);
 void spc_request_sense(struct burn_drive *d, struct buffer *buf);
 int spc_block_type(enum burn_block_types b);
 int spc_get_erase_progress(struct burn_drive *d);
+
+/* ts A70315 : test_unit_ready with result parameters */
+int spc_test_unit_ready_r(struct burn_drive *d, int *key, int *asc, int *ascq);
+
 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, char *cmd_text,
+				int flag);
+
 /* ts A61021 : the spc specific part of sg.c:enumerate_common()
 */
 int spc_setup_drive(struct burn_drive *d);
@@ -47,4 +56,7 @@ 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);
+
 #endif /*__SPC*/

libburn/structure.c

@@ -40,6 +40,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 +66,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;
@@ -104,6 +108,8 @@ 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;
@@ -353,9 +359,13 @@ int burn_track_set_sectors(struct burn_track *t, int sectors)
 }
 
 
-/* ts A70218 */
+/* ts A70218 , API since A70328 */
 int burn_track_set_size(struct burn_track *t, off_t size)
 {
+	if (t->source == NULL)
+		return 0;
+	if (t->source->set_size == NULL)
+		return 0;
 	t->open_ended = (size <= 0);
 	return t->source->set_size(t->source, size);
 }

libburn/toc.c

@@ -128,9 +128,14 @@ void toc_find_modes(struct burn_drive *d)
 			if (e && !(e->control & 4)) {
 				t->mode = BURN_AUDIO;
 			} else {
+
+				t->mode = BURN_MODE1;
+/* ts A70519 : this does not work with Linux 2.4 USB because one cannot
+               predict the exact dxfer_size without knowing the sector type.
 				mem.sectors = 1;
 				d->read_sectors(d, lba, mem.sectors, &o, &mem);
 				t->mode = sector_identify(mem.data);
+*/
 			}
 		}
 }

libburn/transport.h

@@ -51,6 +51,7 @@ struct command
 	unsigned char opcode[16];
 	int oplen;
 	int dir;
+	int dxfer_len;
 	unsigned char sense[128];
 	int error;
 	int retry;
@@ -113,15 +114,21 @@ struct burn_format_descr {
 	off_t size;
 
 	/* the Type Dependent Parameter (usually the write alignment size) */
-	unsigned tdp;
+	unsigned int tdp;
 };
 
 
-#define LIBBURN_SG_MAX_SIBLINGS 16
-
 /** 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
+	*/
+	int drive_role;
+
 	int bus_no;
 	int host;
 	int id;
@@ -173,9 +180,12 @@ struct burn_drive
 	*/
 	int current_feat2fh_byte4;
 
-	/* ts A70114 : wether a DVD-RW media holds an incomplete session
+	/* 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 A61218 from 51h READ DISC INFORMATION */
 	int bg_format_status; /* 0=needs format start, 1=needs format restart*/
@@ -183,7 +193,7 @@ struct burn_drive
 	/* 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;
 
@@ -197,6 +207,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 */
@@ -225,8 +237,29 @@ struct burn_drive
 	struct buffer *buffer;
 	struct burn_progress progress;
 
+	/* 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;
+
+
 /* transport functions */
 	int (*grab) (struct burn_drive *);
 	int (*release) (struct burn_drive *);
@@ -306,6 +339,11 @@ 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 */

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

libcevap/extract_cgen_input.sh

@@ -0,0 +1,30 @@
+#!/bin/sh
+
+copy_mode=0
+
+while true
+do
+  read line
+  if test "$copy_mode" = "0"
+  then
+    if echo " $line" | grep '^ Cgen=' >/dev/null 2>&1
+    then
+      copy_mode=1
+      if echo " $line" | grep '^ Cgen=..' >/dev/null 2>&1
+      then
+        echo " $line" | sed -e 's/^ Cgen=//'
+      fi
+    elif echo " $line" | grep '^ =end Model=' >/dev/null 2>&1
+    then
+break
+    fi
+  else
+    if test " $line" = " @"
+    then
+      copy_mode=0
+      echo "@"
+    else
+      echo " $line" | sed -e 's/^ //'
+    fi
+  fi
+done

libcevap/libcevap_gen.sh

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+test_dir=.
+model_file=./libdax_model.txt
+xtr_dir=.
+cgen_dir=.
+# cgen_dir=~/projekte/cdrskin_dir/libburn-develop/libcevap
+
+cd "$test_dir" || exit 1
+test -e smem.h || exit 1
+
+cat "$model_file" | \
+  "$xtr_dir"/extract_cgen_input.sh | \
+  "$cgen_dir"/cgen -smem_local -ansi -global_include cevap_global.h \
+                   -overwrite "$@"
+

libcevap/libdax_model.txt

@@ -0,0 +1,944 @@
+
+#
+# libdax is the early working name for the successor software of libburn,
+# a library for writing information onto optical media, i.e. CD and DVD.
+# The current working name is libcevap, refering to various kinds of roasts in
+# Europe and Asia which share the property to be structured in smaller pieces.
+#
+# The reason for the replacement is the unclear copyright situation as well
+# as libburn's sketchy original state and the subsequential evolutionary
+# damages done by us in libburn code.
+# This does not mean libburn is shaky. Its current state just reflects the
+# virtual conflict of at least two programmer personalities and their goals.
+#
+
+#
+# Please: Nobody shall take the development of libcevap as a reason for not
+# programming an application which uses libburn.
+# libburn works now. libcevap is planned to work in future.
+#
+# libcevap will replace libburn in a controlled, application friendly way.
+# The first application of libcevap will be a libburn API wrapper which will
+# allow to perform all API calls of libburn which are proveable to work in
+# the current implementation. (Some CD stuff is not understood by us yet.
+# We will have to learn.)
+#
+# The libburn API will be frozen when libcevap has closed up to its current
+# capabilities. Nevertheless it may take profit from some of the future
+# progress in libcevap (e.g. new media types).
+# We hope that finally libcevap will have capabilities superior to libburn.
+# This will then be a reason to port applications to the libcevap API.
+#
+# Application programmers are advised to encapsulate their libburn API calls
+# in an own abstraction layer. The semantic concepts of burning will be
+# compatible between libburn and libcevap. I.e you will have a library object
+# to be started up, drives to be found and grabbed, media and their states
+# to be identified, sessions, tracks, burn options to be set, blanking,
+# formatting, and so on.
+# Data types, function calls, and quirks will be incompatible between both
+# APIs, though. 
+#
+
+# -------------------------------------------------------------------------
+
+# Originally this was a backup of text input clicketitoggled into ArgoUML
+# Meanwhile it becomes an intermediate storage for attributes and
+# class interconnections in the notation of my C stub generator CgeN
+# (see also end of this text)
+
+# next : work on completeness : cevapformat
+
+# Open questions:
+# - how to connect to GESTURES ? Globally ?
+
+
+Model=libdax
+
+ClassDiagram=Overview
+
+Class=API
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+The API is the only layer visible to the applications. It exposes MMC concepts
+which it reflects and augments by its own architectural concepts.
+Subordinates=EQUIP,JOB,AUX
+Cgen=\
+cevapi
+-r -m struct CevapequiP *equip
+-r -m struct CevapjoB *job
+-r -m struct CevapauX *aux
+-r -m struct CevapgestureS *gestures
+@
+=end Class
+
+Class=EQUIP
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+EQUIP represents the physical and logical equipment in reach of libdax.
+This includes the system, drives, media, and their current states.
+PeerToPeer=GESTURES
+Boss=API
+Cgen=\
+cevapequip
+-r -v struct CevapI *boss
+-r -m struct CevapsysteM *sys
+-v struct CevapgestureS *gestures
+@
+=end Class
+
+Class=JOB
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+JOB models the tasks to be performed via libdax.
+This includes disc, session, track, source, fifo, dewav, burn options.
+PeerToPeer=GESTURES
+Boss=API
+Cgen=\
+cevapjob
+-r -v struct CevapI *boss
+-r -m struct CevaptodO *todo
+-v struct CevapgestureS *gestures
+
+# >>>
+
+@
+=end Class
+
+Class=AUX
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+AUX bundles any models which are neither EQUIP nor JOB.
+This includes abort handler and message system.
+PeerToPeer=GESTURES
+Boss=API
+Cgen=\
+cevapaux
+-r -v struct CevapI *boss
+-v struct CevapgestureS *gestures
+
+# >>>
+
+@
+=end Class
+
+Class=GESTURES
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+GESTURES ist the procedural repertoire which interconnects EQUIP, JOB, and AUX
+and also provides to them the services from the SCSI oriented layers. 
+PeerToPeer=EQUIP,JOB,AUX
+Subordinates=SCSI_CMD
+Cgen=\
+cevapgestures
+-r -v struct CevapI *boss
+-v struct CevapequiP *equip
+-v struct CevapjoB *job
+-v struct CevapauX *aux
+-r -m struct CevapscmD *scsi_cmd
+
+# >>>
+
+@
+=end Class
+
+Class=SCSI_CMD
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+SCSI_CMD represents the semantic part of SCSI (i.e. mainly MMC) specs.
+This layer models each SCSI command that is used by libdax. It knows about
+its parameters and constraints with particular equipment and jobs.
+Boss=GESTURES
+Subordinates=Classes with SCSI_EXEC Interface
+Cgen=\
+cevapscmd
+-r -v struct CevapgestureS *boss
+-r -m struct CevapsexeC *scsi_exec
+
+# >>>
+
+@
+=end Class
+
+Interface=SCSI_EXEC
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=16.03.2007
+Documentation=\
+SCSI_EXEC hides the difference between the implementation principle of
+SCSI format+transport and the principle of SCSI service.
+Boss=SCSI_CMD
+Implementations=SCSI_FORMAT,SCSI_SERVICE
+Cgen=\
+cevapsexec
+-r -v struct CevapscmD *boss
+-p -v struct CevapsforM *scsi_format
+-p -v struct CevapsservicE *scsi_service
+-v int silent_on_scsi_error
+
+# >>>
+
+@
+=end Interface
+
+
+Class=OSDriveAspect
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=18.08.2007
+Documentation=\
+OSDriveAspect encapsulates operating system specific properties of an
+individual drive. It shall be handed out by SCSI_EXEC via the GESTURES layer
+to EquipDrive where it forms the link between cevap drive model and operating
+system driver.
+This class description models the implementation specific to Linux.
+Cgen=\
+cevaposdrv
+-r -v int fd
+
+# >>> ??? implement the sibling stuff which never worked properly ?
+
+@
+=end Class
+
+
+Class=SCSI_FORMAT
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+SCSI_FORMAT translates parameters of SCSI commands into CDBs, takes care for
+transport and decodes the reply into parameters.
+Boss=SCSI_CMD via SCSI_EXEC
+Subordinates=SCSI_TRANSPORT
+Cgen=\
+cevapsform
+-r -v struct CevapsexeC *boss
+-p -v struct CevapstransP *scsi_transport
+ 
+# former struct command
+-v unsigned char opcode[16] 
+-v int oplen 
+-v int dir 
+-v int dxfer_len 
+-v unsigned char sense[128] 
+-v int error 
+-v int retry 
+-v struct CevapbuffeR *page 
+
+# >>>
+
+@
+=end Class
+
+Class=SCSI_TRANSPORT
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+SCSI_TRANSPORT takes a formatted CDB from SCSI_FORMAT and makes the operating
+system perform a SCSI transaction. It then returns the reply data in raw form.
+Boss=SCSI_FORMAT
+Os_specific=yes
+Cgen=\
+cevapstransp
+-r -v struct CevapsforM *boss
+
+# >>>
+@
+=end Class
+
+Class=SCSI_SERVICE
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=11.03.2007
+Documentation=\
+SCSI_SERVICE provides the combined services of SCSI_FORMAT and SCSI_TRANSPORT
+via a set of parametrized functions which abstract SCSI command transactions.
+Boss=SCSI_CMD via SCSI_EXEC
+Os_specific=yes
+Cgen=\
+cevapsservice
+-r -v struct CevapsexeC *boss
+
+# >>>
+@
+=end Class
+
+=end ClassDiagram=Overview
+
+
+
+ClassDiagram=Equip_overview
+
+Class=EquipSystem
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=16.03.2007
+Documentation=\
+EquipSystem is the inner root class of EQUIP. It describes the system on
+which libdax is working. This includes the operating system, the system
+adapter classes, the drives.
+Boss=EQUIP
+Subordinates=EquipDrive*N
+Cgen=\
+cevapsystem
+-r -v struct CevapequiP *boss
+-r -m char *infotext
+-r -l struct CevapdrivE *drive
+-p -v struct CevapdrivE *eol_drive
+
+# >>> be boss of SCSI_CMD ? (Rather than GESTURES)
+
+# >>>
+@
+=end Class
+
+
+Class=EquipDrive
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=16.03.2007
+Documentation=\
+EquipDrive represents a drive, including its capabilities, its processing
+status, the media loaded.
+Subordinates=EquipMedia
+Boss=EquipSystem
+Cgen=\
+-l cevapdrive
+-r -v struct CevapsysteM *boss
+
+# Drive number
+-r -v int global_index
+ 
+# Persistent system drive address
+-r -m char *devname
+ 
+# Traditional SCSI address parameters (-1 if not applicable)
+-r -v int bus_no
+-r -v int host
+-r -v int id
+-r -v int channel
+-r -v int lun
+ 
+# (former struct burn_scsi_inquiry_data idata)
+# From 12h INQUIRY , spc3r23.pdf , 6.4.2 , Table 81
+-r -v char vendor[9]
+-r -v char product[17]
+-r -v char revision[5]
+# 1= above elements contain valid information
+-r -v int idata_valid
+ 
+# mc5r03c.pdf 5.3.2 Physical Interface Standard
+# 1=SCSI, 2=ATAPI, 3,4,6=FireWire, 7=SATA, 8=USB
+-r -v int phys_if_std
+# MMC-5 5.3.2 table 91 , e.g. "SCSI Family"
+-r -m char *phys_if_name
+
+# System despendent aspect of the drive (e.g. int fd;) 
+-r -v struct CevaposdrV *system_dep_drive_info
+
+# Result of the CD write mode x block type tests:
+# Index is for write mode : 0=packet , 1=TAO , 2=SAO , 3=raw
+# Bits are for block type
+# Numbering as in mc5r03c.pdf 7.5.4.13 Data Block Type, Table 668 :
+#    0=RAW0     (2352, Raw data)
+#    1=RAW16    (2368, Raw data with P and Q Sub-channel
+#    2=RAW96P   (2448, Raw data with P-W Sub-channel appended)
+#    3=RAW96R   (2448, Raw data with raw P-W Sub-channel appended)
+#    8=MODE1    (2048, ISO/IEC 10149)
+#    9=MODE2R   (2336, Mode 2 formless)
+#   10=MODE2F1  (2048, CD-ROM XA, form 1)
+#   11=MODE2F1X (2056, CD-ROM XA, form 1 plus 8 byte subheader)
+#   12=MODE2F2  (2324, CD-ROM XA, form 2)
+#   13=MODE2MIX (2332, CD-ROM XA, form 1, form 2, or mixed form)
+-r -v int block_types[4]
+
+# (former struct scsi_mode_data)
+# Information about the drive's capabilities, obtained via 5Ah MODE SENSE
+# from mode page 2Ah , mmc3r10g.pdf , 6.3.11 , Table 361
+# (which is deprecated in MMC-5 E.11)
+-p -v int mdata_buffer_size
+-p -v int mdata_dvdram_read
+-p -v int mdata_dvdram_write
+-p -v int mdata_dvdr_read
+-p -v int mdata_dvdr_write
+-p -v int mdata_dvdrom_read
+-p -v int mdata_cdrw_read
+-p -v int mdata_cdrw_write
+-p -v int mdata_cdr_read
+-p -v int mdata_cdr_write
+-p -v int mdata_max_read_speed
+-p -v int mdata_max_write_speed
+-p -v int madata_min_write_speed
+-p -v int mdata_cur_read_speed
+-p -v int mdata_cur_write_speed
+-p -v int mdata_simulate
+-p -v int mdata_c2_pointers
+-r -v int mdata_underrun_proof
+
+# Results from ACh GET PERFORMANCE, Type 03h
+# (Speed values go into *_*_speed)
+# (speed_descriptors became cevapperf which is under cevapmedia)
+-p -v int min_end_lba
+-p -v int max_end_lba
+
+# from mode page 01h , mmc5r03c.pdf , 7.3.2.1 , Table 657
+-p -v int mdata_retry_page_length
+-p -v int mdata_retry_page_valid
+
+# from mode page 05h , mmc5r03c.pdf , 7.5.4.1 , Table 664
+-p -v int mdata_write_page_length
+-p -v int mdata_write_page_valid
+
+# 1= above elements contain valid information
+-p -v int mdata_valid
+
+# The mutex shall be used to coordinate access to the drive in situations
+# where multi-threaded race conditions could disturb operations.
+# E.g. lock, read busy state, interpret, set busy state, unlock
+# A mere reader of the busy state does not have to lock because
+# reading of the state itself is atomar.
+-i -v pthread_mutex_t access_lock
+
+# Flags from feature 002Fh feature descriptor mmc5r03c.pdf 5.3.25 :
+#   bit1= DVD-RW supported
+#   bit2= Test Write available
+#   bit3= DVD-R DL supported
+#   bit6= Buffer Under-run Free recording available (page 05h BUFE)
+# Value -1 indicates that no 002Fh was current in the features list.
+-r -v int current_feat2fh_byte4
+
+# 0= drive is grabbed, 1= drive is not grabbed
+-v volatile int released
+
+# File descriptor of an eventual emulated drive
+-v int stdio_fd
+
+# >>> ???
+# (do we need a drive owned buffer to carry data from call to call or what ?)
+-v struct CevapbuffeR *buffer
+
+# List of profiles as reported by the drive
+-r -l struct CevapprofilE *profile
+-p -v struct CevapprofilE *eol_profile
+
+# Media currently loaded in the drive
+-r -m struct CevapmediA *media
+ 
+
+# >>> transport.h : toc_temp (what is this ? It belongs to BURN_WRITE_RAW)
+# >>>
+
+@
+=end Class
+
+
+Class=EquipMedia
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=16.03.2007
+Documentation=\
+EquipMedia represents an optical disc, including its type, its writeability,
+its formatting, its available formats and performances. 
+Subordinates=\
+EquipProfile*N,EquipFormat*N,EquipPerformance*N,EquipStatus,EquipMulticaps
+Boss=EquipDrive
+Cgen=\
+cevapmedia
+-r -v struct CevapdrivE *boss
+
+# Volatile and/or public properties of the media
+-r -m struct CevapstatuS *status
+
+# MMC-to-MMC feature info from 46h for DVD-RW.
+# Quite internal. Regard as opaque :)
+# 1 = incremental recording available, 0 = not available
+-r -v int current_has_feat21h
+
+# Link Size item number 0 from feature 0021h descriptor
+-r -v int current_feat21h_link_size
+
+# Wether a DVD-RW media holds an incomplete session
+# (which could need closing after write)
+-v int needs_close_session
+
+# From 51h READ DISC INFORMATION
+# 0=needs format start, 1=needs format restart
+-r -v int bg_format_status
+
+# From 23h READ FORMAT CAPACITY mmc5r03c.pdf 6.24
+# 1=unformatted, 2=formatted, 3=unclear
+-r -v int format_descr_type
+# meaning depends on format_descr_type
+-r -v off_t format_curr_max_size
+# dito
+-r -v unsigned int format_curr_blsas
+-r -v int best_format_type
+-r -v off_t best_format_size
+-r -l struct CevapformaT *format_descriptor
+-p -v struct CevapformaT *eol_format_descriptor
+
+# The specific capabilities and restrictions of the media
+-r -m struct CevapmcapS *multicaps
+
+# Results from ACh GET PERFORMANCE, Type 03h
+# (Speed values go into drive.mdata_*_*_speed)
+-r -l struct CevapperF *speed_descriptor
+-p -v struct CevapperF *eol_speed_descriptor
+
+# >>>
+
+@
+=end Class
+
+
+Class=EquipProfile
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=16.03.2007
+Documentation=\
+EquipProfile maps a MMC profile into libdax (See mmc5r03c.pdf chapter 5).
+A profile describes a set of features and may be either current, possible,
+disabled, or unavailable.
+Subordinates=EquipFeature*N
+Boss=EquipMedia
+Cgen=\
+-l cevapprofile
+-r -v struct CevapdrivE *boss
+-r -v int is_current
+-r -v int profile_code
+-r -v char *profile_text
+-r -v int is_cd_profile
+-r -v int is_supported_profile
+-r -l struct CevapfeaturE *feature
+-p -v struct CevapfeaturE *eol_feature
+@
+=end Class
+
+Class=EquipFeature
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=16.03.2007
+Documentation=\
+EquipFeature maps a MMC feature into libdax (See mmc5r03c.pdf chapter 5).
+A feature describes a set of SCSI commands and (implicitely) of use cases.
+Boss=EquipProfile
+Cgen=\
+-l cevapfeature
+-r -v struct CevapprofilE *boss
+
+# >>>
+
+@
+=end Class
+
+Class=EquipFormat
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=
+Documentation=\
+EquipFormat represents a single Formattable Capacity Descriptor
+as of mmc5r03c.pdf 6.24.3.3 .
+Boss=EquipMedia
+Cgen=\
+-l cevapformat
+-r -v struct CevapmediA *boss
+
+# format type: e.g 0x00 is "Full", 0x15 is "Quick"
+-r -v int type
+
+# the size in bytes derived from Number of Blocks
+-r -v off_t size
+
+# the Type Dependent Parameter (usually the write alignment size)
+-r -v unsigned int tdp
+
+# >>>
+
+@
+=end Class
+
+Class=EquipPerformance
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=
+Documentation=\
+>>> EquipPerformance
+Boss=EquipMedia
+Cgen=\
+-l cevapperf
+-r -v struct CevapmediA *boss
+
+# >>>
+
+@
+=end Class
+
+Class=EquipStatus
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=17.3.2007
+Documentation=\
+EquipStatus represents the status of media and drive. This includes 
+blank/appendable/closed, progress indicator.
+Boss=EquipMedia
+Cgen=\
+cevapstatus
+-r -v struct CevapmediA *boss
+-v int status
+-m char *status_text
+-v volatile int busy
+
+# 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.
+-v off_t media_capacity_remaining
+
+# Current write address during write jobs. (Next address to be written)
+# <<< does this belong to JOB ?
+-r -v int nwa
+
+# if > 0 : first lba on media that is too high for write
+-v int media_lba_limit
+
+-v struct CevapprogresS *progress
+
+# >>>
+
+@
+=end Class
+
+Class=EquipMulticaps
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=14.8.2007
+Documentation=\
+EquipMulticaps represents media dependent properties and media states which
+are either volatile or especially interesting to several other modules. This
+includes eventually existing sessions, closure status, profile dependent
+capabilities.
+Boss=EquipMedia
+Cgen=\
+cevapmcaps
+
+# The current profile out of the drive profile list
+-v struct CevapprofilE *current_profile
+
+# Wether the media is erasable (or overwriteable)
+-v int erasable
+
+# A description of the existing media content structure
+-r -m struct CevapdisC *disc
+
+# Start and end addresses out of ATIP.
+# From 43h READ TOC/PMA/ATIP , mmc5r03c.pdf , 6.26
+-r -v int start_lba
+-r -v int end_lba
+
+# From 51h READ DISC INFORMATION Number of Sessions (-1)
+-v int complete_sessions
+
+# From 51h READ DISC INFORMATION Last Track Number in Last Session
+-v int last_track_no
+
+# >>> libburn.h:struct burn_multi_caps
+
+@
+=end Class
+
+Class=EquipTocItem
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=14.8.2007
+Boss=
+Cgen=\
+-l cevaptocitem
+-r -v struct CevapdisC *boss
+-v int session
+-v int valid
+-v int control
+
+# obscure info from CD TOC : possibly length of track
+-v unsigned char point
+-v unsigned char min
+-v unsigned char sec
+-v unsigned char frame
+ 
+-v int pmin
+-v int psec
+-v int pframe
+
+-v int start_lba
+-v int track_blocks
+@
+=end Class
+
+
+
+=end ClassDiagram=Equip_overview
+
+
+ClassDiagram=Job_overview
+
+Class=JobTodo
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=18.3.2007
+Documentation=\
+JobTodo records what is to be done during a job. This includes peripheral
+actions like tray load/eject and central actions like blank, format, burn.
+Subordinates=JobDisc,JobOptions
+Cgen=\
+cevaptodo
+-v volatile int cancel
+
+# >>>
+
+@
+=end Class
+
+Class=JobDisc
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=18.3.2007
+Documentation=\
+JobDisc models a disc structure. Either one which already exists or
+one which is to be created in a job run.
+Subordinates=JobSession*N
+Boss=JobTodo
+Cgen=\
+cevapdisc
+-l struct CevapsessioN *session
+-p -v struct CevapsessioN *eol_session
+-l struct CevaptociteM *toc_entry
+-p -v struct CevaptociteM *eol_toc_entry
+
+# >>> take over services of struct burn_disc
+
+@
+=end Class
+
+Class=JobSession
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=18.3.2007
+Documentation=\
+JobSession represents a recording session. A session usually bundles
+several tracks. Traditionally the last session of a disc is recognized
+by operating systems as the thing to be mounted.
+Subordinates=JobTrack*N,JobFifo
+Boss=JobDisc
+Cgen=\
+-l cevapsession
+-r -v struct CevapdisC *boss
+
+# >>>
+
+-l struct CevaptracK *track
+-p -v struct CevaptracK *eol_track
+
+# >>>
+
+@
+=end Class
+
+Class=JobTrack
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=18.3.2007
+Documentation=\
+JobTrack represents a track to be recorded. A track mainly is associated with
+a data source but in many cases it also becomes a recognizable entity on the
+target media.
+Subordinates=JobBlock*N,JobTrackFilter,JobSource
+Boss=JobSession
+Cgen=\
+-l cevaptrack
+-r -v struct CevapsessioN *boss
+
+# >>>
+
+@
+=end Class
+
+Class=JobBlock
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=18.3.2007
+Documentation=\
+JobBlock represents a single output data transaction unit. On CD this is
+the same as an addressable media block resp. sector. On DVD this might be
+an addressable block od 2k or a packet of e.g. 32k.
+Boss=JobTrack
+Cgen=\
+cevapblock
+-v int alba
+-v int rlba
+
+# >>>
+
+@
+=end Class
+
+Class=JobSource
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=8.4.2007
+Documentation=\
+JobSource represents a data source for a track. Typically this is a disk
+file or a stream file descriptor like stdin.
+Subordinates=JobSourceBlock*N
+Boss=JobTrack
+=end Class
+
+Class=JobSourceBlock
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=8.4.2007
+Documentation=\
+JobSourceBlock represents a single input data transaction unit.
+Boss=JobSource
+=end Class
+
+Class=JobFifo
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=8.4.2007
+Documentation=\
+JobFifo reads data via JobTrackFilter and buffers them until JobBlock can
+accept them.
+Boss=JobSession
+=end Class
+
+Class=JobTrackFilter
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=8.4.2007
+Documentation=\
+JobTrackFilter reads data from JobSourceBlock, processes them and presents
+them to JobFifo or JobBlock. This includes stripping of .wav headers.
+Boss=JobTrack
+=end Class
+
+Class=JobOptions
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=18.3.2007
+Documentation=\
+JobOptions bundles the adjustable parameters of a job. This includes dummy
+mode, speed, appendability, blank mode, format selection, write mode, 
+underrun protection, random access addressing.
+Boss=JobTodo
+Cgen=\
+cevapjobopts
+
+# >>>
+
+# Keeping an eye on the drive buffer
+-v int wait_for_buffer_free
+-v unsigned int wfb_min_usec
+-v unsigned int wfb_max_usec
+-v unsigned int wfb_timeout_sec
+-v unsigned int wfb_min_percent
+-v unsigned int wfb_max_percent
+
+# >>> -m struct params params (used by disabled read cd funtionality)
+
+@
+=end Class
+
+Class=JobBuffer
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=13.8.2007
+Documentation=\
+JobBuffer is an intermediate storage for the content of several JobBlock
+or JobSourceBlock.
+Cgen=\
+cevapbuffer
+-r -m unsigned char *data
+-v int sectors
+-v int bytes
+@
+=end Class
+
+Class=JobProgress
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=13.8.2007
+Documentation=\
+JobProgress reflects the state and parts of the history of a job
+Cgen=\
+cevapprogress
+
+# Keeping an eye on the drive buffer
+-v int nominal_write_speed
+-v off_t pessimistic_buffer_free
+-v int pbf_altered
+-v unsigned int pessimistic_writes
+-v unsigned int waited_writes
+-v unsigned int waited_tries
+-v unsigned int waited_usec
+
+# >>> the info provided by struct burn_progress
+
+# >>> 
+@
+=end Class
+
+Class=
+Author=Thomas Schmitt <scdbackup@gmx.net>
+Version=1.0
+Since=
+Documentation=\
+=end Class
+
+=end ClassDiagram=Equip_overview
+
+
+ClassDiagram=Gestures_overview
+
+# >>>
+
+=end ClassDiagram=Gestures_overview
+
+
+
+=end Model=libdax
+
+----------------------------------------------------------------------------
+Notes:
+----------------------------------------------------------------------------
+
+ Compile cgen:
+   ( cd libcevap && cc -g -o cgen cgen.c ctyp.c smem.c )
+
+ Generate C stubs:
+   ( cd libcevap && ./libcevap_gen.sh )
+ Option -lowercase would generate all lowercase struct and function names
+
+ Compile test:
+   ( cd libcevap && ( rm a.out ; cc -g main.c cevap*.c smem.c ) )
+ Option -DCevap_lowercasE would tell main.c that -lowercase was used above.
+
+
+----------------------------------------------------------------------------
+
+For a description of CgeN see libcevap/cgen.txt
+
+The generated code uses smem.[ch] out of one of my BSD licensed projects.
+For a description see end of libcevap/smem.h .
+
+------------------------------------------------------------------------

libcevap/main.c

@@ -0,0 +1,39 @@
+
+/*
+   cc -g -DCevap_lowercasE -c main.c  
+*/
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "cevapi.h"
+
+#include "smem.h"
+
+int main(int argc, char **argv)
+{
+#ifdef Cevap_lowercasE
+ struct cevapi *cevap= NULL;
+#else
+ struct CevapI *cevap= NULL;
+#endif
+ int ret;
+
+ /* full memory supervision */
+ Smem_set_record_items(1);
+
+ /* one short trip for testing */ 
+#ifdef Cevap_lowercasE
+ ret= cevapi_new(&cevap,0);
+ if(ret>0)
+   cevapi_destroy(&cevap,0);
+#else /* Cevap_lowercasE */
+ ret= Cevapi_new(&cevap,0);
+ if(ret>0)
+   Cevapi_destroy(&cevap,0);
+#endif /* ! Cevap_lowercasE */
+
+ /* report any leaked memory */
+ Smem_stderr(1|2);
+
+ exit(ret<=0);
+}

libcevap/smem.c

@@ -0,0 +1,445 @@
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+#define Smem_included_by_smem_C
+#include "smem.h"
+
+
+
+/* ------------------------------ SmemiteM ----------------------------- */
+
+
+int Smemitem_new(item,data,size,next,hash_start,flag)
+struct SmemiteM **item;
+char *data;
+size_t size;
+struct SmemiteM *next;
+struct SmemiteM **hash_start;
+int flag;
+{
+ struct SmemiteM *t;
+
+ *item= t= (struct SmemiteM *) malloc(sizeof(struct SmemiteM));
+ if(t==NULL)
+   return(-1);
+ t->data= data;
+ t->size= size;
+ t->prev= NULL;
+ t->next= next;
+
+#ifdef Smem_with_hasH
+ t->hash_next= NULL;
+ t->hash_prev= NULL;
+#endif /* Smem_with_hasH */
+
+ if(next!=NULL) {
+   if(next->prev!=NULL) {
+     t->prev= next->prev;
+     next->prev->next= t;
+   }
+   next->prev= t;
+ }
+
+#ifdef Smem_with_hasH
+ if(hash_start!=NULL) {
+   t->hash_next= *hash_start;
+   if(t->hash_next!=NULL) {
+     t->hash_next->hash_prev= t;
+   }
+   *hash_start= t;
+ }
+#endif /* Smem_with_hasH */
+ 
+ return(1);
+}
+
+
+int Smemitem_destroy(in_item,hash_start,flag)
+struct SmemiteM **in_item;
+struct SmemiteM **hash_start;
+int flag;
+{
+ struct SmemiteM *item;
+
+ item= *in_item;
+ if(item==NULL)
+   return(0);
+ if(item==Smem_start_iteM)
+   Smem_start_iteM= item->next;
+ if(item->prev!=NULL)
+   item->prev->next= item->next;
+ if(item->next!=NULL)
+   item->next->prev= item->prev;
+
+#ifdef Smem_with_hasH
+ if(hash_start!=NULL) {
+   if(item==*hash_start)
+     *hash_start= item->hash_next;
+   if(item->hash_prev!=NULL)
+     item->hash_prev->hash_next= item->hash_next;
+   if(item->hash_next!=NULL)
+     item->hash_next->hash_prev= item->hash_prev;
+ }
+#endif /* Smem_with_hasH */
+ 
+ free((char *) item);
+ *in_item= NULL;
+ return(1);
+}
+
+
+int Smemitem_report(item,line,flag)
+struct SmemiteM *item;
+char line[1024];
+int flag;
+{
+ char *cpt;
+ int i,upto;
+
+ sprintf(line,"%4lu bytes at %8.8lx ",(unsigned long) item->size,
+                                      (unsigned long) item->data);
+ cpt= line+strlen(line); 
+ if(item->size<=256)
+   upto= item->size;
+ else
+   upto= 256;
+ if(item->data!=NULL) {
+   strcpy(cpt,"= \"");
+   cpt+= 3;
+   for(i=0;i<upto;i++){
+     if(item->data[i]<32 || item->data[i]>=127 || item->data[i]=='\\') {
+       sprintf(cpt,"\\%2.2X",(unsigned char) item->data[i]);
+       cpt+= 3;
+     } else {
+       *(cpt++)= item->data[i];
+     }
+   }
+   if(i<item->size) {
+     sprintf(cpt,"\" [truncated]");
+   } else {
+     *(cpt++)= '"';
+     *cpt= 0;
+   }  
+ }
+ return(1);
+}
+
+
+int Smemitem_stderr(item,flag)
+struct SmemiteM *item;
+int flag;
+{
+ char line[1024];
+ Smemitem_report(item,line,0);
+ fprintf(stderr,"%s\n",line);
+ return(1);
+}
+
+
+
+/* -------------------------------- Smem ------------------------------ */
+
+
+int Smem_protest(line,flag)
+char *line;
+int flag;
+{
+ fprintf(stderr,"%s\n",line);
+ return(1); 
+}
+
+
+int Smem_hashindex(ptr,flag)
+char *ptr;
+int flag;
+{
+ unsigned long idx;
+
+ idx= (unsigned long) ptr;
+ return((idx>>Smem_hashshifT)%(Smem_hashsizE));
+}
+
+
+/* find a certain memory item */
+struct SmemiteM *Smem_find_item(ptr,flag)
+char *ptr;
+int flag;
+{
+ int misscount= 0,idx;
+ struct SmemiteM *current;
+
+#ifdef Smem_with_hasH
+
+ idx= Smem_hashindex(ptr,0);
+ for(current= Smem_hasH[idx];current!=NULL;current= current->hash_next) {
+   if(current->data==ptr)
+     return(current);
+   misscount++;
+ }
+
+#else /* Smem_with_hasH */
+
+ for(current= Smem_start_iteM;current!=NULL;current= current->next) {
+   if(current->data==ptr)
+     return(current);
+   misscount++;
+ }
+
+#endif /* ! Smem_with_hasH */
+
+ return(NULL);
+}
+
+
+int Smem_search_and_delete(ptr,flag)
+char *ptr;
+int flag;
+/*
+ bit0= revoke registration : decrement counters
+*/
+{
+ int idx;
+ struct SmemiteM *current;
+
+ current= Smem_find_item(ptr,0);
+ if(current==NULL)
+   return(0);
+ Smem_record_counT--;
+ Smem_record_byteS-= current->size;
+ idx= Smem_hashindex(ptr,0);
+ Smemitem_destroy(&current,&(Smem_hasH[idx]),0);
+ Smem_hash_counteR[idx]-= 1.0;
+ if(flag&1) {
+   Smem_malloc_counT--;
+   Smem_pending_counT--;
+ }
+ return(1);   
+}
+
+
+char *Smem_malloc(size)
+size_t size;
+{
+ int idx;
+ char *cpt;
+
+ if(size==0) {
+   Smem_protest("###########  smem.c : malloc(0) caught",0);
+   return(NULL);
+ }
+
+ /* if(size==1032)
+   cpt= NULL; / * set breakpoint here to find requests of certain size */
+
+ cpt= (char *) malloc(size);
+ if(cpt==NULL) {
+   char text[161];
+   sprintf(text,"###########  smem.c : malloc( %lu ) returned NULL",
+                (unsigned long) size);
+   Smem_protest(text,0);
+   return(NULL);
+ }
+ /* if(cpt==0x080a1e20)
+   cpt= NULL; / * set breakpoint here to find origin of certain address  */
+
+ Smem_malloc_counT++;
+ Smem_pending_counT++;
+ if(Smem_record_itemS) {
+   idx= Smem_hashindex(cpt,0);
+   Smem_hash_counteR[idx]+= 1.0;
+   if(Smemitem_new(&Smem_start_iteM,cpt,size,Smem_start_iteM,
+                                             &(Smem_hasH[idx]),0)<=0) {
+     Smem_protest(
+           "###########  smem.c : malloc( sizeof(SmemiteM) ) returned NULL",0);
+     return(NULL);
+   }
+   Smem_record_counT++;
+   Smem_record_byteS+= size;
+ }
+ return(cpt);
+}
+
+
+int Smem_free(ptr)
+char *ptr;
+{
+ if(ptr==NULL) {
+   Smem_protest("########### smem.c : free() of NULL pointer caught",0);
+   return(0);
+ }
+ if(Smem_record_itemS) {
+   if(Smem_search_and_delete(ptr,0)<=0) {
+     Smem_protest("########### smem.c : free() of unrecorded pointer caught",0);
+     return(0);
+   }
+ }
+ Smem_free_counT++;
+ Smem_pending_counT--;
+ free(ptr);
+ return(1);
+}
+
+
+int Smem_report(line,flag)
+char line[1024];
+int flag;
+{
+ sprintf(line,"malloc= %.f , free= %.f , pending= %.f",
+              Smem_malloc_counT,Smem_free_counT,Smem_pending_counT);
+ if(Smem_record_itemS) {
+   sprintf(line+strlen(line)," , bytes=%.f , records= %.f",
+                             Smem_record_byteS,Smem_record_counT);
+ }
+ return(1);
+}
+
+
+int Smem_stderr(flag)
+int flag;
+/*
+ bit0= report 50 youngest pending items too
+ bit1= do not report if nothing is pending
+*/
+{
+ struct SmemiteM *current;
+ char line[1024];
+ int i= 0;
+
+ if(flag&2)
+   if(Smem_pending_counT==0.0 
+      && Smem_record_counT==0.0 
+      && Smem_record_byteS==0.0)
+     return(2);
+ Smem_report(line,0);
+ fprintf(stderr,"%s\n",line);
+ if(flag&1) {
+   for(current= Smem_start_iteM;current!=NULL;current= current->next) {
+     Smemitem_stderr(current,0);
+     if(++i>=50)
+   break;
+   }
+   if(current!=NULL)
+     if(current->next!=NULL)
+       fprintf(stderr,"[list truncated]\n");
+ }
+ return(1);
+}
+
+
+int Smem_set_record_items(value)
+int value;
+{
+ int i;
+
+ if(!Smem_hash_initializeD) {
+   for(i=0;i<Smem_hashsizE;i++) {
+     Smem_hasH[i]= NULL;
+     Smem_hash_counteR[i]= 0.0;
+   }
+   Smem_hash_initializeD= 1;
+ }
+ Smem_record_itemS= value;
+ return(1);
+}
+
+
+int Smem_is_recorded(ptr,flag)
+char *ptr;
+int flag;
+/*
+ bit0= complain if return(0)
+*/
+{
+ if(Smem_record_itemS==0)
+   return(2);
+ if(Smem_find_item(ptr,0)!=NULL)
+   return(1);
+ if(flag&1)
+   Smem_protest("########### smem.c : free() of unrecorded pointer caught",0);
+ return(0);
+}
+
+
+/* A simple C string cloner */
+int Smem_clone_string(ptr,text)
+char **ptr;
+char *text;
+{
+ *ptr= Smem_malloC(strlen(text)+1);
+ if(*ptr==NULL)
+   return(-1);
+ strcpy(*ptr,text);
+ return(1);
+}
+
+
+/* ----------------- for usage via debugger commands --------------------- */
+
+
+/* find a certain memory item */
+struct SmemiteM *Smem_find_data(ptr)
+char *ptr;
+{
+  return(Smem_find_item(ptr,0));
+}
+
+
+/* browsing the list */
+struct SmemiteM *Smem_fetch_item(step,flag)
+int step;
+int flag;
+/*
+ bit0= reset cursor (and therefore address absolutely)
+*/
+{
+ static struct SmemiteM *current= NULL;
+
+ if((flag&1)||current==NULL)
+   current= Smem_start_iteM;
+ if(step>0) {
+   for(;current!=NULL;current= current->next) {
+     if(step==0)
+       return(current);
+     step--;
+   }
+ } else if(step<0) {
+   for(;current!=NULL;current= current->prev) {
+     if(step==0)
+       return(current);
+     step++;
+   }
+ } else {
+   return(current);
+ }
+ return(NULL);
+}
+
+
+int Smem_print_hash_counter() {
+ int i;
+
+ for(i=0;i<Smem_hashsizE;i++)
+   printf("%4d :  %10.f\n",i,Smem_hash_counteR[i]);
+ return(1);
+}
+
+
+/* delete all recorded memory items */
+int Smem_delete_all_items()
+{
+ int ret;
+
+ while(Smem_start_iteM!=NULL) {
+   ret= Smem_free(Smem_start_iteM->data);
+   if(ret<=0)
+     return(0);
+ }
+ return(1);
+}
+
+

libcevap/smem.h

@@ -0,0 +1,165 @@
+
+#ifndef Smem_includeD
+#define Smem_includeD
+
+
+/* compile time adjustable parameters : */
+
+/* if not defined, flat malloc() and free() is used */
+#define Smem_own_functionS
+#ifdef Smem_no_own_functionS
+#undef Smem_own_functionS
+#endif /* Smem_no_own_functionS */
+
+/* if not defined, the record items will be smaller by 8 byte
+   but deletion of items may be much slower */
+#define Smem_with_hasH
+
+
+
+struct SmemiteM {
+
+ char *data;
+ size_t size;
+
+ struct SmemiteM *prev,*next;
+
+ struct SmemiteM *hash_prev,*hash_next;
+
+};
+
+
+
+
+#ifdef Smem_own_functionS
+
+char *Smem_malloc();
+int Smem_free();
+
+#define TSOB_FELD(typ,anz) (typ *) Smem_malloc((anz)*sizeof(typ));
+#define Smem_malloC Smem_malloc
+#define Smem_freE Smem_free
+
+#else /* Smem_own_functionS */
+
+#define TSOB_FELD(typ,anz) (typ *) malloc((anz)*sizeof(typ));
+#define Smem_malloC malloc
+#define Smem_freE free
+
+#endif /* ! Smem_own_functionS */
+
+int Smem_set_record_items();
+int Smem_stderr();
+int Smem_clone_string();
+
+
+#define Smem_hashsizE 251
+#define Smem_hashshifT 8
+
+#ifdef Smem_included_by_smem_C
+
+double Smem_malloc_counT= 0.0;
+double Smem_free_counT= 0.0;
+double Smem_pending_counT= 0.0;
+struct SmemiteM *Smem_start_iteM= NULL;
+struct SmemiteM *Smem_hasH[Smem_hashsizE];
+double Smem_hash_counteR[Smem_hashsizE];
+
+/* these both init values are essential, since setting Smem_record_itemS=1
+   by use of Smem_set_record_items() initializes the hash array
+   (i do not really trust the compiler producers to have read K&R) */
+int Smem_hash_initializeD= 0;
+int Smem_record_itemS= 0;
+
+double Smem_record_counT= 0.0;
+double Smem_record_byteS= 0.0;
+
+#else /* Smem_included_by_smem_C */
+
+extern double Smem_malloc_counT;
+extern double Smem_free_counT;
+extern double Smem_pending_counT;
+extern struct SmemiteM *Smem_start_iteM;
+extern struct SmemiteM *Smem_hasH[Smem_hashsizE];
+extern double Smem_hash_counteR[Smem_hashsizE];
+extern int Smem_hash_initializeD;
+extern int Smem_record_itemS;
+extern double Smem_record_counT;
+extern double Smem_record_byteS;
+
+#endif /* ! Smem_included_by_smem_C */
+
+
+
+#endif /* ! Smem_includeD */
+
+
+/*
+
+                                   smem
+
+ Functions to replace  malloc()  and  free() in order to get more control
+ over memory leaks or spurious errors caused by faulty usage of malloc()
+ and free(). 
+
+
+ Sourcecode provisions:
+ 
+ Use only the following macros for memory management:
+    TSOB_FELD(type,count)  creates an array of items of given type 
+    Smem_malloC()          analogue of malloc()
+    Smem_freE()            analogue of free()
+ One may #define malloc Smem_malloC resp. #define free Smem_freE 
+ but better would be to review (and often to streamline) the sourcecode
+ in respect to those two functions. 
+
+
+ Speed versus control:
+
+ In production versions, where maximum speed is required, one may undefine
+ the macro  Smem_own_functionS  in  smem.h . 
+ This causes the above macros to directly invoke malloc() and free() without
+ any speed reduction (and without any additional use).
+ Undefinitio can be done globaly by modifying smem.h or locally by defining
+  Smem_no_own_functionS  before including smem.h .
+
+ If Smem_own_functionS remains defined, then the functions
+   Smem_malloc() 
+   Smem_free()
+ are used rather than malloc() and free().
+ They count the number of calls to maintain a rough overview of memory usage.
+ Smem_malloc() additionally checks for 0 size and Smem_free() checks for
+ NULL pointers, which they both report to stderr. Eventually one should set
+ a breakpoint in function Smem_protest() to learn about the origin of such
+ messages.
+ A status line may be obtained by  Smem_report()  or printed by Smem_stderr().
+
+ As long as the variable Smem_record_itemS is set to 0, there is not very much
+ overhead compared with malloc() and free().
+ If the variable is set to 1 by Smem_set_record_items() then all malloc()
+ results are kept in a list where they will be deleted by their corresponding
+ Smem_free() calls. If a pointer is to be freed, which is not recorded in the
+ list then an error message will be printed to stderr. The memory will not
+ be freed !
+ This mode not only may be very slow, it also consumes at least 16 byte per
+ piece of data which was obtained by malloc as long as it has not been freed.
+ Due to the current nature of the list, large numbers of memory items are freed
+ much faster in the reverse order of their creation. If there is a list of
+ 100000 strings to delete, it is very rewarding to free the youngest ones first.
+ A shortcut via hashing is available but consumes 24 bytes rather than 16.
+ (see above  Smem_with_hasH  )
+
+ The function Smem_is_recorded() can be used to check wether a pointer is
+ valid according to the list. It returns :
+   0 = is not in list , 1 = is in list , 2 = recording is off 
+
+ If one decides to start recording malloc() results in the midst of a program
+ run, one has to be aware of false protests of Smem_free() if a memory piece
+ has been allocated before recording started. This will also cause those pieces
+ to be memory leaks because Smem_free() refuses to delete them. (Freeing memory
+ that was not obtained by malloc or was already freed previously can result in
+ deferred SIGSEGV or similar trouble, depending on OS and library.)
+ Also in that case one should stop recording before ending the program, to
+ avoid a lot of false complaints about longliving memory objects.    
+
+*/

test/libburner.c

@@ -1,15 +1,15 @@
 
 /* test/libburner.c , API illustration of burning data or audio tracks to CD */
-/* Copyright (C) 2005 - 2006 Thomas Schmitt <scdbackup@gmx.net> */
-/* Provided under GPL, see also "License and copyright aspects" at file end */
+/* Copyright (C) 2005 - 2007 Thomas Schmitt <scdbackup@gmx.net> */
+/* Provided under GPLv2,see also "License and copyright aspects" at file end */
 
 
 /**                               Overview 
   
   libburner is a minimal demo application for the library libburn as provided
-  on  http://libburnia.pykix.org . It can list the available devices, can
-  blank a CD-RW or DVD-RW, can format a DVD-RW, and can burn to CD-R, CD-RW,
-  DVD+RW, DVD-RAM or DVD-RW. Not supported yet: DVD+R [DL].
+  on  http://libburnia-project.org . It can list the available devices, can
+  blank a CD-RW or DVD-RW, can format a DVD-RW, can burn to CD-R, CD-RW, DVD-R,
+  DVD+R, DVD+RW, DVD-RAM or DVD-RW. Not supported yet: double layer media.
 
   It's main purpose, nevertheless, is to show you how to use libburn and also
   to serve the libburnia team as reference application. libburner.c does indeed
@@ -123,21 +123,28 @@ int libburner_aquire_by_adr(char *drive_adr)
 	int ret;
 	char libburn_drive_adr[BURN_DRIVE_ADR_LEN];
 
+	/* Some not-so-harmless drive addresses get blocked in this demo */
+	if (strncmp(drive_adr, "stdio:/dev/fd/", 14) == 0 ||
+		strcmp(drive_adr, "stdio:-") == 0) {
+		fprintf(stderr, "Will not work with pseudo-drive '%s'\n",
+			drive_adr);
+		return 0;
+	}
+
 	/* This tries to resolve links or alternative device files */
 	ret = burn_drive_convert_fs_adr(drive_adr, libburn_drive_adr);	
 	if (ret<=0) {
-		fprintf(stderr,"Address does not lead to a CD burner: '%s'\n",
-			drive_adr);
-		return ret;
+		fprintf(stderr, "Address does not lead to a CD burner: '%s'\n",
+				 drive_adr);
+		return 0;
 	}
-
-	printf("Aquiring drive '%s' ...\n",libburn_drive_adr);
-	ret = burn_drive_scan_and_grab(&drive_list,libburn_drive_adr,1);
+	fprintf(stderr,"Aquiring drive '%s' ...\n", libburn_drive_adr);
+	ret = burn_drive_scan_and_grab(&drive_list, libburn_drive_adr, 1);
 	if (ret <= 0) {
 		fprintf(stderr,"FAILURE with persistent drive address  '%s'\n",
 			libburn_drive_adr);
 	} else {
-		printf("Done\n");
+		fprintf(stderr,"Done\n");
 		drive_is_grabbed = 1;
 	}
 	return ret;
@@ -163,7 +170,7 @@ int libburner_aquire_by_driveno(int *driveno)
 
 	printf("Beginning to scan for devices ...\n");
 	while (!burn_drive_scan(&drive_list, &drive_count))
-		usleep(1002);
+		usleep(100002);
 	if (drive_count <= 0 && *driveno >= 0) {
 		printf("FAILED (no drives found)\n");
 		return 0;
@@ -350,8 +357,12 @@ int libburner_format_row(struct burn_drive *drive)
 
 /** Brings preformatted track images (ISO 9660, audio, ...) onto media.
     To make sure a data image is fully readable on any Linux machine, this
-    function adds 300 kB of padding to the (usualy single) track.
+    function adds 300 kiB of padding to the (usualy single) track.
     Audio tracks get padded to complete their last sector.
+    A fifo of 4 MB is installed between each track and its data source.
+    Each of the 4 MB buffers gets allocated automatically as soon as a track
+    begins to be processed and it gets freed as soon as the track is done.
+    The fifos do not wait for buffer fill but writing starts immediately.
 
     In case of external signals expect abort handling of an ongoing burn to
     last up to a minute. Wait the normal burning timespan before any kill -9.
@@ -363,7 +374,7 @@ int libburner_payload(struct burn_drive *drive,
 		      char source_adr[][4096], int source_adr_count,
 		      int multi, int simulate_burn, int all_tracks_type)
 {
-	struct burn_source *data_src;
+	struct burn_source *data_src, *fifo_src[99];
 	struct burn_disc *target_disc;
 	struct burn_session *session;
 	struct burn_write_opts *burn_options;
@@ -372,14 +383,17 @@ int libburner_payload(struct burn_drive *drive,
 	struct burn_progress progress;
 	time_t start_time;
 	int last_sector = 0, padding = 0, trackno, unpredicted_size = 0, fd;
+	int fifo_chunksize = 2352, fifo_chunks = 1783; /* ~ 4 MB fifo */
 	off_t fixed_size;
 	char *adr, reasons[BURN_REASONS_LEN];
 	struct stat stbuf;
 
 	if (all_tracks_type != BURN_AUDIO) {
 		all_tracks_type = BURN_MODE1;
-		/* a padding of 300 kB helps to avoid the read-ahead bug */
+		/* a padding of 300 kiB helps to avoid the read-ahead bug */
 		padding = 300*1024;
+		fifo_chunksize = 2048;
+		fifo_chunks = 2048; /* 4 MB fifo */
 	}
 
 	target_disc = burn_disc_create();
@@ -390,6 +404,7 @@ int libburner_payload(struct burn_drive *drive,
 	  tracklist[trackno] = track = burn_track_create();
 	  burn_track_define_data(track, 0, padding, 1, all_tracks_type);
 
+	  /* Open file descriptor to source of track data */
 	  adr = source_adr[trackno];
 	  fixed_size = 0;
 	  if (adr[0] == '-' && adr[1] == 0) {
@@ -403,6 +418,8 @@ int libburner_payload(struct burn_drive *drive,
 	  }
 	  if (fixed_size==0)
 		unpredicted_size = 1;
+
+	  /* Convert this filedescriptor into a burn_source object */
 	  data_src = NULL;
 	  if (fd>=0)
 	  	data_src = burn_fd_source_new(fd, -1, fixed_size);
@@ -414,14 +431,28 @@ int libburner_payload(struct burn_drive *drive,
 				strerror(errno));
 		return 0;
 	  }
-	  if (burn_track_set_source(track, data_src) != BURN_SOURCE_OK) {
+	  /* Install a fifo object on top of that data source object */
+	  fifo_src[trackno] = burn_fifo_source_new(data_src,
+					fifo_chunksize, fifo_chunks, 0);
+	  if (fifo_src[trackno] == NULL) {
+		fprintf(stderr,
+			"FATAL: Could not create fifo object of 4 MB\n");
+		return 0;
+	  }
+
+	  /* Use the fifo object as data source for the track */
+	  if (burn_track_set_source(track, fifo_src[trackno])
+							 != BURN_SOURCE_OK) {
 		printf("FATAL: Cannot attach source object to track object\n");
 		return 0;
 	  }
 
 	  burn_session_add_track(session, track, BURN_POS_END);
 	  printf("Track %d : source is '%s'\n", trackno+1, adr);
+
+	  /* Give up local reference to the data burn_source object */
 	  burn_source_free(data_src);
+	  
         } /* trackno loop end */
 
 	/* Evaluate drive and media */
@@ -461,25 +492,44 @@ int libburner_payload(struct burn_drive *drive,
 
 	burn_write_opts_free(burn_options);
 	while (burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING)
-		usleep(1002);
+		usleep(100002);
 	while (burn_drive_get_status(drive, &progress) != BURN_DRIVE_IDLE) {
-		if( progress.sectors <= 0 || progress.sector == last_sector)
+		if (progress.sectors <= 0 ||
+		    (progress.sector >= progress.sectors - 1 &&
+	             !unpredicted_size) ||
+		    (unpredicted_size && progress.sector == last_sector))
 			printf(
-			     "Thank you for being patient since %d seconds.\n",
+			     "Thank you for being patient since %d seconds.",
 			     (int) (time(0) - start_time));
 		else if(unpredicted_size)
-			printf("Track %d : sector %d\n", progress.track+1,
+			printf("Track %d : sector %d", progress.track+1,
 				progress.sector);
 		else
-			printf("Track %d : sector %d of %d\n",progress.track+1,
+			printf("Track %d : sector %d of %d",progress.track+1,
 				progress.sector, progress.sectors);
 		last_sector = progress.sector;
+		if (progress.track >= 0 && progress.track < source_adr_count) {
+			int size, free_bytes, ret;
+			char *status_text;
+	
+			ret = burn_fifo_inquire_status(
+				fifo_src[progress.track], &size, &free_bytes,
+				&status_text);
+			if (ret >= 0 ) 
+				printf("  [fifo %s, %2d%% fill]", status_text,
+					(int) (100.0 - 100.0 *
+						((double) free_bytes) /
+						(double) size));
+		} 
+		printf("\n");
 		sleep(1);
 	}
 	printf("\n");
 
-	for (trackno = 0 ; trackno < source_adr_count; trackno++)
+	for (trackno = 0 ; trackno < source_adr_count; trackno++) {
+	  	burn_source_free(fifo_src[trackno]);
 		burn_track_free(tracklist[trackno]);
+	}
 	burn_session_free(session);
 	burn_disc_free(target_disc);
 	if (multi && current_profile != 0x1a && current_profile != 0x13 &&
@@ -620,7 +670,7 @@ int main(int argc, char **argv)
 	if (ret)
 		exit(ret);
 
-	printf("Initializing libburnia.pykix.org ...\n");
+	printf("Initializing libburnia-project.org ...\n");
 	if (burn_initialize())
 		printf("Done\n");
 	else {

test/open-cd-excl.c

@@ -0,0 +1,133 @@
+/*
+ * open-cd-excl.c --- This program tries to open a block device
+ * by various exclusive and non-exclusive gestures in order to explore
+ * their impact on running CD/DVD recordings.
+ *
+ * Copyright 2007, by Theodore Ts'o.
+ *
+ * Detail modifications 2007, by Thomas Schmitt.
+ * 
+ * %Begin-Header%
+ * This file may be redistributed under the terms of the GNU Public
+ * License.
+ * %End-Header%
+ */
+
+#define _GNU_SOURCE /* for O_LARGEFILE *//*ts A70417: or _LARGEFILE64_SOURCE */
+
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <fcntl.h>
+#include <getopt.h>
+
+const char *progname;
+
+static void usage(void)
+{
+	fprintf(stderr, "Usage: %s [-feirw] device\n", progname);
+	exit(1);
+}
+
+/* ts A70417: added parameter do_rdwr */
+static void init_flock(struct flock *fl, int do_rdwr)
+{
+	memset(fl, 0, sizeof(struct flock));
+	if (do_rdwr)
+		fl->l_type = F_WRLCK;
+	else
+		fl->l_type = F_RDLCK;
+	fl->l_whence = SEEK_SET;
+	fl->l_start = 0;
+	fl->l_len = 0;
+}
+
+int main(int argc, char **argv)
+{
+	struct flock	fl;
+	char	*device_name;
+	int	fd, c, f_opt = 0, do_rdwr = 0, end_immediately = 0;
+	int	flags = O_NONBLOCK|O_LARGEFILE;
+	
+	progname = argv[0];
+
+	/* ts A70417: added -w , -r , -i */
+	while ((c = getopt (argc, argv, "feirw")) != EOF) {
+		switch (c) {
+		case 'e':
+			flags |= O_EXCL;
+			break;
+		case 'f':
+			f_opt++;
+			break;
+		case 'i':
+			end_immediately = 1;
+			break;
+		case 'r':
+			do_rdwr = 0;
+			break;
+		case 'w':
+			do_rdwr = 1;
+			break;
+		case '?':
+			usage();
+			exit(1);
+		}
+	}
+
+	if (optind == argc)
+		usage();
+	device_name = argv[optind++];
+
+	/* ts A70417 : made read-write adjustable independently of f_opt */
+	if (do_rdwr) {
+		flags |= O_RDWR;
+		printf("Using O_RDWR\n");
+	} else {
+		flags |= O_RDONLY;
+		printf("Using O_RDONLY\n");
+	}
+
+	if (flags & O_EXCL)
+		printf("Trying to open %s with O_EXCL ...\n", device_name);
+	fd = open(device_name, flags, 0);
+	if (fd < 0) {
+		perror("open");
+		printf("failed\n");
+		exit(1);
+	}
+	if (flags & O_EXCL)
+		printf("succeeded\n");
+		
+	if (f_opt) {
+		init_flock(&fl, do_rdwr);
+		if (fcntl(fd, F_GETLK, &fl) < 0) {
+			perror("fcntl: F_GETLK: ");
+			exit(1);
+		}
+		printf("fcntl lock apparently %sLOCKED\n", 
+		       (fl.l_type == F_UNLCK) ? "NOT " : "");
+
+		init_flock(&fl, do_rdwr);
+		printf("Trying to grab fcntl lock...\n");
+		if (fcntl(fd, F_SETLK, &fl) < 0) {
+			perror("fcntl: F_SETLK: ");
+			printf("failed\n");
+			exit(1);
+		}
+		printf("succeeded\n");
+	}
+
+	/* ts A70417: added end_immediately */
+	printf("Holding %s open.\n", device_name);
+	usleep(100000);
+	if (end_immediately)
+		exit(0);
+	printf("Press ^C to exit.\n");
+	while (1) {
+		sleep(300);
+	} 
+	/* NOTREACHED */
+	return 0;
+}

test/telltoc.c

@@ -1,11 +1,12 @@
 
 /*  test/telltoc.c , API illustration of obtaining media status info */
-/*  Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net> Provided under GPL */
+/*  Copyright (C) 2006 - 2007 Thomas Schmitt <scdbackup@gmx.net> 
+    Provided under GPL version 2 */
 
 /**                               Overview 
   
   telltoc is a minimal demo application for the library libburn as provided
-  on  http://libburnia.pykix.org . It can list the available devices, can
+  on  http://libburnia-project.org . It can list the available devices, can
   display some drive properties, the type of media, eventual table of content
   and multisession info for mkisofs option -C . 
   It's main purpose, nevertheless, is to show you how to use libburn and also
@@ -24,6 +25,8 @@
      telltoc_media()   prints some information about the media in a drive
      telltoc_toc()     prints a table of content (if there is content)
      telltoc_msinfo()  prints parameters for mkisofs option -C
+     telltoc_read_and_print()  reads from data CD or from DVD and prints 7-bit 
+                       to stdout (encodings 0,2) or 8-bit to file (encoding 1)
   When everything is done, main() releases the drive and shuts down libburn:
      burn_drive_release();
      burn_finish()
@@ -72,6 +75,11 @@ int telltoc_aquire_by_adr(char *drive_adr);
 int telltoc_aquire_by_driveno(int *drive_no, int silent);
 
 
+/* A message from --toc to --read_and_print (CD tracksize is a bit tricky) */
+static int last_track_start = 0, last_track_size = -1;
+static int media_is_cd_profile = 0;
+
+
 /* ------------------------------- API gestures ---------------------------- */
 
 /** You need to aquire a drive before burning. The API offers this as one
@@ -100,22 +108,33 @@ int telltoc_aquire_drive(char *drive_adr, int *driveno, int silent_drive)
 /** If the persistent drive address is known, then this approach is much
     more un-obtrusive to the systemwide livestock of drives. Only the
     given drive device will be opened during this procedure.
+    Special drive addresses stdio:<path> direct output to a hard disk file
+    which will behave much like a DVD-RAM.
 */
 int telltoc_aquire_by_adr(char *drive_adr)
 {
 	int ret;
-	
 	char libburn_drive_adr[BURN_DRIVE_ADR_LEN];
 
+	/* <<< ts A70907 FOR TESTING ONLY !
+	struct burn_drive_info *test_drive_list;
+	*/
+
 	/* This tries to resolve links or alternative device files */
 	ret = burn_drive_convert_fs_adr(drive_adr, libburn_drive_adr);	
 	if (ret<=0) {
-		fprintf(stderr,"Address does not lead to a CD burner: '%s'\n",
+		fprintf(stderr, "Address does not lead to a CD burner: '%s'\n",
 			drive_adr);
-		return ret;
+		return 0;
 	}
-	fprintf(stderr,"Aquiring drive '%s' ...\n",libburn_drive_adr);
-	ret = burn_drive_scan_and_grab(&drive_list,libburn_drive_adr,1);
+
+	/* <<< ts A70907 FOR TESTING ONLY ! 
+	ret = burn_drive_scan_and_grab(&test_drive_list, "/dev/sg2", 1);
+	*/
+
+	fprintf(stderr,"Aquiring drive '%s' ...\n", libburn_drive_adr);
+	ret = burn_drive_scan_and_grab(&drive_list, libburn_drive_adr, 1);
+
 	if (ret <= 0) {
 		fprintf(stderr,"FAILURE with persistent drive address  '%s'\n",
 			libburn_drive_adr);
@@ -123,6 +142,11 @@ int telltoc_aquire_by_adr(char *drive_adr)
 		fprintf(stderr,"Done\n");
 		drive_is_grabbed = 1;
 	}
+
+	/* <<< ts A70907 FOR TESTING ONLY !
+	burn_drive_info_free(test_drive_list);
+	*/
+
 	return ret;
 }
 
@@ -147,7 +171,7 @@ int telltoc_aquire_by_driveno(int *driveno, int silent_drive)
 
 	fprintf(stderr, "Beginning to scan for devices ...\n");
 	while (!burn_drive_scan(&drive_list, &drive_count))
-		usleep(1002);
+		usleep(100002);
 	if (drive_count <= 0 && *driveno >= 0) {
 		fprintf(stderr, "FAILED (no drives found)\n");
 		return 0;
@@ -234,7 +258,7 @@ int telltoc_media(struct burn_drive *drive)
 
 	printf("Media current: ");
 	ret = burn_disc_get_profile(drive, &profile_no, profile_name);
-	if (profile_no > 0 && ret >0) {
+	if (profile_no > 0 && ret > 0) {
 		if (profile_name[0])
 			printf("%s\n", profile_name);
 		else
@@ -312,6 +336,11 @@ int telltoc_media(struct burn_drive *drive)
 				caps->advised_write_mode == BURN_WRITE_RAW ?
 				" (advised)" : "");
 		printf("\n");
+		printf("Write dummy  : ");
+		if (caps->might_simulate)
+			printf("supposed to work with non-RAW modes\n");
+		else
+			printf("will not work\n");
 		o= burn_write_opts_new(drive);
 		if (o != NULL) {
 			burn_write_opts_set_perform_opc(o, 0);
@@ -438,8 +467,9 @@ int telltoc_formatlist(struct burn_drive *drive)
 int telltoc_toc(struct burn_drive *drive)
 {
 	int num_sessions = 0 , num_tracks = 0 , lba = 0, pmin, psec, pframe;
-	int track_count = 0;
+	int track_count = 0, pno;
 	int session_no, track_no;
+	char profile_name[80];
 	struct burn_disc *disc= NULL;
 	struct burn_session **sessions;
 	struct burn_track **tracks;
@@ -474,6 +504,7 @@ int telltoc_toc(struct burn_drive *drive)
 				track_count,
 				((toc_entry.control&7)<4?"audio":"data "),
 				lba, pmin, psec, pframe);
+			last_track_start = lba;
 		}
 		burn_session_get_leadout_entry(sessions[session_no],
 						&toc_entry);
@@ -489,6 +520,11 @@ int telltoc_toc(struct burn_drive *drive)
 		printf("Media content: session %2d  ", session_no+1);
 		printf("leadout            lba: %9d  %4.2d:%2.2d:%2.2d\n",
 			lba, pmin, psec, pframe);
+		last_track_size = lba - last_track_start;
+		if (burn_disc_get_profile(drive, &pno, profile_name) > 0)
+			if (pno == 0x09 || pno == 0x0a)
+				media_is_cd_profile = 1;
+			
 	}
 	if (disc!=NULL)
 		burn_disc_free(disc);
@@ -553,6 +589,125 @@ ex:;
 }
 
 
+/**
+  @param encoding determins how to format output on stdout:
+                  0 = default , 1 = raw 8 bit (dangerous for tty) , 2 = hex
+*/
+int telltoc_read_and_print(struct burn_drive *drive, 
+	int start_sector, int sector_count, char *raw_file, int encoding)
+{
+	int j, i, request = 16, done, lbas = 0, final_cd_try = -1, todo;
+	int ret = 0;
+	char buf[16 * 2048], line[81];
+	off_t data_count, total_count= 0, last_reported_count= 0;
+	struct stat stbuf;
+	FILE *raw_fp = NULL;
+
+	if (start_sector == -1)
+		start_sector = last_track_start;
+	if (sector_count == -1) {
+		sector_count = last_track_start + last_track_size
+				- start_sector;
+		if (media_is_cd_profile)  /* In case it is a TAO track */
+			final_cd_try = 0; /* allow it (-1 is denial) */
+	}
+	if (start_sector < 0)
+		start_sector = 0;
+	if (sector_count <= 0)
+		sector_count = 2147483632;
+
+	if (sector_count <= 0)
+		return -1;
+	if (encoding == 1) {
+                if (stat(raw_file,&stbuf) != -1) {
+			if (!(S_ISCHR(stbuf.st_mode) || S_ISFIFO(stbuf.st_mode)
+				 || (stbuf.st_mode & S_IFMT) == S_IFSOCK )) {
+                   	 	fprintf(stderr,
+				  "SORRY: target file '%s' already existing\n",
+				  raw_file);
+				return 1;
+			}
+                }
+                raw_fp = fopen(raw_file,"w");
+                if (raw_fp == NULL) {
+                    fprintf(stderr,"SORRY: cannot open target file '%s' (%s)\n", raw_file, strerror(errno));
+                    return 1;
+                }
+		printf(
+	"Data         : start=%ds , count=%ds , read=0s , encoding=%d:'%s'\n",
+		start_sector, sector_count, encoding, raw_file);
+	} else 
+		printf(
+		"Data         : start=%ds , count=%ds , read=0 , encoding=%d\n",
+		start_sector, sector_count, encoding);
+	todo = sector_count - 2*(final_cd_try > -1);
+	for (done = 0; done < todo && final_cd_try != 1; done += request) {
+		if (todo - done > 16)
+			request = 16;
+		else
+			request = todo - done;
+		ret = burn_read_data(drive,
+			((off_t) start_sector + done) * (off_t) 2048,
+			buf, (off_t) (request * 2048), &data_count, 1);
+			
+print_result:;
+		total_count += data_count;
+		if (encoding == 1) {
+			if (data_count > 0)
+				fwrite(buf, data_count, 1, raw_fp);
+		} else for (i = 0; i < data_count; i += 16) {
+			if (encoding == 0) {
+				sprintf(line, "%8ds + %4d : ",
+					start_sector + done + i / 2048,
+					i % 2048);
+				lbas = strlen(line);
+			}
+			for (j = 0; j < 16 && i + j < data_count; j++) {
+				if (buf[i + j] >= ' ' && buf[i + j] <= 126 &&
+					encoding != 2)
+					sprintf(line + lbas + 3 * j, " %c ",
+					 	(int) buf[i + j]);
+				else
+					sprintf(line + lbas + 3 * j, "%2.2X ",
+					 	(unsigned char) buf[i + j]);
+			}
+			line[lbas + 3 * (j - 1) + 2] = 0;
+			printf("%s\n",line);
+		}
+		if (encoding == 1 &&
+		    total_count - last_reported_count >= 1000 * 2048) {
+			fprintf(stderr, 
+	     		 "\rReading data : start=%ds , count=%ds , read=%ds  ",
+			 start_sector, sector_count,
+			  (int) (total_count / (off_t) 2048));
+			last_reported_count = total_count;
+		}
+		if (ret <= 0) {
+			fprintf(stderr, "SORRY : Reading failed.\n");
+	break;
+		}
+	}
+	if (ret > 0 && media_is_cd_profile && final_cd_try == 0) {
+		/* In a SAO track the last 2 frames should be data too */
+		final_cd_try = 1;
+		burn_read_data(drive,
+			((off_t) start_sector + todo) * (off_t) 2048,
+			buf, (off_t) (2 * 2048), &data_count, 2);
+		if (data_count < 2 * 2048)
+			fprintf(stderr, "\rNOTE : Last two frames of CD track unreadable. This is normal if TAO track.\n");
+		if (data_count > 0)
+			goto print_result;	
+	}
+	if (last_reported_count > 0)
+		fprintf(stderr,
+"\r                                                                       \r");
+	printf("End Of Data  : start=%ds , count=%ds , read=%ds\n",
+		start_sector, sector_count,(int) (total_count / (off_t) 2048));
+
+	return ret;
+}
+
+
 /** The setup parameters of telltoc */
 static char drive_adr[BURN_DRIVE_ADR_LEN] = {""};
 static int driveno = 0;
@@ -561,6 +716,8 @@ static int do_toc = 0;
 static int do_msinfo = 0;
 static int print_help = 0;
 static int do_capacities = 0;
+static int read_start = -2, read_count = -2, print_encoding = 0;
+static char print_raw_file[4096] = {""};
 
 
 /** Converts command line arguments into above setup parameters.
@@ -603,6 +760,26 @@ int telltoc_setup(int argc, char **argv)
         } else if (!strcmp(argv[i], "--toc")) {
 	    do_toc = 1;
 
+        } else if (!strcmp(argv[i], "--read_and_print")) {
+            i+= 3;
+            if (i >= argc) {
+                fprintf(stderr,"--read_and_print requires three arguments: start count encoding(try 0, not 1)\n");
+                return 1;
+            }
+            sscanf(argv[i-2], "%d", &read_start);
+            sscanf(argv[i-1], "%d", &read_count);
+            print_encoding = 0;
+            if(strncmp(argv[i], "raw:", 4) == 0 || strcmp(argv[i],"1:") == 0) {
+                print_encoding = 1;
+                strcpy(print_raw_file, strchr(argv[i], ':') + 1);
+		if (strcmp(print_raw_file, "-") == 0) {
+                	fprintf(stderr,
+		"--read_and_print does not write to \"-\" as stdout.\n");
+                	return 1;
+		}
+            } else if(strcmp(argv[i], "hex") == 0 || strcmp(argv[i], "2") == 0)
+               print_encoding = 2;
+            
         } else if (!strcmp(argv[i], "--help")) {
             print_help = 1;
 
@@ -617,6 +794,7 @@ int telltoc_setup(int argc, char **argv)
         printf("Usage: %s\n", argv[0]);
         printf("       [--drive <address>|<driveno>|\"-\"]\n");
         printf("       [--media]  [--capacities]  [--toc]  [--msinfo]\n");
+        printf("       [--read_and_print <start> <count> \"0\"|\"hex\"|\"raw\":<path>]\n");
         printf("Examples\n");
         printf("A bus scan (needs rw-permissions to see a drive):\n");
         printf("  %s --drive -\n",argv[0]);
@@ -630,6 +808,12 @@ int telltoc_setup(int argc, char **argv)
         printf("  mkisofs ... -C \"$msinfo\" ...\n");
 	printf("Obtain what is available about drive 0 and its media\n");
 	printf("  %s --drive 0\n",argv[0]);
+	printf("View blocks 16 to 19 of data CD or DVD in human readable form\n");
+	printf("  %s --drive /dev/sr1 --read_and_print 16 4 0 | less\n",
+		argv[0]);
+        printf("Copy last data track from CD to file /tmp/data\n");
+        printf("  %s --drive /dev/sr1 --toc --read_and_print -1 -1 raw:/tmp/data\n",
+                argv[0]);
     }
     return 0;
 }
@@ -651,14 +835,14 @@ int main(int argc, char **argv)
 			msinfo_alone = 1;
 	}
 	/* Default option is to do everything if possible */
-    	if (do_media==0 && do_msinfo==0 && do_capacities==0 && do_toc==0 
-	    && driveno!=-1) {
+    	if (do_media==0 && do_msinfo==0 && do_capacities==0 && do_toc==0 &&
+		(read_start < 0 || read_count <= 0) && driveno!=-1) {
 		if(print_help)
 			exit(0);
-		full_default = do_media = do_msinfo = do_capacities= do_toc = 1;
+		full_default = do_media = do_msinfo = do_capacities= do_toc= 1;
 	}
 
-	fprintf(stderr, "Initializing libburnia.pykix.org ...\n");
+	fprintf(stderr, "Initializing libburnia-project.org ...\n");
 	if (burn_initialize())
 		fprintf(stderr, "Done\n");
 	else {
@@ -666,8 +850,11 @@ int main(int argc, char **argv)
 		exit(33);
 	}
 
-	/* Print messages of severity SORRY or more directly to stderr */
-	burn_msgs_set_severities("NEVER", "SORRY", "telltoc : ");
+	/* Print messages of severity WARNING or more directly to stderr */
+	burn_msgs_set_severities("NEVER", "WARNING", "telltoc : ");
+
+	/* Activate the default signal handler */
+	burn_set_signal_handling("telltoc : ", NULL, 0);
 
 	/** Note: driveno might change its value in this call */
 	ret = telltoc_aquire_drive(drive_adr, &driveno, !full_default);
@@ -704,6 +891,13 @@ int main(int argc, char **argv)
 		if (ret<=0)
 			{ret = 38; goto release_drive; }
 	}
+	if (read_start >= -1 && (read_count > 0 || read_count == -1)) {
+		ret = telltoc_read_and_print(drive_list[driveno].drive,
+				read_start, read_count, print_raw_file,
+				print_encoding);
+		if (ret<=0)
+			{ret = 40; goto release_drive; }
+	}
 
 	ret = 0;
 	if (toc_failed)