Documented changes and release timestamp

COPYRIGHT

@@ -1,7 +1,7 @@
 Derek Foreman <derek@signalmarketing.com> and Ben Jansens <xor@orodu.net>
 Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
 Mario Danic <mario.danic@gmail.com>, Thomas Schmitt <scdbackup@gmx.net>
-Copyright (C) 2006-2011 Mario Danic, Thomas Schmitt
+Copyright (C) 2006-2010 Mario Danic, Thomas Schmitt
 
 
     This program is free software; you can redistribute it and/or modify

ChangeLog

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

Makefile.am

@@ -6,7 +6,6 @@ pkgconfigdir=$(LIBBURNIA_PKGCONFDIR)
 libincludedir=$(includedir)/libburn
 
 lib_LTLIBRARIES = libburn/libburn.la 
-ACLOCAL_AMFLAGS = -I ./
 
 ## ========================================================================= ##
 
@@ -76,15 +75,11 @@ libburn_libburn_la_SOURCES = \
 libinclude_HEADERS = \
 	libburn/libburn.h 
 
-install-exec-hook:
-	$(LIBBURNIA_LDCONFIG_CMD) "$(DESTDIR)$(libdir)" || echo 'NOTE: Explicite dynamic library configuration failed. If needed, configure manually for:' "$(DESTDIR)$(libdir)"
-
 ## ========================================================================= ##
 
 ## Build test applications
 noinst_PROGRAMS = \
 	test/libburner \
-	test/offst_source \
 	test/telltoc \
 	test/dewav \
 	test/fake_au \
@@ -99,9 +94,6 @@ LIBBURN_EXTRALIBS = $(LIBBURN_ARCH_LIBS) $(THREAD_LIBS)
 test_libburner_CPPFLAGS = -Ilibburn
 test_libburner_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 test_libburner_SOURCES = test/libburner.c
-test_offst_source_CPPFLAGS = -Ilibburn
-test_offst_source_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
-test_offst_source_SOURCES = test/offst_source.c
 test_telltoc_CPPFLAGS = -Ilibburn
 test_telltoc_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 test_telltoc_SOURCES = test/telltoc.c
@@ -118,9 +110,9 @@ test_structest_CPPFLAGS = -Ilibburn
 test_structest_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 test_structest_SOURCES = test/structest.c
 
-##  cdrskin construction site - ts A60816 - B10808
+##  cdrskin construction site - ts A60816 - B00122
 cdrskin_cdrskin_CPPFLAGS = -Ilibburn
-cdrskin_cdrskin_CFLAGS = -DCdrskin_libburn_1_1_6
+cdrskin_cdrskin_CFLAGS = -DCdrskin_libburn_0_7_6
 
 # cdrskin_cdrskin_LDADD = $(libburn_libburn_la_OBJECTS) $(LIBBURN_EXTRALIBS)
 # ts A80123, change proposed by Simon Huggins to cause dynamic libburn linking
@@ -151,10 +143,7 @@ doc/html: doc/doxygen.conf
 doc-upload: doc/html
 	scp -r $</* $(webhost):$(webpath)
 
-## ts B00729
-## Not by default any more.
-## It is unclear who is supposed to create file ./doc/doc.lock
-# all: doc
+all: doc
 
 install-data-local: 
 	if [ -f ./doc/doc.lock ]; then \
@@ -197,8 +186,6 @@ EXTRA_DIST = \
 	version.h.in \
 	doc/comments \
 	doc/doxygen.conf.in \
-	doc/cookbook.txt \
-	doc/mediainfo.txt \
 	README \
 	AUTHORS \
 	CONTRIBUTORS \
@@ -212,17 +199,14 @@ EXTRA_DIST = \
 	cdrskin/wiki_plain.txt \
 	cdrskin/cleanup.h \
 	cdrskin/cleanup.c \
-	libburn/libburn.ver \
 	libburn/os-dummy.h \
 	libburn/os-freebsd.h \
 	libburn/os-linux.h \
 	libburn/os-libcdio.h \
-	libburn/os-solaris.h \
 	libburn/sg-dummy.c \
 	libburn/sg-freebsd.c \
 	libburn/sg-linux.c \
 	libburn/sg-libcdio.c \
-	libburn/sg-solaris.c \
 	COPYING \
 	NEWS \
 	ChangeLog \

README

@@ -6,12 +6,12 @@ This all is under GPL.
 ------------------------------------------------------------------------------
 libburn-project.org
 By Mario Danic <mario.danic@gmail.com> and Thomas Schmitt <scdbackup@gmx.net>
-Copyright (C) 2006-2011 Mario Danic, Thomas Schmitt
+Copyright (C) 2006-2010 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
 
-     http://files.libburnia-project.org/releases/libburn-1.1.6.tar.gz
+     http://files.libburnia-project.org/releases/libburn-0.7.6.pl00.tar.gz
 
 ------------------------------------------------------------------------------
 
@@ -19,10 +19,10 @@ Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
 
                                 From tarball
 
-Obtain libburn-1.1.6.tar.gz, take it to a directory of your choice and do:
+Obtain libburn-0.7.6.pl00.tar.gz, take it to a directory of your choice and do:
 
-   tar xzf libburn-1.1.6.tar.gz
-   cd libburn-1.1.6
+   tar xzf libburn-0.7.6.pl00.tar.gz
+   cd libburn-0.7.6
    ./configure --prefix=/usr
    make
 
@@ -60,11 +60,6 @@ Warning: The trunk might contain experimental features which might not
 
                         Special ./configure options
 
-make install on GNU/Linux will try to run program ldconfig with the library
-installation directory as only argument. Failure to do so will not abort
-installation. One may disable ldconfig by ./configure option:
-   --disable-ldconfig-at-install
-
 In some situations Linux may deliver a better write performance to drives if
 the track input is read with O_DIRECT (see man 2 open). The API call
 burn_os_open_track_src() and the input readers of cdrskin and libburn fifo
@@ -81,32 +76,11 @@ Alternatively the transport of SCSI commands can be done via libcdio-0.83.
 You may install it and re-run libburn's ./configure with option
     --enable-libcdio
 
-By use of a version script, the libburn.so library exposes no other function
-names but those of the API definition in libburn/libburn.h.
-If -Wl,--version-script=... makes problems with the local compiler, then
-disable this encapsulation feature by
-    --disable-versioned-libs
-
 Make sure to re-compile all source files after running ./configure
    make clean ; make
    make install
 
 
-Linux only:
-
-libburn tries to avoid a collision with udev's drive examination by waiting
-0.1 seconds before opening the device file for a longer time, after udev
-might have been alarmed by drive scanning activities.
-The waiting time can be set at ./configure time with microsecond granularity.
-E.g. 2 seconds:
-  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=2000000"
-  ./configure ...options...
-Waiting can be disabled by zero waiting time:
-  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=0"
-Alternatively, libburn can try to be nice by opening the device file,
-closing it immediately, waiting, and only then opening it for real:
-  CFLAGS="$CFLAGS -DLibburn_udev_extra_open_cyclE -DLibburn_udev_wait_useC=500000"
-
 ------------------------------------------------------------------------------
 
 An important part of the project, libisofs, is hosted in a bzr repository at
@@ -125,15 +99,14 @@ See README files there.
 
 libburnia-project.org is an open-source software project for reading, mastering
 and writing optical discs.
-For now this means CD media, all DVD media, all BD media.
+For now this means CD media, all DVD media except DVD-R DL, all BD media.
 
 The project comprises of several more or less interdependent parts which
 together strive to be a usable foundation for application development.
 These are libraries, language bindings, and middleware binaries which emulate
 classical (and valuable) Linux tools.
-Currently it is supported on GNU/Linux with kernels >= 2.4,
-on FreeBSD with ATAPI/CAM enabled in the kernel (see man atapicam),
-and on OpenSolaris (tested with kernel 5.11).
+Currently it is supported on Linux with kernels >= 2.4 and on FreeBSD versions 
+with ATAPI/CAM support enabled in the kernel, see atapicam(4).
 On other X/Open compliant systems there will only be pseudo drives, but no
 direct MMC operation on real CD/DVD/BD drives.
 
@@ -165,15 +138,12 @@ The project components (list subject to growth, hopefully):
 
 - libisofs is the library to pack up hard disk files and directories into a
            ISO 9660 disk image. This may then be brought to CD via libburn.
-           An own ISO 9660 extension stores ACLs, xattr, and MD5 of file
-           content.
+           libisofs is to be the foundation of our upcoming mkisofs emulation.
 
 - libisoburn is an add-on to libburn and libisofs which coordinates both and
            also allows to grow ISO-9660 filesystem images on multi-session
            media as well as on overwriteable media via the same API.
            All media peculiarities are handled automatically.
-           It also contains the methods of command oriented application
-           xorriso and offers them via a C language API.
 
 - cdrskin  is a limited cdrecord compatibility wrapper for libburn.
            cdrecord is a powerful GPL'ed burn program included in Joerg
@@ -191,12 +161,9 @@ The project components (list subject to growth, hopefully):
            Rock Ridge extensions. Manipulation is not only adding or
            overwriting of files but also deleting, renaming, attribute
            changing, incremental backups, activating boot images, and
-           extracting of files from ISO images to disk. There is also a
-           sparse emulation of cdrecord and a more laborate one of mkisofs.
-           All features of xorriso are also available via a C language API
-           of libisoburn.
-           A static compilation of xorriso and the libraries is dedicated
-           to the GNU Operating System. See xorriso/README_gnu_xorriso .
+           extracting of files from ISO images to disk. An own ISO 9660
+           extension stores ACLs, xattr, and MD5 of file content.
+           See xorriso/README for more.
 
 - "test"   is a collection of application gestures and examples given by the
            authors of the library features. The burn API example of libburn
@@ -529,139 +496,6 @@ Project history as far as known to me:
   fixes bugs about the generic X/Open system adapter, and allows to use
   libcdio >= 0.83 as SCSI transport facility.
 
-- 10 Feb 2010 libisofs-0.6.28 fixes a regression about bootable images which
-  was introduced by version 0.6.22 in August 2009.
-
-- 23 Feb 2010 libisoburn-0.5.0 marks the transition of the xorriso standalone
-  version to an official GNU project. The name changed to "GNU xorriso" and its
-  license is now GPLv3+.
-  The licenses of libburnia libraries and applications are not affected by
-  this change. 
-
-- 10 Mar 2010 libburn-0.7.8 fixes bugs and improves the built-in abort handler
-  on FreeBSD.
-
-- 30 Mar 2010 Release 0.5.2 of libisoburn provides xorriso documentation in
-  GNU Texinfo format with embedded extra data to derive a full man page.
-
-- 09 Apr 2010 libburn-0.8.0 now works with ahci driver on FreeBSD 8-STABLE.
-
-- 03 May 2010 Version 0.6.32 of libisofs is able to create ISO images with
-  multiple boot images. All boot catalog parameters described in El-Torito
-  specs can be set and inquired. This allows to use GRUB boot images for EFI. 
-
-- 04 May 2010 Release 0.5.6.pl00 of libisoburn makes use of the new libisofs
-  capabilities about boot images.
-
-- 11 Jun 2010 libburn-0.8.2 now works on Solaris. 
-
-- 14 Jun 2010 By release 0.5.8.pl00 of libisoburn, xorriso becomes a public C
-  language API of libisoburn. The emulations of mkisofs and cdrecord have
-  been enhanced. 
-
-- Tue Jun 29 2010 Version 0.6.34 of libisofs provides new features about
-  hiding file names from directory trees.
-
-- Wed Jun 30 2010 libburn-0.8.4 removes some restrictions on operating
-  systems other than Linux and FreeBSD.
-
-- Fri Jul 02 2010 Release 0.6.0.pl00 of libisoburn adds more options to the
-  mkisofs emulation of xorriso. It also fixes minor bugs and shortcommings.
-
-- Wed Sep 15 2010 Version 0.6.36 of libisofs can produce ISO images which
-  bear a partiton 1 with non-zero start address. They can be mounted from
-  USB stick via the main device file (e.g. /dev/sdb) as well as via the
-  partition device file (e.g. /dev/sdb1).
-
-- Fri Sep 17 2010 libburn-0.8.6 lifts the test reservation on DVD-R DL media.
-
-- Sat Sep 18 2010 Release 0.6.2.pl00 of libisoburn introduces a partition
-  with non-zero offset for ISO 9660 images on USB sticks, improves mkisofs
-  emulation, and fixes a regression which existed since version 0.4.2.
-
-- Wed Oct 20 2010 libburn-0.8.8 can report the used amount of BD spare blocks.
-
-- Sat Oct 23 2010 Version 0.6.38 of libisofs can use libjte to produce jigdo
-  files along with the ISO image. Further filesystem images may be appended
-  as MBR partitions 1 to 4. The capability was added to produce boot blocks
-  for computers with MIPS CPU.
-
-- Tue Oct 26 2010 Release 0.6.4.pl00 of libisoburn and xorriso makes use of
-  the new libisofs capabilities.
-
-- Wed Dec 08 2010 libburn-0.9.0 fixes a regression with SCSI command logging.
-
-- Fri Dec 10 2010 Version 0.6.40 of libisofs makes the prediction of the
-  emerging image size less expensive and is able to make images bootable
-  for SUN SPARC systems.
-
-- Sun Dec 12 2010 Release 0.6.6.pl00 of libisoburn and xorriso can read ISO
-  images which were copied to a different start address than they were prepared
-  for.
-
-- Mon Jan 17 2011 we go for release 1.0.0. This does not indicate a
-  technological overhaul but shall emphasize the maturity of the software.
-  libisofs-1.0.0 fixes a bug about the length of ECMA-119 directory names and
-  is ready to allow untranslated ECMA-119 names (violating the specs).
-  libburn-1.0.0.pl00 allows umask to create stdio-drive files with
-  rw-permissions for all. cdrskin now refuses to burn if the foreseeable size
-  exceeds media capacity
-  libisoburn-1.0.0.pl00 allows to create an ISO 9660:1999 directory tree,
-  improved the emulation fidelity of command -as mkisofs, lowered the default
-  abort threshold for xorriso batch mode, and increased that threshold for
-  xorriso dialog mode.
-
-- Wed Feb 23 2011 release 1.0.2:
-  libisofs fixes several bugs and introduces the capability to copy files
-  inside the ISO filesystem.
-  libburn removed a compilation obstacle on Solaris 9 and improved recognition
-  of stdio pseudo-drives.
-  libisoburn and xorriso fix bugs and make use of the new libisofs capability.
-  xorriso improves its mkisofs emulation.
-
-- Thu Mar 10 2011 release 1.0.4:
-  Several bugs were fixed in the libraries and in the mkisofs emulation of
-  xorriso. This emulation xorrisofs has now an own man page and info document.
-
-- Sat Apr 09 2011 release 1.0.6:
-  libburn refined its representation of emulated drives. The size alignment
-  of DVD DAO is now 2 kB rather than 32 kB. libisofs produces Joliet names of
-  up to 103 characters. xorriso fixes two bugs and makes use of the library
-  improvements.
-
-- Thu Apr 14 2011 release libisoburn-1.0.8:
-  A bug in the mkisofs emulation of xorriso could cause options to be ignored.
-  The problem was freshly introduced with libisoburn-1.0.6. 
-
-- Fri May 13 2011 release libisofs-1.0.8:
-  Fixes a few rarely occurring bugs that have been found during the last month.
-
-- Sat Jun 18 2011 release 1.1.0:
-  The consumption of stack memory was reduced. Statical program analysis found
-  some rarely occuring memory leaks. Several small bugs were fixed.
-  The suffix .plXY was dropped from tarball names of libburn and libisoburn.
-
-- Mon Jun 20 2011 patch release libburn-1.1.0.pl01:
-  libburn-1.1.0 compiled only on Linux, FreeBSD, and Solaris, but not on
-  other X/Open compliant systems.
-
-- Fri Jul 08 2011 release libisofs-1.1.2 and libisoburn-1.1.2:
-  A severe regression was fixed in libisoburn and xorriso, which was introduced
-  with version 1.0.6. It caused ISO 9660 images to be unreadable if they were
-  written to a write-only random-access file. E.g. by: xorrisofs ... >image.iso
-  
-- Mon Aug 08 2011 release 1.1.4:
-  Several bugs were fixed in libburn. The most severe of them prevented xorriso
-  on some drives from burning mountable ISO 9660 images to CD media.
-  New means to list drives by their udev symbolic links help to deal with
-  the non-persistent drive addresses on modern GNU/Linux.
-
-- Tue Sep 27 2011 release 1.1.6:
-  libisoburn now comes with a test suite. See releng/README. Bugs were fixed
-  in several rarely used features. Processing of ACL and extattr was enabled
-  on FreeBSD. Workarounds try to cope with vanishing udev links on GNU/Linux.
-
-
 ------------------------------------------------------------------------------
 
     This program is free software; you can redistribute it and/or modify

acinclude.m4

@@ -1,14 +1,3 @@
-AC_DEFUN([LIBBURNIA_SET_FLAGS],
-[
-case $target_os in
-freebsd*)
-        LDFLAGS="$LDFLAGS -L/usr/local/lib"
-        CPPFLAGS="$CPPFLAGS -I/usr/local/include"
-        ;;
-esac
-])
-
-
 AC_DEFUN([TARGET_SHIZZLE],
 [
   ARCH=""
@@ -16,13 +5,11 @@ AC_DEFUN([TARGET_SHIZZLE],
 
   AC_MSG_CHECKING([target operating system])
 
-  LIBBURNIA_LDCONFIG_CMD="echo 'No ldconfig run performed. If needed, configure manually for:'"
   
   case $target_os in
     linux*)
       ARCH=linux
       LIBBURN_ARCH_LIBS=
-      LIBBURNIA_LDCONFIG_CMD=ldconfig
       ;;
     freebsd*)
       ARCH=freebsd
@@ -44,21 +31,6 @@ AC_DEFUN([TARGET_SHIZZLE],
 ])
 
 
-dnl LIBBURN_ASSERT_VERS_LIBS is by Thomas Schmitt, libburnia project
-dnl It tests whether -Wl,--version-script=... works with the compiler
-AC_DEFUN([LIBBURN_ASSERT_VERS_LIBS],
-[
-    libburnia_save_LDFLAGS="$LDFLAGS"
-    LDFLAGS="$LDFLAGS -Wl,--version-script=libburn/libburn.ver"
-    AC_TRY_LINK([#include <stdio.h>], [printf("Hello\n");],
-                [vers_libs_test="yes"], [vers_libs_test="no"])
-    if test x$vers_libs_test = xno
-    then
-        LDFLAGS="$libburnia_save_LDFLAGS"
-    fi
-])
-  
-
 dnl LIBBURNIA_SET_PKGCONFIG determines the install directory for the *.pc file.
 dnl Important: Must be performed _after_ TARGET_SHIZZLE
 dnl 

bootstrap

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

cdrskin/README

@@ -4,17 +4,16 @@
 cdrskin. By Thomas Schmitt <scdbackup@gmx.net>
 Integrated sub project of libburnia-project.org but also published via:
 http://scdbackup.sourceforge.net/cdrskin_eng.html
-http://scdbackup.sourceforge.net/cdrskin-1.1.6.tar.gz
+http://scdbackup.sourceforge.net/cdrskin-0.7.6.pl00.tar.gz
 
-Copyright (C) 2006-2011 Thomas Schmitt, provided under GPL version 2 or later.
+Copyright (C) 2006-2010 Thomas Schmitt, provided under GPL version 2 or later.
 ------------------------------------------------------------------------------
 
 
 cdrskin is a limited cdrecord compatibility wrapper which allows to use
 most of the libburn features from the command line.
 
-Currently it is supported on GNU/Linux with kernels >= 2.4,
-on FreeBSD and on OpenSolaris.
+Currently it is supported on Linux with kernels >= 2.4 and on FreeBSD.
 IDE drives under Linux 2.4. need kernel module ide-scsi.
 ATA and SATA drives under FreeBSD need kernel module atapicam.
 On other X/Open compliant systems there will only be emulated drives, but no
@@ -26,10 +25,10 @@ By using this software you agree to the disclaimer at the end of this text
 
                    Compilation, First Glimpse, Installation
 
-Obtain cdrskin-1.1.6.tar.gz, take it to a directory of your choice and do:
+Obtain cdrskin-0.7.6.pl00.tar.gz, take it to a directory of your choice and do:
 
-    tar xzf cdrskin-1.1.6.tar.gz
-    cd cdrskin-1.1.6
+    tar xzf cdrskin-0.7.6.pl00.tar.gz
+    cd cdrskin-0.7.6
 
 Within that directory execute:
 
@@ -104,25 +103,17 @@ The output of  cdrskin --devices  might look like
     0  dev='/dev/sr0'  rwrwr- :  '_NEC'  'DVD_RW ND-4570A'
     1  dev='/dev/sr1'  rwrw-- :  'HL-DT-ST'  'DVDRAM GSA-4082B'
 
-On Linux, full and insecure enabling of both for everybody would look like
-    chmod a+rw /dev/sr0 /dev/hda
-This is equivalent to the traditional setup chmod a+x,u+s cdrecord.
+So full and insecure enabling of both for everybody would look like
 
-On FreeBSD, device permissions are to be set in /etc/devfs.rules.
-On Solaris, pfexec privileges may be restricted to "basic,sys_devices".
-See below "System Dependend Drive Permission Examples".
+    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.
-Better consider to grant the necessary permissions to group "floppy"
-and to add users to it.
-
-
-A behavioral conflict is known between any burn software and demons like hald
-which probe CD drives. This can spoil burn runs for CD-R or CD-RW.
-You may have to keep your hald away from the drive. See for example
-   http://www.freebsd.org/gnome/docs/halfaq.html
 
+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
@@ -131,6 +122,11 @@ 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.
 
+A behavioral conflict is known between any burn software and demons like hald
+which probe CD drives. This can spoil burn runs for CD-R or CD-RW.
+You may have to keep your hald away from the drive. See for example
+   http://www.freebsd.org/gnome/docs/halfaq.html
+
 
                                 Usage examples 
 
@@ -150,7 +146,7 @@ Obtain some info about the drive
     cdrskin dev=0,1,0 -checkdrive 
 
 Obtain some info about the drive and the inserted media
-    cdrskin dev=0,1,0 -atip -v -minfo
+    cdrskin dev=0,1,0 -atip -v
 
 Prepare CD-RW or DVD-RW for re-use, DVD-RAM or BD-RE for first use
     cdrskin -v dev=/dev/sg1 blank=as_needed -eject
@@ -310,11 +306,10 @@ Add-on session (equivalent to growisofs -M):
     cdrskin dev=/dev/sr0 --grow_overwriteable_iso ... -
 
 
-                            DVD-RW , DVD-R , DVD-R DL
+                               DVD-RW and DVD-R
 
 DVD-RW are usable if formatted to state "Restricted Overwrite" or if in state
-"Sequential Recording". DVD-R are always in sequential state. DVD-R DL are
-always sequential and incapable of multi-session.
+"Sequential Recording". DVD-R are always in sequential state.
 
 "Sequential" is the state of unused media and of media previously blanked
 or written by cdrecord. dvd+rw-format -blank can also achieve this state.
@@ -404,14 +399,13 @@ drive. See man page section FILES for a way to lift that ban.
                         Special compilation variations
 
 All following options of ./configure and cdrskin/compile_cdrskin.sh are
-combinable. After runs of ./configure do as next:
-    make clean ; make
+combinable.
 
 In some situations Linux may deliver a better write performance to drives if
 the track input is read with O_DIRECT (see man 2 open). The API call
 burn_os_open_track_src() and the input readers of cdrskin and libburn fifo
 can be told to use this peculiar read mode by:
-    --enable-track-src-odirect
+   --enable-track-src-odirect
 
 But often cdrskin option dvd_obs=64k will yield even better performance in
 such a situation. 64k can be made default at compile time by 
@@ -439,100 +433,6 @@ will not have a fifo buffer, and will not be able to put out help texts or
 debugging messages.
 
 
-Linux only:
-
-libburn tries to avoid a collision with udev's drive examination by waiting
-0.1 seconds before opening the device file for a longer time, after udev
-might have been alarmed by drive scanning activities.
-The waiting time can be set at ./configure time with microsecond granularity.
-E.g. 2 seconds:
-  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=2000000"
-  ./configure ...options...
-Waiting can be disabled by zero waiting time:
-  CFLAGS="$CFLAGS -DLibburn_udev_wait_useC=0"
-Alternatively, libburn can try to be nice by opening the device file,
-closing it immediately, waiting, and only then opening it for real:
-  CFLAGS="$CFLAGS -DLibburn_udev_extra_open_cyclE -DLibburn_udev_wait_useC=500000"
-
-------------------------------------------------------------------------------
-
-                  System Dependend Drive Permission Examples
-
-Accessing the optical drives requires privileges which usually are granted
-only to the superuser. Linux, FreeBSD and Solaris offer quite different
-approaches for avoiding the need for unrestricted privileges.
-
-First check whether some friendly system setting already allows you to
-access the drives as normal user:
-  cdrskin --devices
-Those drives of which you see address and type strings are already usable.
-
-If there remain drives invisible which the superuser can see by the same
-command, then the following examples might help:
-
---------------------- 
-On all three systems:
---------------------- 
-Add the authorized users of CD drives to group "floppy" in /etc/group.
-If missing: create this group.
-Changes to /etc/group often only affect new login sessions. So log out and in
-before making the first tests.
-
----------
-On Linux:
----------
-Allow rw-access to the drives
-  chgrp floppy /dev/sr0 /dev/sr1
-  chmod g+rw   /dev/sr0 /dev/sr1
-It might be necessary to perform chgrp and chmod after each reboot or to
-edit distro dependent device configuration files for permanent settings.
-
------------
-On FreeBSD:
------------
-Edit /etc/devfs.rules and make sure to have these lines
-  [localrules=10]
-  add path 'acd*' mode 0664 group floppy
-  add path 'cd*' mode 0664 group floppy
-  add path 'pass*' mode 0664 group floppy
-  add path 'xpt*' mode 0664 group floppy
-  [localrules=5]
-  add path 'pass*' mode 0664 group floppy
-  add path 'cd*' mode 0664 group floppy
-  add path 'xpt*' mode 0664 group floppy
-  add path 'acd*' mode 0664 group floppy
-
-Edit /etc/rc.conf and add the following line if missing
-  devfs_system_ruleset="localrules"
-
-This gets into effect by reboot or by command
-  /etc/rc.d/devfs start
-
------------
-On Solaris:
------------
-Run cdrskin by
-  pfexec cdrskin ...arguments...
-
-The following settings will make pfexec keep original UID and EUID and prevent
-most superuser powers. Be aware that you still can manipulate all device files
-if you have the file permissions for that.
-Full root privileges for cdrskin can then be aquired only by command su.
-
-Edit /etc/security/exec_attr and add this line to the other "Media Backup"
-lines:
-  Media Backup:solaris:cmd:::/usr/local/bin/cdrskin:privs=basic,sys_devices
-Edit /etc/user_attr and add profile "Media Backup" to the user's line:
-  thomas::::profiles=Media Backup,Primary Administrator;roles=root
-See also man privileges, man exec_attr, man user_attr.
-
-Then allow the group r-access to the drives
-  pfexec chgrp floppy /dev/rdsk/c3t0d0s2 /dev/rdsk/c4t0d0s2
-  pfexec chmod g+r    /dev/rdsk/c3t0d0s2 /dev/rdsk/c4t0d0s2
-The last two commands have to be executed after each boot. I do not know
-the relevant device configuration files yet.
-
-
 ------------------------------------------------------------------------------
                       Project aspects and legal stuff
 ------------------------------------------------------------------------------
@@ -576,7 +476,7 @@ contributions in a due way.
 Based on and sub project of:
 libburnia-project.org
 By Mario Danic <mario.danic@gmail.com> and Thomas Schmitt <scdbackup@gmx.net>
-Copyright (C) 2006-2011 Mario Danic, Thomas Schmitt
+Copyright (C) 2006-2010 Mario Danic, Thomas Schmitt
 
 libburnia-project.org is inspired by and in other components still containing
 parts of

cdrskin/add_ts_changes_to_libburn_0_7_6

@@ -38,9 +38,8 @@ original="./libburn_svn_release.tgz"
 # My changes are in $changes , mainly in $changes/cdrskin
 changes="./libburn-release"
 
-skin_release="1.1.6"
-patch_level=""
-# patch_level=".pl00"
+skin_release="0.7.6"
+patch_level=".pl00"
 skin_rev="$skin_release""$patch_level"
 
 # The result directory and the name of the result tarballs

cdrskin/add_ts_changes_to_libburn_0_7_7

@@ -38,7 +38,7 @@ original="./libburn_svn.tgz"
 # My changes are in $changes , mainly in $changes/cdrskin
 changes="./libburn-develop"
 
-skin_release="1.1.7"
+skin_release="0.7.7"
 patch_level=""
 skin_rev="$skin_release""$patch_level"
 

cdrskin/cdrfifo.c

@@ -34,7 +34,7 @@
 
 
 /* Macro for creation of arrays of objects (or single objects) */
-#define TSOB_FELD(typ,anz) (typ *) calloc(anz, sizeof(typ));
+#define TSOB_FELD(typ,anz) (typ *) malloc((anz)*sizeof(typ));
 
 
 #define Cdrfifo_buffer_chunK 2048
@@ -203,11 +203,10 @@ int Cdrfifo_close(struct CdrfifO *o, int flag)
  if(o->dest_fd!=-1)
    close(o->dest_fd);
  o->dest_fd= -1;
- for(i=0; i<o->follow_up_fd_counter; i++) {
+ for(i=0; i<o->follow_up_fd_counter; i++)
    if(o->follow_up_fds[i][1]!=-1)
      close(o->follow_up_fds[i][1]);
    o->follow_up_fds[i][1]= -1;
- }
  return(1);
 }
 
@@ -634,7 +633,7 @@ return: <0 = error , 0 = idle , 1 = did some work
 */
 {
  double buffer_space;
- int can_read,can_write= 0,ret,did_work= 0,idx,sod, eop_idx;
+ int can_read,can_write= 0,ret,did_work= 0,idx,sod,eop_is_near,eop_idx;
 
  buffer_space= Cdrfifo_tell_buffer_space(o,0);
  if(o->dest_fd>=0) if(FD_ISSET((o->dest_fd),wts)) {
@@ -644,7 +643,7 @@ return: <0 = error , 0 = idle , 1 = did some work
    if(o->read_idx+can_write > o->buffer_size)
      can_write= o->buffer_size - o->read_idx;
    if(o->follow_up_fd_idx>=0) {
-     Cdrfifo_eop_adjust(o,&can_write,&eop_idx,0);
+     eop_is_near= Cdrfifo_eop_adjust(o,&can_write,&eop_idx,0);
      if(can_write<=0)
        goto after_write;
    }
@@ -1039,9 +1038,9 @@ int Test_mixed_bs(char **paths, int path_count,
  bit0= debugging verbousity
 */
 {
- int fd_in[100],fd_out[100],ret,pipe_fds[100][2];
+ int fd_in[100],fd_out[100],ret,pipe_fds[100][2],real_out[100];
  int i,iv,stall_counter= 0,cycle_counter= 0.0;
- char target_path[80];
+ char buf[10240], target_path[80];
  double in_counter, out_counter, prev_in= -1.0, prev_out= -1.0;
  struct CdrfifO *ff_in= NULL, *ff_out= NULL;
 
@@ -1109,8 +1108,9 @@ int Test_multi(int fs_size, double speed_limit, double interval, int flag)
  bit0= debugging verbousity
 */
 {
- int fd_in[4],fd_out[4],ret,pipe_fds[4][2];
+ int fd_in[4],fd_out[4],ret,pipe_fds[4][2],real_out[4],pipe_idx;
  int i,iv;
+ char buf[10240];
  struct CdrfifO *ff1= NULL,*ff2= NULL;
 
  /* open four pairs of fds */

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 "Jul 28, 2011"
+.TH CDRSKIN 1 "Jan 19, 2010"
 .\" Please adjust this date whenever revising the manpage.
 .\"
 .\" Some roff macros, for reference:
@@ -47,7 +47,7 @@ Multi session on CD (follow-up sessions in TAO only)
 .br
 or on DVD-R[W] (in Incremental mode) or DVD+R[/DL] or BD-R.
 .br
-Single session Disk-at-once on DVD-RW, DVD-R, DVD-R DL.
+Single session on DVD-RW or DVD-R (Disk-at-once).
 .br
 Single session or emulated ISO-9660 multi-session 
 .br
@@ -82,7 +82,7 @@ A \fBtrack\fP stores a stream of bytes.
 .br
 Each track is initiated by one track source address argument, which may either
 be "-" for standard input or the address of a readable file. If no write mode
-is given explicitly then one will be chosen which matches the peculiarities
+is given explicitely then one will be chosen which matches the peculiarities
 of track sources and the state of the output media.
 .PP
 More than one track can be burned by a single run of cdrskin. 
@@ -93,13 +93,13 @@ Some media types can be kept appendable so that further tracks can
 be written to them in subsequent runs of cdrskin (see option -multi).
 Info about the addresses of burned tracks is kept in a table of
 content (TOC) on media and can be retrieved via cdrskin option -toc.
-This information is also used by the operating systems' CD-ROM read drivers.
+These informations are also used by the operating systems' CD-ROM read drivers.
 .PP
 In general there are two types of tracks: data and audio. They differ in
 sector size, throughput and readability via the systems' CD-ROM drivers
 resp. by music CD players. With DVD and BD there is only type data.
 .br
-If not explicitly option -audio is given, then any track is burned as type
+If not explicitely option -audio is given, then any track is burned as type
 data, unless the track source is a file with suffix ".wav" or ".au" and has a
 header part which identifies it as MS-WAVE resp. SUN Audio with suitable
 parameters. Such files are burned as audio tracks by default.
@@ -138,7 +138,7 @@ try to choose a write mode which matches the defined recording job,
 the capabilities of the drive and the state of the present media.
 .br
 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 explicitly,
+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.
 .SS
 .B Recordable CD Media:
@@ -166,7 +166,7 @@ needed.
 .SS
 .B Sequentially Recordable DVD or BD Media:
 .br
-Currently DVD-RW, DVD-R[DL], DVD+R[DL], and BD-R can be used for the Sequential
+Currently DVD-RW, DVD-R , DVD+R[/DL], and BD-R can be used for the Sequential
 recording model. It resembles the model of CD media. Only DVD-RW can be
 blanked and re-used from scratch.
 .br
@@ -181,24 +181,24 @@ With DVD-R[W] two write modes may be available:
 Mode DAO has many restrictions. It does not work with
 appendable media, allows no -multi and only a single track. The size of the
 track needs to be known in advance. So either its source has to be a disk file
-of recognizable size or the size has to be announced explicitly by options
+of recognizable size or the size has to be announced explicitely by options
 .B tsize= 
 or
 .B tao_to_sao_tsize= .
 .br
-DAO is the only mode for DVD-R media which do not offer feature 21h Incremental
-Streaming (e.g. DVD-R DL). DAO may also be selected explicitly by option
+DAO is the only mode for media which do not offer feature 21h Incremental
+Streaming. DAO may also be selected explicitely by option
 .B -sao .
 Program growisofs uses DAO on sequential DVD-R[W] media for maximum
 DVD-ROM/-Video compatibility.
 .br
 The other mode, Incremental Streaming, is the default write mode if
 it is available and if the restrictions of DAO would prevent the job.
-Incremental Streaming may be selected explicitly by option
+Incremental Streaming may be selected explicitely by option
 .B -tao
 as it resembles much CD TAO by allowing track sources of
 unpredicted length and to keep media appendable by option
-.B -multi . It does not work with DVD-R DL and minimally blanked DVD-RW.
+.B -multi .
 The only restriction towards CD-R[W] is the lack of support for -audio tracks.
 Multiple tracks per session are permissible.
 .br
@@ -225,7 +225,7 @@ Currently types DVD+RW, DVD-RW, DVD-RAM and BD-RE can be overwritten via
 cdrskin.
 .br
 Option -audio is not allowed. Only one track is allowed.
-Option -multi cannot mark a recognizable end of overwriteable media.
+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 .
@@ -256,7 +256,7 @@ that it has to be formatted again. If in doubt, just give it a try.
 .br
 The drives, CD, DVD, or BD burners, are accessed via addresses which
 are specific to libburn and the operating system. Those addresses get listed
-by a run of \fBcdrskin --devices\fP or \fBcdrskin --device_links\fP.
+by a run of \fBcdrskin --devices\fP.
 .br
 On Linux, they are device files which traditionally do not offer
 w-permissions for normal users. Because libburn needs rw-permission,
@@ -271,22 +271,19 @@ 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
-For drive permission examples on Linux, FreeBSD, and Solaris,
-see cdrskin/README.
-.br
 .PP
 If you only got one CD capable drive then you may leave out cdrskin option
 \fBdev=\fP. Else you should use this option to address the drive you want.
 .br
 cdrskin option dev= not only accepts the listed addresses but also
-traditional cdrecord SCSI addresses which consist of three numbers:
-Bus,Target,Lun. On Linux there is also a related address family "ATA" which
+traditional cdrecord SCSI addresses which on Linux consist of three
+numbers: Bus,Target,Lun. There is also a related address family "ATA" which
 accesses IDE drives not under control of Linux SCSI drivers:
 ATA:Bus,Target,Lun.
 .br
 See option -scanbus for getting a list of cdrecord style addresses.
 .br
-Further are accepted: links to libburn-suitable device files, 
+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/sg0).
 .br
@@ -353,7 +350,7 @@ print "Mounted Media:" and media type text.
 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 explicitly by option -data, input files with suffix
+-swab. Unless marked explicitely by option -data, input files with suffix
 ".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.
@@ -512,7 +509,7 @@ cdrskin will not write CD-ROM XA but rather strip the header bytes and write as
 .TP
 .BI dev= target
 Set the address of the drive to use. Valid are at least the
-addresses listed with options --devices or --device_links,
+addresses listed with option --devices, 
 X,Y,Z addresses listed with option -scanbus,
 ATA:X,Y,Z addresses listed with options dev=ATA -scanbus,
 and volatile libburn drive numbers (numbering starts at "0").
@@ -530,7 +527,7 @@ of Bus,Target,Lun addresses.
 Set "driveropts=noburnfree" to disable the drive's eventual protection
 mechanism against temporary lack of source data (i.e. buffer underrun).
 A drive that announces no such capabilities will not get them enabled anyway,
-even if attempted explicitly via "driveropts=burnfree".
+even if attempted explicitely via "driveropts=burnfree".
 .TP
 .BI \-dummy
 Try to perform the drive operations without actually affecting the inserted
@@ -554,9 +551,6 @@ which appear to be in the desired blank or format state already.
 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
-It enables a burn run where cdrskin expects to exceed the available media
-capacity.
-.br
 .B Caution:
 Use this only when in urgent need.
 .TP
@@ -603,7 +597,7 @@ 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 preceded
+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
@@ -662,8 +656,7 @@ 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 DVD-R[W] DAO write mode and on DVD-R DL media.
-Option --prodvd_cli_compatible eventually makes
+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
@@ -712,7 +705,7 @@ No -multi is allowed with DVD-R[W] -sao.
 only imposes restrictions without providing known advantages. 
 .br
 -sao can only be used for tracks of fixely predicted size. This implies that
-track arguments which depict stdin or named pipes need to be preceded by
+track arguments which depict stdin or named pipes need to be preceeded by
 option tsize= or by option tao_to_sao_tsize=.
 .br
 -sao cannot be used on appendable media.
@@ -757,8 +750,6 @@ Mode -tao can be used with track sources of unpredictable size, like standard
 input or named pipes. It is also the only mode that can be used for writing
 to appendable media which already hold data. With unformatted DVD-R[W] it is
 the only mode which allows -multi.
-.br
-Mode -tao is not usable for minimally blanked DVD-RW and for DVD-R DL.
 .TP
 .BI \-toc
 Print the table of content (TOC) which describes the tracks recorded on disc.
@@ -831,7 +822,7 @@ Alphabetical list of options which are genuine to cdrskin and intended for
 normal use:
 .TP
 .BI \--adjust_speed_to_drive
-Curb explicitly given speed= values to the maximum which is announced by the
+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.
@@ -881,17 +872,6 @@ 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 \--device_links
-Like --devices, but presenting the drives with addresses of symbolic links
-which point to the actual device files.
-.br
-Modern GNU/Linux systems may shuffle drive addresses from boot to boot.
-The udev daemon is supposed to create links which always point to the
-same drive, regardless of its system address.
-Option --device_links shows the addresses of such links if they begin
-by "/dev/dvd" or "/dev/cd".
-Precedence is: "dvdrw", "cdrw", "dvd", "cdrom", "cd".
-.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
@@ -936,7 +916,7 @@ to cdrskin, then cdrskin will delegate the job to said command.
 The natural commands to be given are cdrecord or wodim but one may well submit
 the address of an own program. 
 .br
-The fallback program will get all arguments of cdrskin which do not match
+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.
@@ -982,12 +962,12 @@ source is a ISO-9660 filesystem image.
 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 recognizable ISO-9660 size will be regarded as
+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 overridden by option write_start_address=, the track with the new image
+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
@@ -1082,7 +1062,7 @@ the available capacity. So for most realistic results one may set up
 the full burn session and add --tell_media_space. But if one has to expect
 a cdrskin version prior to 0.3.3 no track source should be given in order
 not to start an involuntary burn session.
-In this case set at least -sao or -tao explicitly.
+In this case set at least -sao or -tao explicitely.
 .br
 The result gets printed to standard output. It is 0 or empty if no writing
 is possible with the given options.
@@ -1107,11 +1087,12 @@ This option is only needed for revoking eventual --ignore_signals or
 .TP
 .BI \--allow_untested_media
 Enable the use of media profiles which have been implemented but not yet
-tested. Currently this option is without effect because no media types are
-under test reservation.
+tested. Currently this applies to :
 .br
-(If you really test experimental media, then please report the outcome on
-libburn-hackers@pykix.org)
+Profile 0015h , DVD-R/DL Sequential (will not allow -multi).
+.br
+If you really test such media, then please report the outcome on
+libburn-hackers@pykix.org 
 .TP
 .BI dev_translation= <sep><from><sep><to>
 Set drive address alias. This was necessary before cdrskin-0.2.4 to manually
@@ -1147,9 +1128,9 @@ 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 scanned for by
-options --devices, --device_links and -scanbus.
+options --devices and -scanbus.
 Normally this is /dev/sgN on kernel versions < 2.6 and /dev/srN
-on kernels >= 2.6 . This option allows to explicitly override that default
+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
@@ -1253,7 +1234,7 @@ cdrskin -scanbus
 .br
 cdrskin dev=ATA -scanbus
 .br
-cdrskin --device_links
+cdrskin --devices
 .SS
 .B Get info about a particular drive or loaded media:
 .br
@@ -1281,7 +1262,7 @@ cdrskin -v dev=/dev/hdc speed=12 fs=8m \\
 .br
 blank=as_needed -eject padsize=300k my_image.iso
 .SS
-.B Write compressed afio archive on-the-fly (not possible with minimally blanked DVD-RW or DVD-R DL):
+.B Write compressed afio archive on-the-fly (not possible with minimally blanked DVD-RW):
 .br
 find . | afio -oZ - | \\
 .br

cdrskin/cdrskin.c

@@ -1,7 +1,7 @@
 
 /*
- cdrskin.c , Copyright 2006-2011 Thomas Schmitt <scdbackup@gmx.net>
-Provided under GPL version 2 or later.
+ cdrskin.c , Copyright 2006-2010 Thomas Schmitt <scdbackup@gmx.net>
+Provided under GPL version 2 or later. See future commitment below.
 
 A cdrecord compatible command line interface for libburn.
 
@@ -12,7 +12,8 @@ See also :  http://scdbackup.sourceforge.net/cdrskin_eng.html
 
 Interested users of cdrecord are encouraged to contribute further option
 implementations as they need them. Contributions will get published under GPL
-but it is essential that the authors allow a future release under LGPL.
+but it is essential that the authors allow a future release under LGPL and/or
+BSD license.
 
 There is a script test/cdrecord_spy.sh which may be installed between
 the cdrecord command and real cdrecord in order to learn about the options
@@ -87,17 +88,17 @@ or
 
 /** The official program version */
 #ifndef Cdrskin_prog_versioN
-#define Cdrskin_prog_versioN "1.1.6"
+#define Cdrskin_prog_versioN "0.7.6"
 #endif
 
 /** The official libburn interface revision to use.
     (May get changed further below)
 */
 #ifndef Cdrskin_libburn_majoR
-#define Cdrskin_libburn_majoR 1
+#define Cdrskin_libburn_majoR 0
 #endif
 #ifndef Cdrskin_libburn_minoR
-#define Cdrskin_libburn_minoR 1
+#define Cdrskin_libburn_minoR 7
 #endif
 #ifndef Cdrskin_libburn_micrO
 #define Cdrskin_libburn_micrO 6
@@ -134,36 +135,42 @@ or
 #endif /* Cdrskin_libburn_cvs_A60220_tS */
 
 
-#ifdef Cdrskin_libburn_1_1_6
-#define Cdrskin_libburn_versioN "1.1.6"
+#ifdef Cdrskin_libburn_0_7_6
+#define Cdrskin_libburn_versioN "0.7.6"
 #define Cdrskin_libburn_from_pykix_svN 1
-#endif
+#endif /* Cdrskin_libburn_0_7_6 */
 
-#ifdef Cdrskin_libburn_1_1_7
-#define Cdrskin_libburn_versioN "1.1.7"
+#ifdef Cdrskin_libburn_0_7_7
+#define Cdrskin_libburn_versioN "0.7.7"
 #define Cdrskin_libburn_from_pykix_svN 1
-#endif
+
+/* Place novelty switch macros here. 
+   Move them down to Cdrskin_libburn_from_pykix_svN on version leap
+*/
+
+
+#endif /* Cdrskin_libburn_0_7_7 */
 
 #ifndef Cdrskin_libburn_versioN
-#define Cdrskin_libburn_1_1_6
-#define Cdrskin_libburn_versioN "1.1.6"
+#define Cdrskin_libburn_0_7_6
+#define Cdrskin_libburn_versioN "0.7.6"
 #define Cdrskin_libburn_from_pykix_svN 1
 #endif
 
-#ifdef Cdrskin_libburn_1_1_6
+#ifdef Cdrskin_libburn_0_7_6
 #undef Cdrskin_libburn_majoR
 #undef Cdrskin_libburn_minoR
 #undef Cdrskin_libburn_micrO
-#define Cdrskin_libburn_majoR 1
-#define Cdrskin_libburn_minoR 1
+#define Cdrskin_libburn_majoR 0
+#define Cdrskin_libburn_minoR 7
 #define Cdrskin_libburn_micrO 6
 #endif
-#ifdef Cdrskin_libburn_1_1_7
+#ifdef Cdrskin_libburn_0_7_7
 #undef Cdrskin_libburn_majoR
 #undef Cdrskin_libburn_minoR
 #undef Cdrskin_libburn_micrO
-#define Cdrskin_libburn_majoR 1
-#define Cdrskin_libburn_minoR 1
+#define Cdrskin_libburn_majoR 0
+#define Cdrskin_libburn_minoR 7
 #define Cdrskin_libburn_micrO 7
 #endif
 
@@ -352,40 +359,16 @@ or
 
 #include "../libburn/libburn.h"
 
+#ifdef Cdrskin_libburn_has_audioxtR
+#include "../libburn/libdax_audioxtr.h"
+#endif
 
 #ifdef Cdrskin_libburn_has_cleanup_handleR
 #define Cleanup_set_handlers burn_set_signal_handling
 #define Cleanup_app_handler_T burn_abort_handler_t
 #else
 #include "cleanup.h"
-#ifdef Cdrskin_use_libburn_cleanuP
-#undef Cdrskin_use_libburn_cleanuP
 #endif
-#endif
-
-/*
- # define Cdrskin_use_libburn_cleanuP 1
-*/
-/* May not use libburn cleanup with cdrskin fifo */
-#ifndef Cdrskin_use_libburn_fifO
-#ifdef Cdrskin_use_libburn_cleanuP
-#undef Cdrskin_use_libburn_cleanuP
-#endif
-#endif
-
-#ifdef Cdrskin_use_libburn_cleanuP
-#define Cleanup_handler_funC   NULL
-#define Cleanup_handler_handlE "cdrskin: "
-#define Cleanup_handler_flaG 48
-#else
-#define Cleanup_handler_funC   (Cleanup_app_handler_T) Cdrskin_abort_handler
-#define Cleanup_handler_handlE skin
-#define Cleanup_handler_flaG 4
-#endif /* ! Cdrskin_use_libburn_cleanuP */
-
-/* 0= no abort going on, -1= Cdrskin_abort_handler was called
-*/
-static int Cdrskin_abort_leveL= 0;
 
 
 /** The size of a string buffer for pathnames and similar texts */
@@ -409,7 +392,7 @@ static int Cdrskin_abort_leveL= 0;
 /* Imported from scdbackup-0.8.5/src/cd_backup_planer.c */
 
 /** Macro for creation of arrays of objects (or single objects) */
-#define TSOB_FELD(typ,anz) (typ *) calloc(anz, sizeof(typ));
+#define TSOB_FELD(typ,anz) (typ *) malloc((anz)*sizeof(typ));
 
 
 /** Convert a text so that eventual characters special to the shell are
@@ -559,7 +542,7 @@ int Sfile_multi_read_argv(char *progname, char **filenames, int filename_count,
      if(pass==0)
        maxl= strlen(progname)+1;
      else {
-      (*argv)[0]= (char *) calloc(1, strlen(progname)+1);
+      (*argv)[0]= (char *) malloc(strlen(progname)+1);
       if((*argv)[0]==NULL)
          {ret= -1; goto ex;}
        strcpy((*argv)[0],progname);
@@ -590,7 +573,7 @@ int Sfile_multi_read_argv(char *progname, char **filenames, int filename_count,
        } else {
          if(argcount >= *argc)
      break;
-         (*argv)[argcount]= (char *) calloc(1, l+1);
+         (*argv)[argcount]= (char *) malloc(l+1);
          if((*argv)[argcount]==NULL)
            {ret= -1; goto ex;}
          strcpy((*argv)[argcount],buf);
@@ -604,9 +587,9 @@ int Sfile_multi_read_argv(char *progname, char **filenames, int filename_count,
    if(pass==0){
      *argc= argcount;
      if(argcount>0) {
-       *argv= (char **) calloc(argcount, sizeof(char *));
-       *argidx= (int *) calloc(argcount, sizeof(int));
-       *arglno= (int *) calloc(argcount, sizeof(int));
+       *argv= (char **) malloc(argcount*sizeof(char *));
+       *argidx= (int *) malloc(argcount*sizeof(int));
+       *arglno= (int *) malloc(argcount*sizeof(int));
        if(*argv==NULL || *argidx==NULL || *arglno==NULL)
          {ret= -1; goto ex;}
      }
@@ -641,7 +624,7 @@ int Sfile_home_adr_s(char *filename, char *fileadr, int fa_size, int flag)
  home= getenv("HOME");
  if(home==NULL)
    return(0);
- if((int) (strlen(home) + strlen(filename) + 1) >= fa_size)
+ if(strlen(home)+strlen(filename)+1>=fa_size)
    return(-1);
  strcpy(fileadr,home);
  if(filename[0]!=0){
@@ -806,8 +789,8 @@ int Cdradrtrn_add(struct CdradrtrN *trn, char *from, char *to, int flag)
  }
  if(strlen(from)>=Cdrskin_adrleN || strlen(to)>=Cdrskin_adrleN)
    return(0);
- trn->from_address[cnt]= calloc(1, strlen(from_pt)+1);
- trn->to_address[cnt]= calloc(1, strlen(to_pt)+1);
+ trn->from_address[cnt]= malloc(strlen(from_pt)+1);
+ trn->to_address[cnt]= malloc(strlen(to_pt)+1);
  if(trn->from_address[cnt]==NULL ||
     trn->to_address[cnt]==NULL)
    return(-2);
@@ -1813,6 +1796,7 @@ int Cdrtrack_add_to_session(struct CdrtracK *track, int trackno,
 
    Cdrskin_get_fifo_par(track->boss, &fifo_enabled, &fifo_size, &fifo_start_at,
                         0);
+   fd_src= src;
 
    if(track->track_type == BURN_AUDIO)
      chunksize= 2352;
@@ -1822,7 +1806,6 @@ int Cdrtrack_add_to_session(struct CdrtracK *track, int trackno,
      chunksize= 2048;
    chunks= fifo_size / chunksize;
    if(chunks > 1 && fifo_enabled) {
-     fd_src= src;
      src= burn_fifo_source_new(fd_src, chunksize, chunks,
                                (chunksize * chunks >= 128 * 1024));
      if((flag & 1) || src == NULL)
@@ -2210,7 +2193,6 @@ LIBBURN_MISCONFIGURATION_ = 0;
    return(-1);
  }
  Cdrpreskin_set_severities(preskin,NULL,NULL,0);
- burn_allow_drive_role_4(1);
  return(1);
 }
 
@@ -2677,8 +2659,7 @@ return:
      o->scan_demands_drive= 1;
      o->demands_cdrskin_caps= 1;
 
-   } else if(strcmp(argv[i],"--devices") == 0 ||
-             strcmp(argv[i],"--device_links") == 0) {
+   } else if(strcmp(argv[i],"--devices")==0) {
 #ifndef Cdrskin_extra_leaN
      printf("Note: If this hangs for a while then there is a drive with\n");
      printf("      unexpected problems (e.g. ill DMA).\n");
@@ -2873,7 +2854,6 @@ set_dev:;
     " direct_write_amount=<size>  write random access to media like DVD+RW\n");
      printf(" --demand_a_drive   exit !=0 on bus scans with empty result\n");
      printf(" --devices          list accessible devices (tells /dev/...)\n");
-     printf(" --device_links     list accessible devices by (udev) links\n");
      printf(
           " dev_translation=<sep><from><sep><to>   set input address alias\n");
      printf("                    e.g.: dev_translation=+ATA:1,0,0+/dev/sg1\n");
@@ -3163,7 +3143,7 @@ set_severities:;
      int major, minor, micro;
 
      printf(
-"Cdrecord 2.01-Emulation Copyright (C) 2006-2011, see libburnia-project.org\n");
+"Cdrecord 2.01-Emulation Copyright (C) 2006-2010, see libburnia-project.org\n");
      if(o->fallback_program[0]) {
        char *hargv[2];
 
@@ -3395,7 +3375,7 @@ struct CdrskiN {
  int single_track;
  int prodvd_cli_compatible;
 
- int do_devices;              /* 1= --devices , 2= --device_links */
+ int do_devices;
 
  int do_scanbus;
 
@@ -3635,7 +3615,6 @@ int Cdrskin_new(struct CdrskiN **skin, struct CdrpreskiN *preskin, int flag)
  o->write_type= BURN_WRITE_SAO;
  o->block_type= BURN_BLOCK_SAO;
  o->multi= 0;
- o->cdxa_conversion= 0;
  o->modesty_on_drive= 0;
  o->min_buffer_percent= 65;
  o->max_buffer_percent= 95;
@@ -3745,7 +3724,7 @@ int Cdrskin_get_device_adr(struct CdrskiN *skin,
 
 int Cdrskin_get_drive(struct CdrskiN *skin, struct burn_drive **drive,int flag)
 {
- if(skin->driveno<0 || (unsigned int) skin->driveno >= skin->n_drives)
+ if(skin->driveno<0 || skin->driveno >= skin->n_drives)
    return(0);
  *drive= skin->drives[skin->driveno].drive;
  return ((*drive) != NULL); 
@@ -4009,7 +3988,7 @@ int Cdrskin_grab_drive(struct CdrskiN *skin, int flag)
        ClN(fprintf(stderr,
          "cdrskin_debug: Cdrskin_grab_drive() dropping unwanted drives (%d)\n",
           skin->n_drives-1));
-     for(i= 0; i < (int) skin->n_drives; i++) {
+     for(i=0;i<skin->n_drives;i++) {
        if(i==skin->driveno)
      continue;
        if(skin->verbosity>=Cdrskin_verbose_debuG)   
@@ -4107,8 +4086,7 @@ ex:;
 #ifdef Cdrskin_grab_abort_brokeN
  if(restore_handler) {
    int Cdrskin_abort_handler(struct CdrskiN *, int, int);
-   Cleanup_set_handlers(Cleanup_handler_handlE, Cleanup_handler_funC,
-                        Cleanup_handler_flaG);
+   Cleanup_set_handlers(skin,(Cleanup_app_handler_T) Cdrskin_abort_handler,4);
  }
 #endif /* Cdrskin_grab_abort_brokeN */
 
@@ -4141,42 +4119,17 @@ int Cdrskin_release_drive(struct CdrskiN *skin, int flag)
 }
 
 
-int Cdrskin__is_aborting(int flag)
-{
- if(Cdrskin_abort_leveL)
-   return(-1);
- return(burn_is_aborting(0));
-}
-
-
-int Cdrskin_abort(struct CdrskiN *skin, int flag)
-{
- int ret;
-
- Cdrskin_abort_leveL= 1;
- ret= burn_abort(skin->abort_max_wait, burn_abort_pacifier, "cdrskin: ");
- if(ret<=0) {
-   fprintf(stderr,
-       "\ncdrskin: ABORT : Cannot cancel burn session and release drive.\n");
-   return(0);
- } else {
-   fprintf(stderr,
-  "cdrskin: ABORT : Drive is released and library is shut down now.\n");
- }
- fprintf(stderr,
-  "cdrskin: ABORT : Program done. Even if you do not see a shell prompt.\n");
- fprintf(stderr,"\n");
- exit(1);
-}
-
-
 /** Clean up resources in abort situations. To be called by Cleanup subsystem
     but hardly ever by the application. The program must exit afterwards.
 */
 int Cdrskin_abort_handler(struct CdrskiN *skin, int signum, int flag)
 {
 
-#ifndef Cdrskin_libburn_has_burn_aborT
+#ifdef Cdrskin_libburn_has_burn_aborT
+
+ int ret;
+
+#else 
 
  int wait_grain= 100000,first_status= 1;
  double start_time,last_time,current_time;
@@ -4189,9 +4142,8 @@ int Cdrskin_abort_handler(struct CdrskiN *skin, int signum, int flag)
  if(getpid()!=skin->control_pid) {
    if(skin->verbosity>=Cdrskin_verbose_debuG)   
      ClN(fprintf(stderr,
-        "\ncdrskin_debug: ABORT : [%lu] Thread rejected: pid=%lu, signum=%lu\n",
-        (unsigned long int) skin->control_pid, (unsigned long int) getpid(),
-        (unsigned long int) signum));
+          "\ncdrskin_debug: ABORT : [%d] Thread rejected: pid=%d, signum=%d\n",
+          skin->control_pid,getpid(),signum));
 
 #ifdef Not_yeT
    /* >>> find more abstract and system independent way to determine 
@@ -4229,15 +4181,14 @@ int Cdrskin_abort_handler(struct CdrskiN *skin, int signum, int flag)
    fprintf(stderr,"cdrskin: ABORT : Usually it is done with 4x speed after about a MINUTE\n");
    fprintf(stderr,"cdrskin: URGE  : But wait at least the normal burning time before any kill -9\n");
  }
- if(skin->verbosity>=Cdrskin_verbose_debuG)
-   ClN(fprintf(stderr,"cdrskin_debug: ABORT : Calling burn_abort()\n"));
 
- Cdrskin_abort_leveL= -1;
- if (!(flag & 1))
- burn_abort(-1, burn_abort_pacifier, "cdrskin: ");
- fprintf(stderr,
-        "cdrskin: ABORT : Urged drive worker threads to do emergency halt.\n");
- return -2;
+ ret= burn_abort(skin->abort_max_wait, burn_abort_pacifier, "cdrskin: ");
+ if(ret<=0) {
+   fprintf(stderr,
+         "\ncdrskin: ABORT : Cannot cancel burn session and release drive.\n");
+   return(0);
+ }
+ fprintf(stderr,"\n");
 
 #else /* Cdrskin_libburn_has_burn_aborT */
 
@@ -4352,7 +4303,7 @@ int Cdrskin_driveno_of_location(struct CdrskiN *skin, char *devicename,
  int i,ret;
  char adr[Cdrskin_adrleN];
 
- for(i= 0; i < (int) skin->n_drives; i++) {
+ for(i=0;i<skin->n_drives;i++) {
 
 #ifdef Cdrskin_libburn_has_drive_get_adR
    ret= burn_drive_get_adr(&(skin->drives[i]), adr);
@@ -4442,7 +4393,7 @@ wrong_devno:;
      goto location_not_found;
    }
  }
- if((unsigned int) (*driveno) >= skin->n_drives || (*driveno) < 0) {
+ if((*driveno)>=skin->n_drives || (*driveno)<0) {
    ClN(fprintf(stderr,"cdrskin: obtained drive number  %d  from '%s'\n",
                *driveno,adr));
    goto wrong_devno;
@@ -4468,7 +4419,7 @@ int Cdrskin_driveno_to_btldev(struct CdrskiN *skin, int driveno,
  int k,ret,still_untranslated= 1,hret,k_start;
  char *loc= NULL,buf[Cdrskin_adrleN],adr[Cdrskin_adrleN];
 
- if(driveno < 0 || driveno > (int) skin->n_drives)
+ if(driveno<0 || driveno>skin->n_drives)
    goto fallback;
 
 #ifdef Cdrskin_libburn_has_drive_get_adR
@@ -4722,47 +4673,28 @@ int Cdrskin_report_disc_status(struct CdrskiN *skin, enum burn_disc_status s,
 /** Perform operations -scanbus or --devices 
     @param flag Bitfield for control purposes: 
                 bit0= perform --devices rather than -scanbus
-                bit1= with bit0: perform --device_links
     @return <=0 error, 1 success
 */
 int Cdrskin_scanbus(struct CdrskiN *skin, int flag)
 {
  int ret,i,busno,first_on_bus,pseudo_transport_group= 0,skipped_devices= 0;
- int busmax= 16, busidx, max_dev_len, pad, j;
+ int busmax= 16, busidx;
  char shellsafe[5*Cdrskin_strleN+2],perms[40],btldev[Cdrskin_adrleN];
  char adr[Cdrskin_adrleN],*raw_dev,*drives_shown= NULL;
- char link_adr[BURN_DRIVE_ADR_LEN];
  int *drives_busses= NULL;
  struct stat stbuf;
 
- drives_shown= calloc(1, skin->n_drives+1);
- drives_busses= calloc((skin->n_drives+1), sizeof(int));
+ drives_shown= malloc(skin->n_drives+1);
+ drives_busses= malloc((skin->n_drives+1) * sizeof(int));
  if(drives_shown == NULL || drives_busses == NULL)
    {ret= -1; goto ex;}
-
+ for(i=0;i<skin->n_drives;i++)
+   drives_shown[i]= 0;
  if(flag&1) {
-   max_dev_len= 0;
-   for(i= 0; i < (int) skin->n_drives; i++) {
-     drives_shown[i]= 0;
-     ret= burn_drive_get_adr(&(skin->drives[i]), adr);
-     if(ret<=0)
-   continue;
-     if(flag & 2) {
-       ret= burn_lookup_device_link(adr, link_adr, "/dev", NULL, 0, 0);
-       if(ret == 1)
-         strcpy(adr, link_adr);
-     }
-     if(strlen(adr)>=Cdrskin_strleN)
-       Text_shellsafe("failure:oversized string", shellsafe, 0);
-     else
-       Text_shellsafe(adr, shellsafe,0);
-     if((int) strlen(shellsafe) > max_dev_len)
-       max_dev_len= strlen(shellsafe);
-   }
    printf("cdrskin: Overview of accessible drives (%d found) :\n",
           skin->n_drives);
    printf("-----------------------------------------------------------------------------\n");
-   for(i= 0; i < (int) skin->n_drives; i++) {
+   for(i=0;i<skin->n_drives;i++) {
 
 #ifdef Cdrskin_libburn_has_drive_get_adR
      ret= burn_drive_get_adr(&(skin->drives[i]), adr);
@@ -4785,22 +4717,12 @@ int Cdrskin_scanbus(struct CdrskiN *skin, int flag)
        if(stbuf.st_mode&S_IROTH) perms[4]= 'r';
        if(stbuf.st_mode&S_IWOTH) perms[5]= 'w';
      }
-     if(flag & 2) {
-       ret= burn_lookup_device_link(adr, link_adr, "/dev", NULL, 0, 0);
-       if(ret == 1)
-         strcpy(adr, link_adr);
-     }
      if(strlen(adr)>=Cdrskin_strleN)
        Text_shellsafe("failure:oversized string",shellsafe,0);
      else
        Text_shellsafe(adr,shellsafe,0);
-     printf("%d  dev=%s", i, shellsafe);
-     pad= max_dev_len - strlen(shellsafe);
-     if(pad > 0)
-       for(j= 0; j < pad; j++)
-         printf(" ");
-     printf("  %s :  '%-8.8s'  '%s'\n",
-            perms, skin->drives[i].vendor, skin->drives[i].product);
+     printf("%d  dev=%s  %s :  '%-8.8s'  '%s'\n",
+            i,shellsafe,perms,skin->drives[i].vendor,skin->drives[i].product);
    }
    printf("-----------------------------------------------------------------------------\n");
  } else {
@@ -4822,7 +4744,7 @@ int Cdrskin_scanbus(struct CdrskiN *skin, int flag)
    if(skin->preskin->old_pseudo_scsi_adr)
      printf("cdrskin: NOTE : The printed addresses are not cdrecord compatible !\n");
 
-   for(i= 0; i < (int) skin->n_drives; i++) {
+   for(i=0;i<skin->n_drives;i++) {
      drives_busses[i]= -1;
      ret= Cdrskin_driveno_to_btldev(skin,i,btldev,1);
      if(ret >= pseudo_transport_group &&
@@ -4832,8 +4754,8 @@ int Cdrskin_scanbus(struct CdrskiN *skin, int flag)
          busmax= 1 + ret - pseudo_transport_group;
      }
    }
-   for(busidx= 0; busidx < (int) skin->n_drives + 1; busidx++) {
-     if(busidx < (int) skin->n_drives)
+   for(busidx= 0; busidx < skin->n_drives + 1; busidx++) {
+     if(busidx < skin->n_drives)
        busno= drives_busses[busidx];
      else
        busno= busmax;
@@ -4845,7 +4767,7 @@ int Cdrskin_scanbus(struct CdrskiN *skin, int flag)
      if(i < busidx)
    continue;
      first_on_bus= 1;
-     for(i= 0; i < (int) skin->n_drives; i++) {
+     for(i=0;i<skin->n_drives;i++) {
        ret= Cdrskin_driveno_to_btldev(skin,i,btldev,1);
        if(busno==busmax && drives_shown[i]==0) {
          if(ret/1000000 != pseudo_transport_group) {
@@ -4904,7 +4826,7 @@ int Cdrskin_checkdrive(struct CdrskiN *skin, char *profile_name, int flag)
    else
      ClN(printf("cdrskin: pseudo-checkdrive on drive %d\n",skin->driveno));
  }
- if(skin->driveno >= (int) skin->n_drives || skin->driveno < 0) {
+ if(skin->driveno>=skin->n_drives || skin->driveno<0) {
    fprintf(stderr,"cdrskin: FATAL : there is no drive #%d\n",skin->driveno);
    {ret= 0; goto ex;}  
  } 
@@ -4921,10 +4843,6 @@ int Cdrskin_checkdrive(struct CdrskiN *skin, char *profile_name, int flag)
    printf("%s\n","Emulated (stdio-drive, 2k random read-write)");
  else if(ret==3)
    printf("%s\n","Emulated (stdio-drive, sequential write-only)");
- else if(ret==4)
-   printf("%s\n","Emulated (stdio-drive, 2k random read-only)");
- else if(ret == 5)
-   printf("%s\n","Emulated (stdio-drive, 2k random write-only)");
  else if(ret!=1)
    printf("%s\n","Emulated (stdio-drive)");
  else
@@ -5168,7 +5086,7 @@ int Cdrskin_minfo(struct CdrskiN *skin, int flag)
 #endif
  char media_class[80];
  int nominal_sessions= 1, ftils= 1, ltils= 1, first_track= 1, read_capacity= 0;
- int app_code, cd_info_valid, lra, alloc_blocks, free_blocks;
+ int app_code, cd_info_valid, lra;
  off_t avail, buf_count;
  char disc_type[80], bar_code[9], buf[2 * 2048];
  unsigned int disc_id;
@@ -5264,11 +5182,6 @@ int Cdrskin_minfo(struct CdrskiN *skin, int flag)
    printf("Disk type: unrecognizable\n");
  if(cd_info_valid & 2)
    printf("Disk id: 0x%-X\n", disc_id);
- ret= burn_disc_get_bd_spare_info(drive, &alloc_blocks, &free_blocks, 0);
- if(ret == 1) {
-   printf("BD Spare Area consumed:   %d\n", alloc_blocks - free_blocks);
-   printf("BD Spare Area available:  %d\n", free_blocks);
- }
 
  printf("\n");
  printf("Track  Sess Type   Start Addr End Addr   Size\n");
@@ -5304,8 +5217,8 @@ int Cdrskin_minfo(struct CdrskiN *skin, int flag)
        /* If last two blocks not readable then assume TAO and subtract 2
           from lra and size.
        */;
-       ret= burn_read_data(drive, (off_t) (lra - 1) * (off_t) 2048, buf,
-                           2 * 2048, &buf_count, 2 | 4);
+       ret= burn_read_data(drive, (off_t) lra * (off_t) 2048, buf, 2 * 2048,
+                           &buf_count, 2 | 4);
        if(ret <= 0) {
          lra-= 2;
          size-= 2;
@@ -5412,7 +5325,7 @@ int Cdrskin_print_all_profiles(struct CdrskiN *skin, struct burn_drive *drive,
 int Cdrskin_atip(struct CdrskiN *skin, int flag)
 {
  int ret,is_not_really_erasable= 0, current_is_cd= 1;
- double x_speed_max= -1.0, x_speed_min= -1.0;
+ double x_speed_max, x_speed_min= -1.0;
  enum burn_disc_status s;
  struct burn_drive *drive;
  int profile_number= 0;
@@ -5426,8 +5339,16 @@ int Cdrskin_atip(struct CdrskiN *skin, int flag)
  drive= skin->drives[skin->driveno].drive;
  s= burn_disc_get_status(drive);
  Cdrskin_report_disc_status(skin,s,1|2);
- if(s==BURN_DISC_APPENDABLE && skin->no_blank_appendable)
+ if(s==BURN_DISC_APPENDABLE && skin->no_blank_appendable) {
    is_not_really_erasable= 1;
+ } else if(s==BURN_DISC_EMPTY) {
+   if(skin->verbosity>=Cdrskin_verbose_progresS) {
+     printf("Current: none\n");
+     Cdrskin_print_all_profiles(skin, drive, 0);
+   }
+   ret= 0; goto ex;
+ }
+
 
 #ifdef Cdrskin_atip_speed_brokeN
 
@@ -5524,17 +5445,13 @@ int Cdrskin_atip(struct CdrskiN *skin, int flag)
  }
 #endif /* Cdrskin_libburn_has_burn_disc_unsuitablE */
 
- if(burn_disc_get_status(drive) != BURN_DISC_EMPTY) {
-   ret= burn_drive_get_write_speed(drive);
-   x_speed_max= ((double) ret)/Cdrskin_libburn_speed_factoR;
-   if(x_speed_min<0)
-     x_speed_min= x_speed_max;
- }
+ ret= burn_drive_get_write_speed(drive);
+ x_speed_max= ((double) ret)/Cdrskin_libburn_speed_factoR;
+ if(x_speed_min<0)
+   x_speed_min= x_speed_max;
  printf("cdrskin: burn_drive_get_write_speed = %d  (%.1fx)\n",ret,x_speed_max);
  if(skin->verbosity>=Cdrskin_verbose_progresS) {
-   if(burn_disc_get_status(drive) == BURN_DISC_EMPTY)
-     printf("Current: none\n");
-   else if(profile_name[0])
+   if(profile_name[0])
      printf("Current: %s\n",profile_name);
    else if(burn_disc_erasable(drive))
      printf("Current: CD-RW\n");
@@ -5543,9 +5460,6 @@ int Cdrskin_atip(struct CdrskiN *skin, int flag)
    Cdrskin_print_all_profiles(skin, drive, 0);
  }
 
- if(burn_disc_get_status(drive) == BURN_DISC_EMPTY)
-   {ret= 0; goto ex;}
-
  if(strstr(profile_name,"DVD")==profile_name) {
    /* These are dummy messages for project scdbackup, so its media recognition
       gets a hint that the media is suitable and not in need of blanking.
@@ -5668,7 +5582,7 @@ ex:;
 int Cdrskin_list_formats(struct CdrskiN *skin, int flag)
 {
  struct burn_drive *drive;
- int ret, i, status, num_formats, profile_no, type, alloc_blocks, free_blocks;
+ int ret, i, status, num_formats, profile_no, type;
  off_t size;
  unsigned dummy;
  char status_text[80], profile_name[90];
@@ -5715,10 +5629,6 @@ int Cdrskin_list_formats(struct CdrskiN *skin, int flag)
  } else
    sprintf(status_text, "illegal status according to MMC-5");
  printf("Format status: %s\n", status_text);
- ret= burn_disc_get_bd_spare_info(drive, &alloc_blocks, &free_blocks, 0);
- if(ret == 1)
-   printf("BD Spare Area: %d blocks consumed, %d blocks available\n",
-          alloc_blocks - free_blocks, free_blocks);
 
  for (i = 0; i < num_formats; i++) {
    ret= burn_disc_get_format_descr(drive, i, &type, &size, &dummy);
@@ -6123,8 +6033,6 @@ ex:;
  skin->drive_is_busy= 0;
  if(skin->drive_is_grabbed)
    Cdrskin_release_drive(skin,0);
- if(Cdrskin__is_aborting(0))
-   Cdrskin_abort(skin, 0); /* Never comes back */
  return(ret);
 }
 
@@ -6178,9 +6086,6 @@ int Cdrskin_burn_pacifier(struct CdrskiN *skin,
  /* for debugging */
  static double last_fifo_in= 0.0,last_fifo_out= 0.0,curr_fifo_in,curr_fifo_out;
 
- if(Cdrskin__is_aborting(0))
-   Cdrskin_abort(skin, 0); /* Never comes back */
-
  current_time= Sfile_microtime(0);
  elapsed_total_time= current_time-start_time;
  elapsed_time= current_time-*last_time;
@@ -6504,7 +6409,7 @@ int Cdrskin_activate_write_mode(struct CdrskiN *skin,
                                 struct burn_disc *disc,
                                 int flag)
 {
- int profile_number= -1, ret, was_still_default= 0;
+ int profile_number= -1, current_is_cd= 1, ret, was_still_default= 0;
  char profile_name[80], reasons[BURN_REASONS_LEN];
  enum burn_disc_status s= BURN_DISC_UNGRABBED;
  enum burn_write_types wt;
@@ -6514,6 +6419,8 @@ int Cdrskin_activate_write_mode(struct CdrskiN *skin,
    burn_disc_get_profile(skin->grabbed_drive,&profile_number,profile_name);
    s= burn_disc_get_status(skin->grabbed_drive);
  }
+ if(profile_number!=0x09 && profile_number!=0x0a)
+   current_is_cd= 0;
  if(strcmp(skin->preskin->write_mode_name,"DEFAULT")==0) {
    was_still_default= 1;
    wt= burn_write_opts_auto_write_type(opts, disc, reasons, 0);
@@ -6928,7 +6835,7 @@ int Cdrskin_direct_write(struct CdrskiN *skin, int flag)
    if(ret<=0)
      goto ex;
  }
- buf= calloc(1, max_chunksize);
+ buf= malloc(max_chunksize);
  if(buf==NULL) {
    fprintf(stderr,
            "cdrskin: FATAL : Cannot allocate %d bytes of read buffer.\n",
@@ -7009,8 +6916,7 @@ ex:;
 int Cdrskin_grow_overwriteable_iso(struct CdrskiN *skin, int flag)
 {
  int ret, i, went_well= 1;
- char *track_descr, *md;
- unsigned char *td; /* Because the representation of 255 in char is ambigous */
+ char *track_descr,*td,*md;
  double track_size, media_size;
 
  ret= Cdrtrack_get_iso_fs_descr(skin->tracklist[0],&track_descr,&track_size,0);
@@ -7045,12 +6951,12 @@ int Cdrskin_grow_overwriteable_iso(struct CdrskiN *skin, int flag)
  /* Copy type 255 CD001 descriptors from track to media descriptor buffer
     and adjust their size entries */
  for(i=1; i<16; i++) {
-   td= (unsigned char *) (track_descr + i * 2048);
+   td= track_descr+i*2048;
    md= skin->overwriteable_iso_head+(16+i)*2048;
-   if(td[0] != 255)
+   if(td[0] != -1)
  break;
    /* demand media descrN[0] == track descrN[0] */
-   if(((char *) td)[0] != md[0]) {
+   if(td[0] != md[0]) {
      fprintf(stderr,
    "cdrskin: SORRY : Type mismatch of ISO volume descriptor #%d (%u <-> %u)\n",
              i, ((unsigned int) td[0]) & 0xff, ((unsigned int) md[0])&0xff);
@@ -7104,10 +7010,6 @@ int Cdrskin_burn(struct CdrskiN *skin, int flag)
  double put_counter, get_counter, empty_counter, full_counter;
  int total_min_fill, fifo_percent;
 #endif
-#ifdef Cdrskin_libburn_has_get_spacE
- off_t free_space;
- char msg[80];
-#endif
 
  if(skin->tell_media_space)
    doing= "estimating";
@@ -7351,12 +7253,17 @@ burn_failed:;
    /* write capacity estimation and return without actual burning */
 
 #ifdef Cdrskin_libburn_has_get_spacE
-   free_space= burn_disc_available_space(drive,o);
-   sprintf(msg,"%d\n",(int) (free_space/(off_t) 2048));
-   if(skin->preskin->result_fd>=0) {
-     write(skin->preskin->result_fd,msg,strlen(msg));
-   } else
-     printf("%s",msg);
+   {
+     off_t free_space;
+     char msg[80];
+
+     free_space= burn_disc_available_space(drive,o);
+     sprintf(msg,"%d\n",(int) (free_space/(off_t) 2048));
+     if(skin->preskin->result_fd>=0) {
+       write(skin->preskin->result_fd,msg,strlen(msg));
+     } else
+       printf("%s",msg);
+   }
 #endif /* Cdrskin_libburn_has_get_spacE */
 
    if(skin->track_counter>0)
@@ -7366,23 +7273,6 @@ burn_failed:;
    {ret= 1; goto ex;}
  }
 
-
-#ifdef Cdrskin_libburn_has_get_spacE
- if(skin->fixed_size > 0 && !skin->force_is_set) {
-   free_space= burn_disc_available_space(drive,o);
-   if(skin->fixed_size > free_space && free_space > 0) {
-     fprintf(stderr,
- "cdrskin: FATAL : predicted session size %lus does not fit on media (%lus)\n",
-             (unsigned long) ((skin->fixed_size + 2047.0) / 2048.0),
-             (unsigned long) ((free_space + 2047) / 2048));
-     ClN(fprintf(stderr,
-              "cdrskin: HINT : This test may be disabled by option -force\n");)
-     {ret= 0; goto ex;}
-   }
- }
-#endif /* Cdrskin_libburn_has_get_spacE */
-
-
  Cdrskin_adjust_speed(skin,0);
 
 #ifndef Cdrskin_extra_leaN
@@ -7404,8 +7294,7 @@ fifo_filling_failed:;
  skin->drive_is_busy= 1;
  burn_disc_write(o, disc);
  if(skin->preskin->abort_handler==-1)
-   Cleanup_set_handlers(Cleanup_handler_handlE, Cleanup_handler_funC,
-                        Cleanup_handler_flaG);
+   Cleanup_set_handlers(skin,(Cleanup_app_handler_T) Cdrskin_abort_handler,4);
  last_time= start_time= Sfile_microtime(0);
 
  burn_write_opts_free(o);
@@ -7424,7 +7313,7 @@ fifo_filling_failed:;
 
    /* >>> how do i learn about success or failure ? */
 
-   if(loop_counter>0 || Cdrskin__is_aborting(0))
+   if(loop_counter>0)
      Cdrskin_burn_pacifier(skin,drive_status,&p,start_time,&last_time,
                            &total_count,&last_count,&min_buffer_fill,0);
 
@@ -7498,9 +7387,6 @@ fifo_filling_failed:;
  if(skin->verbosity>=Cdrskin_verbose_progresS)
    printf("\n");
 
- if(Cdrskin__is_aborting(0))
-   Cdrskin_abort(skin, 0); /* Never comes back */
-
 #ifdef Cdrskin_libburn_has_wrote_welL
  wrote_well = burn_drive_wrote_well(drive);
 #endif
@@ -7785,7 +7671,7 @@ int Cdrskin_eject(struct CdrskiN *skin, int flag)
  if(!skin->do_eject)
    return(1);
 
- if((int) skin->n_drives <= skin->driveno || skin->driveno < 0)
+ if(skin->n_drives<=skin->driveno || skin->driveno < 0)
    return(2);
 
  /* ??? A61012 : retry loop might now be obsolete 
@@ -7879,7 +7765,7 @@ sorry_failed_to_eject:;
 */
 int Cdrskin_setup(struct CdrskiN *skin, int argc, char **argv, int flag)
 {
- int i,k,l,ret, idx= -1;
+ int i,k,l,ret,source_has_size=0, idx= -1;
  double value,grab_and_wait_value= -1.0, num;
  char *cpt,*value_pt,adr[Cdrskin_adrleN],*blank_mode= "";
  struct stat stbuf;
@@ -8147,9 +8033,6 @@ option_data:;
    } else if(strcmp(argv[i],"--devices")==0) {
      skin->do_devices= 1;
 
-   } else if(strcmp(argv[i],"--device_links")==0) {
-     skin->do_devices= 2;
-
 #ifndef Cdrskin_extra_leaN
 
    } else if(strncmp(argv[i],"dev_translation=",16)==0) {
@@ -8408,8 +8291,10 @@ gracetime_equals:;
      skin->preskin->demands_cdrskin_caps= 1;
 
    } else if(strcmp(argv[i],"--list_ignored_options")==0) {
+     char line[80];
      /* is also handled in Cdrpreskin_setup() */;
 
+     line[0]= 0;
      printf("cdrskin: List of all ignored options:\n");
      for(k=0;ignored_partial_options[k][0]!=0;k++)
        printf("%s\n",ignored_partial_options[k]);
@@ -8789,6 +8674,7 @@ track_too_large:;
                (int) sizeof(skin->source_path)-1,(int) strlen(argv[i]));
        return(0);
      }
+     source_has_size= 0;
      strcpy(skin->source_path,argv[i]);
      if(strcmp(skin->source_path,"-")==0) {
        if(skin->stdin_source_used) {
@@ -8811,7 +8697,7 @@ track_too_large:;
      } else {
        if(stat(skin->source_path,&stbuf)!=-1) {
          if((stbuf.st_mode&S_IFMT)==S_IFREG)
-           ;
+           source_has_size= 1;
          else if((stbuf.st_mode&S_IFMT)==S_IFDIR) {
            fprintf(stderr,
                    "cdrskin: FATAL : Source address is a directory: '%s'\n",
@@ -8999,11 +8885,9 @@ int Cdrskin_create(struct CdrskiN **o, struct CdrpreskiN **preskin,
  *o= skin;
  if(skin->preskin->abort_handler==1 || skin->preskin->abort_handler==3 || 
     skin->preskin->abort_handler==4)
-   Cleanup_set_handlers(Cleanup_handler_handlE, Cleanup_handler_funC,
-                        Cleanup_handler_flaG);
+   Cleanup_set_handlers(skin,(Cleanup_app_handler_T) Cdrskin_abort_handler,4);
  else if(skin->preskin->abort_handler==2)
-   Cleanup_set_handlers(Cleanup_handler_handlE, Cleanup_handler_funC,
-                        2 | 8);
+   Cleanup_set_handlers(skin,(Cleanup_app_handler_T) Cdrskin_abort_handler,2|8);
 
  printf("cdrskin: scanning for devices ...\n");
  fflush(stdout);
@@ -9079,28 +8963,21 @@ int Cdrskin_run(struct CdrskiN *skin, int *exit_value, int flag)
  if(skin->do_devices) {
    if(skin->n_drives<=0 && skin->preskin->scan_demands_drive)
      {*exit_value= 4; goto no_drive;}
-   if(Cdrskin__is_aborting(0))
-     goto ex;
-   ret= Cdrskin_scanbus(skin, 1 | (2 * (skin->do_devices == 2)));
+   ret= Cdrskin_scanbus(skin,1);
    if(ret<=0) {
      fprintf(stderr,"cdrskin: FATAL : --devices failed.\n");
      {*exit_value= 4; goto ex;}
    }
  }
-
  if(skin->do_scanbus) {
    if(skin->n_drives<=0 && skin->preskin->scan_demands_drive)
      {*exit_value= 5; goto no_drive;}
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_scanbus(skin,0);
    if(ret<=0)
      fprintf(stderr,"cdrskin: FATAL : -scanbus failed.\n");
    {*exit_value= 5*(ret<=0); goto ex;}
  }
  if(skin->do_load) {
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_grab_drive(skin,8);
    if(ret>0) {
      if(skin->do_load==2 && !skin->do_eject) {
@@ -9116,16 +8993,12 @@ int Cdrskin_run(struct CdrskiN *skin, int *exit_value, int flag)
    {*exit_value= 14*(ret<=0); goto ex;}
  }
  if(skin->do_checkdrive) {
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_checkdrive(skin,"",(skin->do_checkdrive==2)<<1);
    {*exit_value= 6*(ret<=0); goto ex;}
  }
  if(skin->do_msinfo) {
    if(skin->n_drives<=0)
      {*exit_value= 12; goto no_drive;}
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_msinfo(skin,0);
    if(ret<=0)
      {*exit_value= 12; goto ex;}
@@ -9133,8 +9006,6 @@ int Cdrskin_run(struct CdrskiN *skin, int *exit_value, int flag)
  if(skin->do_atip) {
    if(skin->n_drives<=0)
      {*exit_value= 7; goto no_drive;}
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_atip(skin, skin->do_atip == 4 ? 4 :
                                 (skin->do_atip>1) | (2 * (skin->do_atip > 2)));
    if(ret<=0)
@@ -9143,8 +9014,6 @@ int Cdrskin_run(struct CdrskiN *skin, int *exit_value, int flag)
  if(skin->do_list_formats) {
    if(skin->n_drives<=0)
      {*exit_value= 14; goto no_drive;}
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_list_formats(skin, 0);
    if(ret<=0)
      {*exit_value= 14; goto ex;}
@@ -9152,8 +9021,6 @@ int Cdrskin_run(struct CdrskiN *skin, int *exit_value, int flag)
  if(skin->do_blank) {
    if(skin->n_drives<=0)
      {*exit_value= 8; goto no_drive;}
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_blank(skin,0);
    if(ret<=0)
      {*exit_value= 8; goto ex;}
@@ -9162,8 +9029,6 @@ int Cdrskin_run(struct CdrskiN *skin, int *exit_value, int flag)
 #ifdef Cdrskin_libburn_has_random_access_rW
  if(skin->do_direct_write) {
    skin->do_burn= 0;
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_direct_write(skin,0);
    if(ret<=0)
      {*exit_value= 13; goto ex;}
@@ -9173,15 +9038,11 @@ int Cdrskin_run(struct CdrskiN *skin, int *exit_value, int flag)
  if(skin->do_burn || skin->tell_media_space) {
    if(skin->n_drives<=0)
      {*exit_value= 10; goto no_drive;}
-   if(Cdrskin__is_aborting(0))
-     goto ex;
    ret= Cdrskin_burn(skin,0);
    if(ret<=0)
      {*exit_value= 10; goto ex;}
  }
 ex:;
- if(Cdrskin__is_aborting(0))
-   Cdrskin_abort(skin, 0); /* Never comes back */
  return((*exit_value)==0);
 no_drive:;
  fprintf(stderr,"cdrskin: FATAL : This run would need an accessible drive\n");
@@ -9229,7 +9090,7 @@ int main(int argc, char **argv)
        messaging need libburn running */
  ret= Cdrpreskin_initialize_lib(preskin,0);
  if(ret<=0) {
-   fprintf(stderr,"cdrskin: FATAL : Initialization of burn library failed\n");
+   fprintf(stderr,"cdrskin: FATAL : Initializiation of burn library failed\n");
    {exit_value= 2; goto ex;}
  }
  lib_initialized= 1;
@@ -9269,13 +9130,9 @@ int main(int argc, char **argv)
 #endif
  }
 
- if(!Cdrskin__is_aborting(0))
-   Cdrskin_run(skin,&exit_value,0);
+ Cdrskin_run(skin,&exit_value,0);
 
 ex:;
- if(Cdrskin__is_aborting(0))
-   Cdrskin_abort(skin, 0); /* Never comes back */
-
  if(preskin!=NULL)
    h_preskin= preskin;
  else if(skin!=NULL)

cdrskin/cdrskin_eng.html

@@ -2,7 +2,7 @@
 
 <HEAD>
 <META NAME="description" CONTENT="cdrskin, a limited cdrecord compatibility wrapper for libburn">
-<META NAME="keywords" CONTENT="cdrskin, libburn, libburnia, burn, CD, DVD, BD, linux, recording, burning, CD-R, CD-RW, DVD-R, DVD-R DL, DVD-RW, DVD+RW, DVD+R, DVD+R DL, DVD-RAM, BD-RE, BD-R, cdrecord, compatible, scdbackup">
+<META NAME="keywords" CONTENT="cdrskin, libburn, libburnia, burn, CD, DVD, linux, recording, burning, CD-R, CD-RW, DVD-R, DVD-RW, DVD+RW, DVD+R, DVD+R/DL, DVD-RAM, BD-RE, BD-R, cdrecord, compatible, scdbackup">
 <META NAME="robots" CONTENT="follow">
 <TITLE>cdrskin homepage english</TITLE>
 </HEAD>
@@ -24,8 +24,7 @@
 <P>
 <H2>Purpose:</H2>
 Burns preformatted data to CD, DVD, and BD media:<BR>
-CD-R, DVD-R, DVD-R DL, DVD+R, DVD+R DL, BD-R, CD-RW,
-DVD-RW, DVD-RAM, DVD+RW, BD-RE
+CD-R, DVD-R, DVD+R, DVD+R/DL, BD-R, CD-RW, DVD-RW, DVD-RAM, DVD+RW, BD-RE
 </P>
 <P>
 
@@ -39,8 +38,8 @@ About any CD, DVD, or BD recorder produced in the recent ten years.
 <BR>
 <A HREF="http://libburnia-project.org">libburn</A>
 supports recorders which are compliant to standards MMC-1 for CD and
-MMC-5 for DVD or BD. Linux, FreeBSD, and Solaris allow to access drives
-connected via SCSI, PATA (aka IDE, ATA), USB, or SATA.
+MMC-5 for DVD or BD. Linux and FreeBSD allow to access drives connected
+via SCSI, PATA (aka IDE, ATA), USB, or SATA.
 <BR>
 </P>
 
@@ -53,8 +52,6 @@ connected via SCSI, PATA (aka IDE, ATA), USB, or SATA.
 <DT>or FreeBSD (with libc, of course) :</DT>
 <DD>ATA and SATA drives need atapicam running.</DD>
 <DD>libcam has to be installed.</DD>
-<DT>or Solaris (with libc, of course) :</DT>
-<DD>Tested on kernel 5.11, hopefully suitable for older ones too.</DD>
 <DT>libpthread</DT>
 <DD>is supposed to be a standard system component.</DD>
 </DL>
@@ -65,7 +62,7 @@ connected via SCSI, PATA (aka IDE, ATA), USB, or SATA.
 GPL software included:<BR>
 </H2>
 <DL>
-<DT>libburn-1.1.6</DT>
+<DT>libburn-0.7.6</DT>
 <DD>(founded by Derek Foreman and Ben Jansens,
 developed and maintained since August 2006 by
 Thomas Schmitt from team of libburnia-project.org)
@@ -75,8 +72,8 @@ Thomas Schmitt from team of libburnia-project.org)
 </P>
 
 <P>
-This program system has been tested on Intel/AMD with Linux, FreeBSD,
-and OpenSolaris based operating systems.<BR>
+This program system has been tested on Intel/AMD Linux and FreeBSD systems
+only.<BR>
 Ports to other usable systems are appreciated. Reports are welcome.
 </P>
 
@@ -96,11 +93,10 @@ Ports to other usable systems are appreciated. Reports are welcome.
 <DL>
 <DT>The most common options of cdrecord for data and audio on CD media
 are provided in a compatible way.<BR>
-On all DVD media, cdrskin is able to perform any recording job
+On all DVD media except DVD-R DL, cdrskin is able to perform any recording job
 which is possible with cdrecord.
 Other than with cdrecord, option -multi is supported with many DVD types and
-BD-R. Write mode -tao works with anything but quickly blanked DVD-RW and
-DVD-R DL, which both support no -multi.
+BD-R. Write mode -tao works with anything but quickly blanked DVD-RW.
 </DT>
 <BR><BR>
 <DT>Get an overview of drives and their addresses</DT>
@@ -109,9 +105,8 @@ DVD-R DL, which both support no -multi.
 <DD>#<KBD>&nbsp;cdrskin --devices</KBD></DD>
 <DT>Being superuser avoids permission problems with /dev/srN resp. /dev/hdX .
 </DT>
-<DT>Ordinary users should then get granted access to the /dev files
-as listed by option --devices. Linux and FreeBSD demand rw-permission.
-On Solaris it is r-permission and privileges "basic,sys_devices".</DT>
+<DT>Ordinary users should then get granted rw access to the /dev files
+as listed by option --devices.</DT>
 <DT>&nbsp;</DT>
 
 <DT>Get info about a particular drive or loaded media:</DT>
@@ -133,8 +128,7 @@ On Solaris it is r-permission and privileges "basic,sys_devices".</DT>
 <DD>$<KBD>&nbsp;cdrskin -v dev=/dev/hdc speed=12 fs=8m \</KBD></DD>
 <DD><KBD>&nbsp;&nbsp;blank=as_needed -eject padsize=300k my_image.iso</KBD></DD>
 
-<DT>Write compressed afio archive on-the-fly
-(not DVD-R DL or minimally blanked DVD-RW):</DT>
+<DT>Write compressed afio archive on-the-fly:</DT>
 <DD>$<KBD>&nbsp;find . | afio -oZ - | \</KBD></DD>
 <DD><KBD>&nbsp;&nbsp;cdrskin -v dev=0,1,0 fs=32m speed=8 \</KBD></DD>
 <DD><KBD>&nbsp;&nbsp;blank=as_needed padsize=300k -</KBD></DD>
@@ -200,15 +194,8 @@ Standalone ISO 9660 multi-session CD/DVD/BD tool
 <P>
 <DL>
 <DT>Download as source code (see README):</DT>
-<DD><A HREF="cdrskin-1.1.6.tar.gz">cdrskin-1.1.6.tar.gz</A>
-(870 KB).
-</DD>
-<DD><A HREF="cdrskin-1.1.6.tar.gz.sig">cdrskin-1.1.6.tar.gz.sig</A></DD>
-<DD>
-(detached GPG signature for verification by
-<KBD>gpg --verify cdrskin-1.1.6.tar.gz.sig cdrskin-1.1.6.tar.gz</KBD>
-<BR>
-after <KBD>gpg --keyserver keys.gnupg.net --recv-keys ABC0A854</KBD>).
+<DD><A HREF="cdrskin-0.7.6.pl00.tar.gz">cdrskin-0.7.6.pl00.tar.gz</A>
+(810 KB).
 </DD>
 <DD>
 The cdrskin tarballs are source code identical with libburn releases
@@ -257,23 +244,22 @@ cdrskin_0.4.2.pl00-x86-suse9_0-static.tar.gz</A>, (310 KB), -static compiled,
 <HR>
 
 <P>
-Enhancements towards previous stable version cdrskin-1.1.4:
+Enhancements towards previous stable version cdrskin-0.7.4.pl00:
 <UL>
 <LI>
-Worked around a collision with Linux udev which lets links vanish
+Made FreeBSD system adapter safe from mutal burn spoiling and drive deadlock
 </LI>
+<LI>Experimental system adapter via GNU libcdio on X/Open systems</LI>
+<LI>Experimentally using FreeBSD system adapter for Debian kfreebsd</LI>
 <!--
 <LI>none</LI>
 -->
 </UL>
 
-Bug fixes towards cdrskin-1.1.4:
+Bug fixes towards cdrskin-0.7.4.pl00:
 <UL>
-<LI>
-stdio sizes > 4 TB - 32 kB caused integer rollover
-</LI>
-<!--
 <LI>none</LI>
+<!--
 -->
 </UL>
 
@@ -281,31 +267,29 @@ stdio sizes > 4 TB - 32 kB caused integer rollover
 
 <P>
 <DL>
-<DT><H3>Development snapshot, version 1.1.7 :</H3></DT>
-<DD>Enhancements towards current stable version 1.1.6:
+<DT><H3>Development snapshot, version 0.7.7 :</H3></DT>
+<DD>Enhancements towards current stable version 0.7.6.pl00:
 <UL>
 <LI>none yet</LI>
 <!--
-<LI>none yet</LI>
 -->
 
 </UL>
 </DD>
 
-<DD>Bug fixes towards cdrskin-1.1.6:
+<DD>Bug fixes towards cdrskin-0.7.6.pl00:
 <UL>
 <LI>none yet</LI>
 <!--
-<LI>none yet</LI>
 -->
 </UL>
 </DD>
 
 <DD>&nbsp;</DD>
-<DD><A HREF="README_cdrskin_devel">README 1.1.7</A>
-<DD><A HREF="cdrskin__help_devel">cdrskin-1.1.7 --help</A></DD>
-<DD><A HREF="cdrskin_help_devel">cdrskin-1.1.7 -help</A></DD>
-<DD><A HREF="man_1_cdrskin_devel.html">man cdrskin (as of 1.1.7)</A></DD>
+<DD><A HREF="README_cdrskin_devel">README 0.7.7</A>
+<DD><A HREF="cdrskin__help_devel">cdrskin_0.7.7 --help</A></DD>
+<DD><A HREF="cdrskin_help_devel">cdrskin_0.7.7 -help</A></DD>
+<DD><A HREF="man_1_cdrskin_devel.html">man cdrskin (as of 0.7.7)</A></DD>
 <DD>&nbsp;</DD>
 <DT>Maintainers of cdrskin unstable packages please use SVN of
 <A HREF="http://libburnia-project.org"> libburnia-project.org</A></DT>
@@ -325,8 +309,8 @@ admins with full system souvereignty.</DT>
 <A HREF="README_cdrskin_devel">upcoming README</A> ):
 </DD>
 <DD>
-<A HREF="cdrskin-1.1.7.tar.gz">cdrskin-1.1.7.tar.gz</A>
-(870 KB).
+<A HREF="cdrskin-0.7.7.tar.gz">cdrskin-0.7.7.tar.gz</A>
+(810 KB).
 </DD>
 
 <!-- This is not offered any more since spring 2008
@@ -475,11 +459,10 @@ First of all: this relationship is single sided, as cdrskin has to be aware of
 cdrecord but not vice versa.
 <BR>
 <BR>
-I was a long time user of cdrecord and it worked fine for me. 
+I am a long time user of cdrecord and it works fine for me. 
 Especially i do appreciate its write mode -tao which allows to pipe arbitrary
 data on CD and CD-RW via stdin. cdrecord is reliable, versatile and well
-maintained. So for me - there would be no problem with using it for
-burning CDs.
+maintained. So for me - there would be no problem with it.
 <BR>
 But the author of cdrecord and the Linux kernel people foster a very hostile 
 relationship. Ok, that's their business, not mine (or ours if you are with me).

cdrskin/cdrskin_timestamp.h

@@ -1 +1 @@
-#define Cdrskin_timestamP "2011.09.27.060001"
+#define Cdrskin_timestamP "2010.01.22.130001"

cdrskin/cleanup.c

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

cdrskin/compile_cdrskin.sh

@@ -1,14 +1,14 @@
 #!/bin/sh
 
 # compile_cdrskin.sh  
-# Copyright 2005 - 2011 Thomas Schmitt, scdbackup@gmx.net, GPL
+# Copyright 2005 - 2010 Thomas Schmitt, scdbackup@gmx.net, GPL
 # to be executed within  ./libburn-*  resp ./cdrskin-*
 
 debug_opts="-O2"
 def_opts=
 largefile_opts="-D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1"
-fifo_opts=""
-libvers="-DCdrskin_libburn_1_1_6"
+fifo_opts="-DCdrskin_use_libburn_fifO"
+libvers="-DCdrskin_libburn_0_7_6"
 
 # To be used if Makefile.am uses libburn_libburn_la_CFLAGS
 # burn="libburn/libburn_libburn_la-"
@@ -19,20 +19,13 @@ libdax_msgs_o="$burn"libdax_msgs.o
 libdax_audioxtr_o="$burn"libdax_audioxtr.o
 do_strip=0
 static_opts=
-warn_opts="-Wall -Wextra -Wno-unused-parameter"
+warn_opts="-Wall"
 libcdio=
 fifo_source="cdrskin/cdrfifo.c"
 compile_cdrskin=1
 compile_cdrfifo=0
 compile_dewav=0
 
-libcam=
-os=$(uname -s)
-case $os in
- *FreeBSD)
-  libcam="-lcam"
-esac
-
 for i in "$@"
 do
   if test "$i" = "-compile_cdrfifo"
@@ -47,15 +40,15 @@ do
     libdax_audioxtr_o=
     libdax_msgs_o="$burn"message.o
     cleanup_src_or_obj="-DCleanup_has_no_libburn_os_H cdrskin/cleanup.c"
-  elif test "$i" = "-libburn_1_1_6"
+  elif test "$i" = "-libburn_0_7_6"
   then
-    libvers="-DCdrskin_libburn_1_1_6"
+    libvers="-DCdrskin_libburn_0_7_6"
     libdax_audioxtr_o="$burn"libdax_audioxtr.o
     libdax_msgs_o="$burn"libdax_msgs.o
     cleanup_src_or_obj="$burn"cleanup.o
   elif test "$i" = "-libburn_svn"
   then
-    libvers="-DCdrskin_libburn_1_1_7"
+    libvers="-DCdrskin_libburn_0_7_7"
     libdax_audioxtr_o="$burn"libdax_audioxtr.o
     libdax_msgs_o="$burn"libdax_msgs.o
     cleanup_src_or_obj="$burn"cleanup.o
@@ -93,10 +86,6 @@ do
   then
     fifo_source=
     fifo_opts="-DCdrskin_use_libburn_fifO -DCdrskin_no_cdrfifO"
-  elif test "$i" = "-use_libburn_cleanup"
-  then
-    fifo_source=
-    fifo_opts="-DCdrskin_use_libburn_cleanuP -DCdrskin_use_libburn_fifO -DCdrskin_no_cdrfifO"
   elif test "$i" = "-use_libcdio"
   then
     libcdio="-lcdio"
@@ -109,7 +98,7 @@ do
     echo "Options:"
     echo "  -compile_cdrfifo  compile program cdrskin/cdrfifo."
     echo "  -compile_dewav    compile program test/dewav without libburn."
-    echo "  -libburn_1_1_6    set macro to match libburn-1.1.6"
+    echo "  -libburn_0_7_6    set macro to match libburn-0.7.6"
     echo "  -libburn_svn      set macro to match current libburn-SVN."
     echo "  -dvd_obs_64k      64 KB default size for DVD/BD writing."
     echo "  -use_libcdio      link with -lcdio because libburn uses it."
@@ -136,7 +125,7 @@ echo "Build timestamp   :  $timestamp"
 
 if test "$compile_cdrskin"
 then
-  echo "compiling program cdrskin/cdrskin.c $fifo_source $static_opts $debug_opts $libvers $fifo_opts $def_opts $cleanup_src_or_obj $libcdio $libcam"
+  echo "compiling program cdrskin/cdrskin.c $fifo_source $static_opts $debug_opts $libvers $fifo_opts $def_opts $cleanup_src_or_obj $libcdio"
   cc -I. \
     $warn_opts \
     $static_opts \
@@ -182,7 +171,6 @@ then
     "$burn"ecma130ab.o \
     \
     $libcdio \
-    $libcam \
     -lpthread
 
     ret=$?

configure.ac

@@ -1,16 +1,13 @@
-AC_INIT([libburn], [1.1.6], [http://libburnia-project.org])
+AC_INIT([libburn], [0.7.6], [http://libburnia-project.org])
 AC_PREREQ([2.50])
 dnl AC_CONFIG_HEADER([config.h])	
 
 AC_CANONICAL_HOST
 AC_CANONICAL_TARGET
 
-LIBBURNIA_SET_FLAGS
-
 AM_INIT_AUTOMAKE([subdir-objects])
-AC_CONFIG_MACRO_DIR([./])
 
-dnl Notes by ts A71207 - B10409 :
+dnl Notes by ts A71207 - B00122 :
 dnl
 dnl Regrettably the meaning of the various version types was misunderstood
 dnl before version 0.4.1.
@@ -80,20 +77,6 @@ dnl    0.7.0 = libburn.so.4.35.0
 dnl    0.7.2 = libburn.so.4.37.0
 dnl    0.7.4 = libburn.so.4.39.0
 dnl    0.7.6 = libburn.so.4.41.0
-dnl    0.7.8 = libburn.so.4.43.0
-dnl    0.8.0 = libburn.so.4.45.0
-dnl    0.8.2 = libburn.so.4.47.0
-dnl    0.8.4 = libburn.so.4.49.0
-dnl    0.8.6 = libburn.so.4.51.0
-dnl    0.8.8 = libburn.so.4.53.0
-dnl    0.9.0 = libburn.so.4.55.0
-dnl    1.0.0 = libburn.so.4.57.0
-dnl    1.0.2 = libburn.so.4.59.0
-dnl    1.0.4 = libburn.so.4.61.0
-dnl    1.0.6 = libburn.so.4.63.0
-dnl    1.1.0 = libburn.so.4.65.0
-dnl    1.1.4 = libburn.so.4.67.0
-dnl    1.1.6 = libburn.so.4.69.0
 dnl
 dnl So LT_CURRENT, LT_REVISION and LT_AGE get set directly here.
 dnl SONAME of the emerging library is  LT_CURRENT - LT_AGE.
@@ -117,8 +100,8 @@ dnl
 dnl If BURN_*_VERSION changes, be sure to change AC_INIT above to match.
 dnl
 dnl As said: Only copies. Original in libburn/libburn.h : burn_header_version_*
-BURN_MAJOR_VERSION=1
-BURN_MINOR_VERSION=1
+BURN_MAJOR_VERSION=0
+BURN_MINOR_VERSION=7
 BURN_MICRO_VERSION=6
 BURN_VERSION=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION.$BURN_MICRO_VERSION
 
@@ -130,14 +113,15 @@ AC_SUBST(BURN_VERSION)
 dnl Libtool versioning
 LT_RELEASE=$BURN_MAJOR_VERSION.$BURN_MINOR_VERSION.$BURN_MICRO_VERSION
 dnl
-dnl This is the release version libburn-1.1.6
+dnl ts B00122
+dnl This is the release version libburn-0.7.6 = libburn.so.4.41.0
 dnl ### This is the development version after above release version
 dnl LT_CURRENT++, LT_AGE++ has not yet happened.
 dnl ### LT_CURRENT++, LT_AGE++ has happened meanwhile.
 dnl
-dnl SONAME = 73 - 69 = 4 . Linux library name = libburn.so.4.69.0
-LT_CURRENT=73
-LT_AGE=69
+dnl SONAME = 45 - 41 = 4 . Linux library name = libburn.so.4.41.0
+LT_CURRENT=45
+LT_AGE=41
 LT_REVISION=0
 LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
 
@@ -195,11 +179,11 @@ AC_CHECK_HEADER(sys/statvfs.h, X=, STATVFS_DEF=)
 AC_CHECK_FUNC([statvfs], X=, STATVFS_DEF=)
 dnl If this would be done more specifically in Makefile.am
 dnl via libburn_libburn_la_CFLAGS then undesired .o file names would emerge
-CFLAGS="$STATVFS_DEF $CFLAGS"
+CFLAGS="$CFLAGS $STATVFS_DEF"
 
 dnl ts A91122
 AC_ARG_ENABLE(track-src-odirect,
-[  --enable-track-src-odirect Enable use of O_DIRECT with track input, default=no],
+[  --enable-track-src-odirect   Enable use of O_DIRECT with track input, default=no],
                , enable_track_src_odirect=no)
 if test x$enable_track_src_odirect = xyes; then
     LIBBURN_O_DIRECT_DEF="-DLibburn_read_o_direcT"
@@ -210,12 +194,12 @@ else
 fi
 dnl Avoid the need for libburn_libburn_la_CFLAGS in Makefile.am (ugly .o names)
 dnl ### AC_SUBST(LIBBURN_O_DIRECT_DEF)
-CFLAGS="$LIBBURN_O_DIRECT_DEF $CFLAGS"
+CFLAGS="$CFLAGS $LIBBURN_O_DIRECT_DEF"
 
 dnl ts A91116
 AC_ARG_ENABLE(dvd-obs-64k,
-[  --enable-dvd-obs-64k    64 KB default size for DVD/BD writing, default=no],
-               , enable_dvd_obs_64k=no)
+[  --enable-dvd-obs-64k         64 KB default size for DVD/BD writing, default=no],
+               , enable_fifo_odirect=no)
 if test x$enable_dvd_obs_64k = xyes; then
     LIBBURN_DVD_OBS_64K="-DLibburn_dvd_obs_default_64K"
     echo "enabled  write size default 64 KB on DVD and BD"
@@ -223,11 +207,11 @@ else
     LIBBURN_DVD_OBS_64K=
     echo "disabled write size default 64 KB on DVD and BD"
 fi
-CFLAGS="$LIBBURN_DVD_OBS_64K $CFLAGS"
+CFLAGS="$CFLAGS $LIBBURN_DVD_OBS_64K"
 
 dnl ts A91218
 AC_ARG_ENABLE(libcdio,
-[  --enable-libcdio        Enable EXPERIMENTAL use of libcdio as system adapter, default=no],
+[  --enable-libcdio         Enable EXPERIMENTAL use of libcdio as system adapter, default=no],
                , enable_libcdio=no)
 if test x$enable_libcdio = xyes; then
 dnl Check whether there is libcdio-devel and libcdio-runtime.
@@ -246,45 +230,13 @@ then
     fi
 else
     echo "enabled  EXPERIMENTAL use of libcdio as system adapter"
-    CFLAGS="$LIBCDIO_DEF $CFLAGS"
+    CFLAGS="$CFLAGS $LIBCDIO_DEF"
 
     LIBCDIO_REQUIRED=0.83
     PKG_CHECK_MODULES(LIBCDIO, libcdio >= $LIBCDIO_REQUIRED)
 
 fi
 
-dnl ts B00704
-# Library versioning normally serves a complex purpose.
-# Since libburn obeys strict ABI backward compatibility, it needs only the
-# simple feature to declare function names "global:" or "local:". Only the
-# global ones are visible to applications at library load time.
-AC_ARG_ENABLE(versioned-libs,
-[  --enable-versioned-libs Enable strict symbol encapsulation , default=yes],
-               , enable_versioned_libs=yes)
-if test x$enable_versioned_libs = xyes; then
-    vers_libs_test=no
-    LIBBURN_ASSERT_VERS_LIBS
-    if test x$vers_libs_test = xno
-    then 
-        echo "disabled strict symbol encapsulation (test failed)"
-    else
-        echo "enabled  strict symbol encapsulation"
-    fi
-else
-    echo "disabled strict symbol encapsulation"
-fi
-
-AC_ARG_ENABLE(ldconfig-at-install,
-[  --enable-ldconfig-at-install    On GNU/Linux run ldconfig, default=yes],
-               , ldconfig_at_install=yes)
-if test x$ldconfig_at_install = xyes; then 
-    dummy=dummy
-else
-    LIBBURNIA_LDCONFIG_CMD="echo 'NOTE: ldconfig is disabled. If needed, configure manually for:'"
-    echo "disabled run of ldconfig during installation on GNU/Linux"
-fi  
-AC_SUBST(LIBBURNIA_LDCONFIG_CMD)
-
 
 dnl Add compiler-specific flags
 
@@ -294,15 +246,15 @@ AC_ARG_ENABLE(debug,
               , enable_debug=yes)
 if test x$enable_debug != xyes; then
     if test x$GCC = xyes; then
-        CFLAGS="-O3 $CFLAGS"
-        CFLAGS="-fexpensive-optimizations $CFLAGS"
+        CFLAGS="$CFLAGS -O3"
+        CFLAGS="$CFLAGS -fexpensive-optimizations"
     fi
-    CFLAGS="-DNDEBUG $CFLAGS"
+    CFLAGS="$CFLAGS -DNDEBUG"
 else
     if test x$GCC = xyes; then
-        CFLAGS="-g -pedantic -Wall -Wextra -Wno-unused-parameter $CFLAGS"
+        CFLAGS="$CFLAGS -g -pedantic -Wall"
     fi
-    CFLAGS="-DDEBUG $CFLAGS"
+    CFLAGS="$CFLAGS -DDEBUG"
 fi
 
 dnl Determine target directory for libburn-*.pc

doc/comments

@@ -8,13 +8,14 @@
 Libburnia is an open-source project for reading, mastering and writing
 optical discs. This page is about its capability to handle optical media.
 For now this means CD-R, CD-RW, DVD-RAM, DVD+RW, DVD+R, DVD+R/DL, DVD-RW,
-DVD-R, DVD-R/DL, BD-R, BD-RE.
+DVD-R, BD-R, BD-RE.
 
-Our scope is currently Linux 2.4 and 2.6, or FreeBSD, or Solaris . For ports
-to other systems we would need : login on a development machine resp.
-an OS ithat is installable on an AMD 64-bit PC, advise from a system person
-about the equivalent of Linux sg or FreeBSD CAM, volunteers for testing of
-realistic use cases.
+Not supported yet are DVD-R/DL. Testers wanted.
+
+Our scope is currently Linux 2.4 and 2.6, or FreeBSD . For ports to other
+systems we would need : login on a development machine resp. a live OS on CD
+or DVD, advise from a system person about the equivalent of Linux sg or FreeBSD
+CAM, volunteers for testing of realistic use cases.
 
 libburn is the library by which preformatted data get onto optical media.
 Its code is independent of cdrecord. Its DVD capabilities are learned from

doc/cookbook.txt

@@ -1,9 +1,3 @@
-
--------------------------------------------------------------------------------
-Note: This is about how libburn operates optical drives. Not about how to
-      operate libburn. The libburn API is described in libburn/libburn.h
--------------------------------------------------------------------------------
-
 libburnia-project.org Optical Media Rotisserie Recipes as of January 2010
 
 Content:

doc/doxygen.conf.in

@@ -154,6 +154,13 @@ QT_AUTOBRIEF           = NO
 
 MULTILINE_CPP_IS_BRIEF = YES
 
+# If the DETAILS_AT_TOP tag is set to YES then Doxygen 
+# will output the detailed description near the top, like JavaDoc.
+# If set to NO, the detailed description appears after the member 
+# documentation.
+
+DETAILS_AT_TOP         = YES
+
 # If the INHERIT_DOCS tag is set to YES (the default) then an undocumented 
 # member inherits the documentation from any documented member that it 
 # re-implements.
@@ -1145,8 +1152,7 @@ HIDE_UNDOC_RELATIONS   = YES
 # toolkit from AT&T and Lucent Bell Labs. The other options in this section 
 # have no effect if this option is set to NO (the default)
 
-# ts B10415: dot causes sigsegv on Debian buildd
-HAVE_DOT               = NO
+HAVE_DOT               = YES
 
 # If the CLASS_GRAPH and HAVE_DOT tags are set to YES then doxygen 
 # will generate a graph for each documented class showing the direct and 

doc/mediainfo.txt

@@ -1,10 +1,4 @@
 
--------------------------------------------------------------------------------
-Note: This is about how libburn operates optical drives. Not about how to
-      operate libburn. The libburn API is described in libburn/libburn.h
--------------------------------------------------------------------------------
-
-
         Overview of class specific or individual media information
              especially manufacturer and exact product type
 
@@ -178,9 +172,6 @@ BD-R and BD-RE:
    Table 288 says that Media Type Code (byte 1 of CDB) for BD media is 1.
    Table 446 says that Disc Information is preceeded by 4 bytes of header.
    Table 448 says that bytes 0   to   1 are Disc Information Identifier "DI".
-                  that bytes 8   to  10 are Disc Type Identifier
-                                            BDO for BD-ROM, BDW for BD-RE,
-                                            BDR for BD-R
                   that bytes 100 to 105 are Disc Manufactuer ID
                   that bytes 106 to 108 are Media Type ID
                   that byte  111        is Product Revision Number
@@ -942,7 +933,6 @@ CMCMAG      CN2     CMC Magnetics Corporation 1-2X HTL 25GB(12cm)  [Blu]
 DAXON 016           DAXON  8X   [Hij]
 DAXON       AZ3     DAXON  16X   [Hij]
 DAXON       CY3     DAXON  12X   [Hij]
-DAXON       D42/52  (user reported DVD+RW)
 Daxon       R2X     Daxon Technology Inc.  1-2X HTL 25GB(12cm)  [Blu]
 Daxon       R4X     Daxon Technology Inc.  1-4X HTL 25GB(12cm)  [Blu]
 
@@ -1182,7 +1172,6 @@ TTH02               TDK  12X   [Hij]
 TYG01               TAIYO YUDEN  4X   [Hij]
 TYG02               TAIYO YUDEN  12X   [Hij]
 TYG03               TAIYO YUDEN  16X   [Hij]
-TYG11               TAIYO YUDEN  DVD-R DL 8x
 TYG-BD      Y01     TAIYO YUDEN Co., Ltd.  1-2X LTH   [Blu]
 TYG-BD      Y03     TAIYO YUDEN Co., Ltd.   1-4X LTH   [Blu]
 

libburn/async.c

@@ -1,9 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
 
 /* ts A71019 */
 
@@ -23,9 +19,6 @@
 #define Libburn_detach_done_workeR 1
 */
 
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
 
 #include "libburn.h"
 #include "transport.h"
@@ -43,7 +36,6 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
-#include <signal.h>
 
 /*
 #include <a ssert.h>
@@ -143,7 +135,7 @@ static void add_worker(int w_type, struct burn_drive *d,
 	pthread_attr_t attr;
 #endif
 
-	a = calloc(1, sizeof(struct w_list));
+	a = malloc(sizeof(struct w_list));
 	a->w_type = w_type;
 	a->drive = d;
 	a->u = *(union w_list_data *)data;
@@ -183,6 +175,11 @@ 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)
@@ -195,12 +192,8 @@ static void remove_worker(pthread_t th)
 			/* Alternative : threads get detached and thus should
 					dispose themselves.
 			*/
-			pthread_detach(th);
-/*
-			int ret;
-			char msg[80];
-
 			ret = pthread_detach(th);
+/*
 			sprintf(msg,
 			 "remove_workers(): pid= %lu  pthread_detach(%lu)= %d",
 			 (unsigned long) getpid(), (unsigned long) th, ret);
@@ -235,22 +228,6 @@ static void *scan_worker_func(struct w_list *w)
 	return NULL;
 }
 
-static void reset_progress(struct burn_drive *d, int sessions, int tracks,
-				int indices, int sectors, int flag)
-{
-	/* reset the progress indicator */
-	d->progress.session = 0;
-	d->progress.sessions = sessions;
-	d->progress.track = 0;
-	d->progress.tracks = tracks;
-	d->progress.index = 0;
-	d->progress.indices = indices;
-	d->progress.start_sector = 0;
-	d->progress.sectors = sectors;
-	d->progress.sector = 0;
-}
-
-
 int burn_drive_scan(struct burn_drive_info *drives[], unsigned int *n_drives)
 {
 	struct scan_opts o;
@@ -320,27 +297,8 @@ drive_is_active:;
 
 static void *erase_worker_func(struct w_list *w)
 {
-
-#define Libburn_protect_erase_threaD 1
-
-#ifdef Libburn_protect_erase_threaD
-	sigset_t sigset, oldset;
-
-	/* Protect blank thread from being interrupted by external signals */
-	sigfillset(&sigset);
-	sigdelset(&sigset, SIGSEGV);
-	sigdelset(&sigset, SIGILL);
-	pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
-#endif /* Libburn_protect_erase_threaD */
-
 	burn_disc_erase_sync(w->u.erase.drive, w->u.erase.fast);
 	remove_worker(pthread_self());
-
-#ifdef Libburn_protect_erase_threaD
-	/* (just in case it would not end with all signals blocked) */
-	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-#endif /* Libburn_protect_erase_threaD */
-
 	return NULL;
 }
 
@@ -352,9 +310,8 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 	/* a ssert(drive); */
 	/* a ssert(!SCAN_GOING()); */
 	/* a ssert(!find_worker(drive)); */
-
 	if((drive == NULL)) {
-		libdax_msgs_submit(libdax_messenger, -1,
+		libdax_msgs_submit(libdax_messenger, drive->global_index,
 			0x00020104,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			"NULL pointer caught in burn_disc_erase", 0, 0);
@@ -368,9 +325,6 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 			0, 0);
 		return;
 	}
-
-	reset_progress(drive, 1, 1, 1, 0x10000, 0);
-
 	/* A70103 : will be set to 0 by burn_disc_erase_sync() */
 	drive->cancel = 1;
 
@@ -382,9 +336,7 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 	/* ts A70909 : the willingness to burn any BURN_DISC_FULL media is
 	               inappropriate. One would rather need a -force option
 	               Note: keep this in sync with mmc_read_disc_info() */
-	/* ts B10321 : Allowed role 5 to be blanked */
-	if ((drive->drive_role == 1 &&
-	     drive->current_profile != 0x0a &&
+	if ((drive->current_profile != 0x0a &&
 	     drive->current_profile != 0x13 &&
 	     drive->current_profile != 0x14 &&
 	     drive->status != BURN_DISC_FULL)
@@ -393,7 +345,7 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 	     drive->status != BURN_DISC_APPENDABLE &&
 	     drive->status != BURN_DISC_BLANK)
 	    ||
-	    (drive->drive_role != 1 && drive->drive_role != 5)
+	    (drive->drive_role != 1)
 	   ) {
 		libdax_msgs_submit(libdax_messenger, drive->global_index,
 			0x00020130,
@@ -413,28 +365,9 @@ void burn_disc_erase(struct burn_drive *drive, int fast)
 /* ts A61230 */
 static void *format_worker_func(struct w_list *w)
 {
-
-#define Libburn_protect_format_threaD 1
-
-#ifdef Libburn_protect_format_threaD
-	sigset_t sigset, oldset;
-
-	/* Protect format thread from being interrupted by external signals */
-	sigfillset(&sigset);
-	sigdelset(&sigset, SIGSEGV);
-	sigdelset(&sigset, SIGILL);
-	pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
-#endif /* Libburn_protect_format_threaD */
-
 	burn_disc_format_sync(w->u.format.drive, w->u.format.size,
 				w->u.format.flag);
 	remove_worker(pthread_self());
-
-#ifdef Libburn_protect_format_threaD
-	/* (just in case it would not end with all signals blocked) */
-	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-#endif /* Libburn_protect_format_threaD */
-
 	return NULL;
 }
 
@@ -444,9 +377,7 @@ void burn_disc_format(struct burn_drive *drive, off_t size, int flag)
 {
 	struct format_opts o;
 	int ok = 0, ret;
-	char msg[40];
-
-	reset_progress(drive, 1, 1, 1, 0x10000, 0);
+	char msg[160];
 
 	if ((SCAN_GOING()) || find_worker(drive) != NULL) {
 		libdax_msgs_submit(libdax_messenger, drive->global_index,
@@ -518,6 +449,42 @@ void burn_disc_format(struct burn_drive *drive, off_t size, int flag)
 			return;
 
 		} 
+		if ((flag & 6) != 6 || (flag & 128)) {
+		    if ((flag & 64) && !(drive->current_feat23h_byte4 & 2)) {
+			if (drive->current_feat23h_byte4 & 1) {
+				libdax_msgs_submit(libdax_messenger,
+					drive->global_index, 0x00020165,
+				   	LIBDAX_MSGS_SEV_WARNING,
+					LIBDAX_MSGS_PRIO_HIGH,
+				      "Drive does not support fast formatting",
+					0, 0);
+				flag &= ~64;
+			} else {
+no_non_default_bd_re:;
+				libdax_msgs_submit(libdax_messenger,
+					drive->global_index, 0x00020167,
+				   	LIBDAX_MSGS_SEV_SORRY,
+					LIBDAX_MSGS_PRIO_HIGH,
+				"Drive does not support non-default formatting",
+					0, 0);
+				drive->cancel = 1;
+				return;
+			}
+		    }
+		    if ((!(flag & 64)) && !(drive->current_feat23h_byte4 & 1)){
+			if (drive->current_feat23h_byte4 & 2) {
+				libdax_msgs_submit(libdax_messenger,
+					drive->global_index, 0x00020166,
+				   	LIBDAX_MSGS_SEV_WARNING,
+					LIBDAX_MSGS_PRIO_HIGH,
+				      "Drive does not support full formatting",
+					0, 0);
+				flag |= 64;
+			} else
+				goto no_non_default_bd_re;
+		    }
+		}
+
 	}
 
 	if (!ok) {
@@ -541,22 +508,8 @@ 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;
-	char msg[80];
-
-#define Libburn_protect_write_threaD 1
-
-#ifdef Libburn_protect_write_threaD
-	sigset_t sigset, oldset;
-
-	/* Protect write thread from being interrupted by external signals */
-	sigfillset(&sigset);
-	sigdelset(&sigset, SIGSEGV);
-	sigdelset(&sigset, SIGILL);
-	pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
-#endif /* Libburn_protect_write_threaD */
 
 	d->thread_pid = getpid();
-	d->thread_tid = pthread_self();
 	d->thread_pid_valid= 1;
 	burn_disc_write_sync(w->u.write.opts, w->u.write.disc);
 	d->thread_pid_valid= 0;
@@ -566,26 +519,14 @@ static void *write_disc_worker_func(struct w_list *w)
 	 */
 	burn_write_opts_free(w->u.write.opts);
 
-	sprintf(msg, "Write thread on drive %d ended", d->global_index);
-	libdax_msgs_submit(libdax_messenger, d->global_index, 0x00020178,
-			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_HIGH,
-			msg, 0, 0);
-
 	remove_worker(pthread_self());
-	d->busy = BURN_DRIVE_IDLE;
-
-#ifdef Libburn_protect_write_threaD
-	/* (just in case it would not end with all signals blocked) */
-	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-#endif /* Libburn_protect_write_threaD */
-
 	return NULL;
 }
 
 void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 {
 	struct write_opts o;
-	char *reasons= NULL;
+	char reasons[BURN_REASONS_LEN+80];
 	struct burn_drive *d;
 
 	d = opts->drive;
@@ -602,20 +543,12 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 		return;
 	}
 
-	reset_progress(d, disc->sessions, disc->session[0]->tracks,
-			 disc->session[0]->track[0]->indices, 0, 0);
-
 	/* For the next lines any return indicates failure */
 	d->cancel = 1;
 
 	/* ts A70203 : people have been warned in API specs */
-	if (opts->write_type == BURN_WRITE_NONE) {
-		libdax_msgs_submit(libdax_messenger, d->global_index,
-			0x0002017c,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
-			"No valid write type selected", 0, 0);
+	if (opts->write_type == BURN_WRITE_NONE)
 		return;
-	}
 
 	if (d->drive_role == 0) {
 		libdax_msgs_submit(libdax_messenger, d->global_index,
@@ -624,14 +557,6 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 			"Drive is a virtual placeholder (null-drive)", 0, 0);
 		return;
 	}
-	if (d->drive_role == 4) {
-		libdax_msgs_submit(libdax_messenger, d->global_index,
-			0x00020181,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
-			"Pseudo-drive is a read-only file. Cannot write.",
-			0, 0);
-		return;
-	}
 
 	/* ts A61007 : obsolete Assert in spc_select_write_params() */
 	if (d->drive_role == 1 && d->mdata->valid <= 0) {
@@ -645,8 +570,6 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 	/* ts A70219 : intended to replace all further tests here and many
 	               tests in burn_*_write_sync()
 	*/
-
-        BURN_ALLOC_MEM_VOID(reasons, char, BURN_REASONS_LEN + 80);
 	strcpy(reasons, "Write job parameters are unsuitable:\n");
 	if (burn_precheck_write(opts, disc, reasons + strlen(reasons), 1)
 	     <= 0) {
@@ -654,9 +577,8 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 				d->global_index, 0x00020139,
 				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 				reasons, 0, 0);
-		goto ex;
+		return;
 	}
-        BURN_FREE_MEM(reasons); reasons= NULL;
 
 	/* ts A90106 : early catching of unformatted BD-RE */
 	if (d->current_profile == 0x43) 
@@ -680,9 +602,6 @@ void burn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
 
 	add_worker(Burnworker_type_writE, d,
 			(WorkerFunc) write_disc_worker_func, &o);
-
-ex:;
-	BURN_FREE_MEM(reasons);
 }
 
 
@@ -690,30 +609,12 @@ static void *fifo_worker_func(struct w_list *w)
 {
 	int old;
 
-#define Libburn_protect_fifo_threaD 1
-
-#ifdef Libburn_protect_fifo_threaD
-	sigset_t sigset, oldset;
-
-	/* Protect fifo thread from being interrupted by external signals */
-	sigfillset(&sigset);
-	sigdelset(&sigset, SIGSEGV);
-	sigdelset(&sigset, SIGILL);
-	pthread_sigmask(SIG_SETMASK, &sigset, &oldset);
-#endif /* Libburn_protect_fifo_threaD */
-
 	pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &old);
 	pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, &old);
 		/* Note: Only burn_fifo_abort() shall cancel the fifo thread */
 
 	burn_fifo_source_shoveller(w->u.fifo.source, w->u.fifo.flag);
 	remove_worker(pthread_self());
-
-#ifdef Libburn_protect_fifo_threaD
-	/* (just in case it would not end with all signals blocked) */
-	pthread_sigmask(SIG_SETMASK, &oldset, NULL);
-#endif /* Libburn_protect_fifo_threaD */
-
 	return NULL;
 }
 
@@ -738,7 +639,6 @@ int burn_fifo_start(struct burn_source *source, int flag)
 	add_worker(Burnworker_type_fifO, NULL,
 			(WorkerFunc) fifo_worker_func, &o);
 	fs->is_started = 1;
-
 	return 1;
 }
 

libburn/back_hacks.h

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

libburn/cleanup.c

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

libburn/cleanup.h

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

libburn/crc.c

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

libburn/crc.h

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

libburn/ddlpa.c

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

libburn/debug.c

@@ -1,14 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
-
 #ifdef WIN32
 #include <windows.h>
 #endif

libburn/drive.h

@@ -1,18 +1,11 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-
 #ifndef __DRIVE
 #define __DRIVE
 
 #include "libburn.h"
 #include "toc.h"
 #include "structure.h"
-#include <pthread.h>
 
 struct burn_drive;
 struct command;
@@ -128,9 +121,8 @@ int burn_disc_get_write_mode_demands(struct burn_disc *disc,
 int burn_drive__fd_from_special_adr(char *adr);
 
 
-/* ts A70929 : Find the drive which is being worked on by pid , tid */
-int burn_drive_find_by_thread_pid(struct burn_drive **d, pid_t pid,
-					pthread_t tid);
+/* ts 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);
 
 
 /* ts A51221 - A80731 : Whitelist inquiry functions */
@@ -143,16 +135,4 @@ char *burn_drive_whitelist_item(int idx, int flag);
 int burn_drive_is_listed(char *path, struct burn_drive **found, int flag);
 
 
-/* ts B00226 : Outsourced backend of burn_abort()
-   @param elapsed  to be subtracted from start time
-   @param flag     bit0= do not shutdown the library
-*/ 
-int burn_abort_5(int patience,
-               int (*pacifier_func)(void *handle, int patience, int elapsed),
-               void *handle, int elapsed, int flag);
-
-/* ts B10730 */
-/* Send a default mode page 05 to CD and DVD-R-oids */
-int burn_drive_send_default_page_05(struct burn_drive *d, int flag);
-
 #endif /* __DRIVE */

libburn/ecma130ab.c

@@ -1,14 +1,9 @@
 
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 /* ts A91016 : libburn/ecma130ab.c is the replacement for old libburn/lec.c
 
    Copyright 2009, Thomas Schmitt <scdbackup@gmx.net>, libburnia-project.org
-   Provided under GPL version 2 or later.
 
    This code module implements the production of RSPC parity bytes (P- and Q-
    parity) and the scrambling of raw CD-ROM sectors as specified in ECMA-130:

libburn/ecma130ab.h

@@ -4,7 +4,6 @@
 /* ts A91016 : libburn/ecma130ab.h is the replacement for old libburn/lec.h
 
    Copyright 2009, Thomas Schmitt <scdbackup@gmx.net>, libburnia-project.org
-   Provided under GPL version 2 or later.
 
    This code module implements the computations prescribed in ECMA-130 Annex A
    and B. For explanations of the underlying mathematics see ecma130ab.c .

libburn/file.c

@@ -1,15 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 
 #include <stdlib.h>
 #include <sys/types.h>
@@ -93,9 +83,7 @@ static off_t file_size(struct burn_source *source)
 
 	if (fs->fixed_size > 0)
 		return fs->fixed_size;
-	if (fstat(fs->datafd, &buf) != 0)
-		return (off_t) 0;
-	if ((buf.st_mode & S_IFMT) != S_IFREG)
+	if (fstat(fs->datafd, &buf) == -1)
 		return (off_t) 0;
 	return (off_t) buf.st_size;
 }
@@ -129,7 +117,7 @@ struct burn_source *burn_file_source_new(const char *path, const char *subpath)
 			return NULL;
 		}
 	}
-	fs = calloc(1, sizeof(struct burn_source_file));
+	fs = malloc(sizeof(struct burn_source_file));
 
 	/* ts A70825 */
 	if (fs == NULL) {
@@ -175,7 +163,7 @@ struct burn_source *burn_fd_source_new(int datafd, int subfd, off_t size)
 
 	if (datafd == -1)
 		return NULL;
-	fs = calloc(1, sizeof(struct burn_source_file));
+	fs = malloc(sizeof(struct burn_source_file));
 	if (fs == NULL) /* ts A70825 */
 		return NULL;
 	fs->datafd = datafd;
@@ -211,10 +199,9 @@ struct burn_source *burn_fd_source_new(int datafd, int subfd, off_t size)
 
 static int fifo_sleep(int flag)
 {
-	static unsigned long sleeptime = 50000; /* 50 ms */
+	static struct timespec sleeptime = { 0, 50000000}; /* 50 ms */
 
-	usleep(sleeptime);
-	return 0;
+	return nanosleep(&sleeptime, NULL);
 }
 
 
@@ -404,13 +391,9 @@ int burn_fifo_source_shoveller(struct burn_source *source, int flag)
 		else
 			ret = fs->inp->read_xt( fs->inp,
 				 (unsigned char *) bufpt, fs->inp_read_size);
-		if (ret == 0) {
-
-			/* >>> ??? ts B00326 */
-			/* >>> report EOF of fifo input and fs->in_counter */;
-
+		if (ret == 0)
 	break; /* EOF */
-		} else if (ret < 0) {
+		else if (ret < 0) {
 			libdax_msgs_submit(libdax_messenger, -1, 0x00020153,
 				 LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 				"Read error on fifo input", errno, 0);
@@ -482,11 +465,10 @@ int burn_fifo_source_shoveller(struct burn_source *source, int flag)
 
 int burn_fifo_cancel(struct burn_source *source)
 {
-	int ret;
 	struct burn_source_fifo *fs = source->data;
 
-	ret = burn_source_cancel(fs->inp);
-	return ret;
+	burn_source_cancel(fs->inp);
+	return(1);
 }
 
 /*
@@ -510,7 +492,7 @@ struct burn_source *burn_fifo_source_new(struct burn_source *inp,
 				"Desired fifo buffer too small", 0, 0);
 		return NULL;
 	}
-	fs = calloc(1, sizeof(struct burn_source_fifo));
+	fs = malloc(sizeof(struct burn_source_fifo));
 	if (fs == NULL)
 		return NULL;
 	fs->is_started = 0;
@@ -625,9 +607,7 @@ void burn_fifo_next_interval(struct burn_source *source,
 
 	*interval_min_fill = fs->interval_min_fill;
 	ret = burn_fifo_inquire_status(source,
-					 &size, &free_bytes, &status_text);
-	if (ret < 0)
-		return;
+					 &size, &free_bytes, &status_text);	
 	fs->interval_min_fill = size - free_bytes - 1;
 }
 
@@ -751,162 +731,3 @@ int burn_fifo_fill(struct burn_source *source, int bufsize, int flag)
 					1 | ((flag & 1) << 1));
 }
 
-
-/* ----------------------------- Offset source ----------------------------- */
-/* ts B00922 */
-
-static void offst_free(struct burn_source *source);
-
-static struct burn_source_offst *offst_auth(struct burn_source *source)
-{
-	if (source->free_data != offst_free) {
-		libdax_msgs_submit(libdax_messenger, -1, 0x0002017a,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
- 			"Expected offset source object as parameter",
-			0, 0);
-		return NULL;
-	}
-	return (struct burn_source_offst *) source->data;
-}
-
-static off_t offst_get_size(struct burn_source *source)
-{
-        struct burn_source_offst *fs;
-
-	if ((fs = offst_auth(source)) == NULL)
-		return (off_t) 0;
-        return fs->size;
-}
-
-static int offst_set_size(struct burn_source *source, off_t size)
-{
-	struct burn_source_offst *fs;
-
-	if ((fs = offst_auth(source)) == NULL)
-		return 0;
-	fs->size = size;
-	return 1;
-}
-
-static void offst_free(struct burn_source *source)
-{
-	struct burn_source_offst *fs;
-
-	if ((fs = offst_auth(source)) == NULL)
-		return;
-	if (fs->prev != NULL)
-		offst_auth(fs->prev)->next = fs->next;
-	if (fs->next != NULL)
-		offst_auth(fs->next)->prev = fs->prev;
-	if (fs->inp != NULL)
-		burn_source_free(fs->inp); /* i.e. decrement refcount */
-	free(source->data);
-}
-
-static int offst_read(struct burn_source *source, unsigned char *buffer,
-			int size)
-{
-	int ret, to_read, todo;
-	struct burn_source_offst *fs;
-
-	if ((fs = offst_auth(source)) == NULL)
-		return -1;
-
-	/* Eventually skip bytes up to start position */;
-	if (!fs->running) {
-		if (fs->prev != NULL)
-			fs->pos = offst_auth(fs->prev)->pos;
-		fs->running= 1;
-	}
-	if(fs->pos < fs->start) {
-		todo = fs->start - fs->pos;
-		while (todo > 0) {
-			to_read = todo;
-			if (to_read > size)
-				to_read = size;
-			ret = burn_source_read(fs->inp, buffer, to_read);
-			if (ret <= 0)
-				return ret;
-			todo -= ret;
-			fs->pos += ret;
-		}
-	}
-
-	/* Produce EOF if source size is exhausted.
-	   burn_source delivers no incomplete sector buffers.
-	*/
-	if (fs->pos + size > fs->start + fs->size)
-		return 0;
-
-	/* Read payload */
-	ret = burn_source_read(fs->inp, buffer, size);
-	if (ret > 0)
-		fs->pos += ret;
-	return ret;
-}
-
-static int offst_cancel(struct burn_source *source)
-{
-	int ret;
-	struct burn_source_offst *fs;
-
-	if ((fs = offst_auth(source)) == NULL)
-		return -1;
-	ret = burn_source_cancel(fs->inp);
-	return ret;
-}
-
-struct burn_source *burn_offst_source_new(
-		struct burn_source *inp, struct burn_source *prev,
-		off_t start, off_t size, int flag)
-{
-	struct burn_source *src;
-	struct burn_source_offst *fs, *prev_fs = NULL;
-
-	if (prev != NULL)
-		if ((prev_fs = offst_auth(prev)) == NULL)
-			return NULL; /* Not type burn_source_offst */
-
-	fs = calloc(1, sizeof(struct burn_source_offst));
-	if (fs == NULL)
-		return NULL;
-        src = burn_source_new();
-        if (src == NULL) {
-                free((char *) fs);
-                return NULL;
-        }
-        src->read = NULL;
-        src->read_sub = NULL;
-        src->get_size = offst_get_size;
-        src->set_size = offst_set_size;
-        src->free_data = offst_free;
-        src->data = fs;
-        src->version= 1;
-        src->read_xt = offst_read;
-        src->cancel= offst_cancel;
-        fs->inp = inp;
-	fs->prev = prev;
-	fs->next = NULL;
-	if (prev != NULL) {
-		if (prev_fs->next != NULL) {
-			offst_auth(prev_fs->next)->prev = src;
-			fs->next = prev_fs->next;
-		}
-		prev_fs->next = src;
-		if (prev_fs->start + prev_fs->size > start) {
-			libdax_msgs_submit(libdax_messenger, -1, 0x00020179,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
- 		"Offset source start address is before end of previous source",
-			0, 0);
-			return NULL;
-		}
-	}
-	fs->start = start;
-	fs->size = size;
-	fs->running = 0;
-	fs->pos = 0;
-        inp->refcount++; /* make sure inp lives longer than src */
-
-        return src;
-}
-

libburn/file.h

@@ -1,10 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
 #ifndef BURN__FILE_H
 #define BURN__FILE_H
 
@@ -74,22 +69,4 @@ struct burn_source_fifo {
 int burn_fifo_source_shoveller(struct burn_source *source, int flag);
 
 
-/* ts B00922 */
-struct burn_source_offst {
-
-	/* See burn_offst_source_new() */
-	struct burn_source *inp;
-	struct burn_source *prev;
-	off_t start;
-	off_t size;
-
-	/* To help offst_free() */
-	struct burn_source *next;
-
-	/* The current reading position */
-	int running;
-	off_t pos;
-
-};
-
 #endif /* LIBBURN__FILE_H */

libburn/init.c

@@ -1,15 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
-
 #include <unistd.h>
 
 /* ts A61007 */
@@ -19,7 +9,6 @@
 #include <signal.h>
 #include <string.h>
 #include <stdlib.h>
-#include <pthread.h>
 
 /* ts A70928 : init.h is for others, not for init .c
 #include "init.h"
@@ -43,16 +32,14 @@ struct libdax_msgs *libdax_messenger= NULL;
 
 int burn_running = 0;
 
-/* ts A60813 : GNU/Linux: whether to use O_EXCL on open() of device files
-   ts B00212 : FreeBSD:   whether to use flock(LOCK_EX) after open()
-*/
+/* ts A60813 : Linux: wether to use O_EXCL on open() of device files */
 int burn_sg_open_o_excl = 1;
 
-/* ts A70403 : GNU/Linux: wether to use fcntl(,F_SETLK,)
+/* ts A70403 : Linux: wether to use fcntl(,F_SETLK,)
                       after open() of device files  */
 int burn_sg_fcntl_f_setlk = 1;
 
-/* ts A70314 : GNU/Linux: what device family to use :
+/* ts A70314 : Linux: what device family to use :
     0= default family
     1= sr
     2= scd
@@ -85,13 +72,10 @@ static char sg_initialize_msg[1024] = {""};
 /* Parameters for builtin abort handler */
 static char abort_message_prefix[81] = {"libburn : "};
 static pid_t abort_control_pid= 0;
-static pthread_t abort_control_thread;
 volatile int burn_global_abort_level= 0;
 int burn_global_abort_signum= 0;
 void *burn_global_signal_handle = NULL;
 burn_abort_handler_t burn_global_signal_handler = NULL;
-int burn_builtin_signal_action = 0;            /* burn_set_signal_handling() */
-volatile int burn_builtin_triggered_action = 0;       /*  burn_is_aborting() */
 
 
 /* ts A70223 : wether implemented untested profiles are supported */
@@ -105,14 +89,6 @@ int burn_support_untested_profiles = 0;
 */
 int burn_sg_log_scsi = 0;
 
-
-/* ts B10312 :
-   Whether to map random-access readonly files to drive role 4.
-   Else it is role 2 overwriteable drive
-*/
-int burn_drive_role_4_allowed = 0;
-
-
 /* ts A60925 : ticket 74 */
 /** Create the messenger object for libburn. */
 int burn_msgs_initialize(void)
@@ -177,8 +153,6 @@ void burn_finish(void)
 
 	sg_shutdown(0);
 
-	burn_drive_clear_whitelist();
-
 	burn_running = 0;
 }
 
@@ -347,20 +321,6 @@ int burn_sev_to_text(int severity_number, char **severity_name, int flag)
 	return ret;
 }
 
-/* ts B00224 */
-char *burn_util_thread_id(pid_t pid, pthread_t tid, char text[80])
-{
-	int i, l;
-
-	sprintf(text, "[%lu,", (unsigned long int) getpid());
-	l= strlen(text);
-	for(i= 0; i < ((int) sizeof(pthread_t)) && 2 * i < 80 - l - 3; i++)
-		sprintf(text + l + 2 * i,
-			 "%2.2X", ((unsigned char *) &tid)[i]);
-
-	sprintf(text + l + 2 * i, "]");
-	return text;
-}
 
 int burn_builtin_abort_handler(void *handle, int signum, int flag)
 {
@@ -369,53 +329,15 @@ int burn_builtin_abort_handler(void *handle, int signum, int flag)
 /*
 #define Libburn_signal_handler_verbouS 1
 */
-
 	int ret;
 	struct burn_drive *d;
 
 #ifdef Libburn_signal_handler_verbouS
-	char text[80];
-
-	fprintf(stderr, "libburn_ABORT: in = %s\n",
-		burn_util_thread_id(getpid(), pthread_self(), text));
-	fprintf(stderr, "libburn_ABORT: ctrl = %s\n",
-		burn_util_thread_id(abort_control_pid, abort_control_thread,
-					text));
-	if (burn_global_signal_handler == burn_builtin_abort_handler)
-		fprintf(stderr, "libburn_ABORT: signal action = %d\n",
-				burn_builtin_signal_action);
-
-	/* >>> find writing drives and report their tid
-	fprintf(stderr, "libburn_ABORT: wrt = %s\n",
-		burn_util_thread_id(0, burn_write_thread_id, text));
-	fprintf(stderr, "libburn_ABORT: sig= %d\n", signum);
-	*/
+	fprintf(stderr,
+		"libburn_ABORT: pid = %d , abort_control_pid = %d , sig= %d\n",
+		getpid(), abort_control_pid, signum);
 #endif
 
-	burn_builtin_triggered_action = burn_builtin_signal_action;
-	burn_global_abort_level = -1;
-
-	if (burn_builtin_signal_action > 1) {
-		Cleanup_set_handlers(NULL, NULL, 2);
-		if (burn_builtin_signal_action == 4)
-			return -2;
-		fprintf(stderr,"%sABORT : Trying to shut down busy drives\n",
-			abort_message_prefix);
-		fprintf(stderr,
-		 "%sABORT : Wait the normal burning time before any kill -9\n",
-		 	abort_message_prefix);
-		burn_abort_5(0, burn_abort_pacifier, abort_message_prefix,
-				0, 1);
-		libdax_msgs_submit(libdax_messenger, -1, 0x00020177,
-			LIBDAX_MSGS_SEV_ABORT, LIBDAX_MSGS_PRIO_HIGH,
-			"Urged drive worker threads to do emergency halt",
-			0, 0);
-		return -2;
-	}
-
-
-	/* ---- old deprecated stuck-in-abort-handler loop ---- */
-
 	/* ts A70928:
 	Must be quick. Allowed to coincide with other thread and to share
 	the increment with that one. It must not decrease, though, and
@@ -428,8 +350,7 @@ int burn_builtin_abort_handler(void *handle, int signum, int flag)
 
 #ifdef Libburn_new_thread_signal_handleR
 
-		ret = burn_drive_find_by_thread_pid(&d, getpid(),
-							pthread_self());
+		ret = burn_drive_find_by_thread_pid(&d, getpid());
 		if (ret > 0 && d->busy == BURN_DRIVE_WRITING) {
 					/* This is an active writer thread */
 
@@ -469,13 +390,13 @@ int burn_builtin_abort_handler(void *handle, int signum, int flag)
 	}
 	burn_global_abort_level = -1;
 	Cleanup_set_handlers(NULL, NULL, 2);
-
 	fprintf(stderr,"%sABORT : Trying to shut down drive and library\n",
 		abort_message_prefix);
 	fprintf(stderr,
 		"%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,
@@ -485,71 +406,28 @@ int burn_builtin_abort_handler(void *handle, int signum, int flag)
 	return(1);
 }
 
-
-/* ts A61002 : API */
 void burn_set_signal_handling(void *handle, burn_abort_handler_t handler,
-				int mode)
+			     int mode)
 {
-
-/*
-	fprintf(stderr, "libburn_experimental: burn_set_signal_handling, handler==%lx  mode=%d\n", (unsigned long) handler, mode);
-*/
-
-	if(handler == NULL) {
+	if(handler == NULL && mode == 0) {
 		handler = burn_builtin_abort_handler;
 /*
-		if ((mode & ~4) == 0)
-			fprintf(stderr, "libburn_experimental: activated burn_builtin_abort_handler() with handle '%s'\n",(handle==NULL ? "libburn : " : (char *) handle));
+		fprintf(stderr, "libburn_experimental: activated burn_builtin_abort_handler() with handle '%s'\n",(handle==NULL ? "libburn : " : (char *) handle));
 */
 
 	}
 	strcpy(abort_message_prefix, "libburn : ");
-	abort_message_prefix[0] = 0;
-	if(handle != NULL && handler == burn_builtin_abort_handler)
+	if(handle != NULL)
 		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_thread = pthread_self();
-	burn_builtin_signal_action = (mode >> 4) & 15;
-	if((mode & 11) != 0)
-		burn_builtin_signal_action = 0;
-	if(burn_builtin_signal_action > 1)
-		burn_builtin_triggered_action = 0;
-	if(burn_builtin_signal_action == 0)
-		burn_builtin_signal_action = 1;
-	Cleanup_set_handlers(handle, (Cleanup_app_handler_T) handler,
-				 (mode & 15) | 4);
+	Cleanup_set_handlers(handle, (Cleanup_app_handler_T) handler, mode|4);
 	burn_global_signal_handle = handle;
 	burn_global_signal_handler = handler;
 }
 
 
-/* ts B00304 : API */
-int burn_is_aborting(int flag)
-{
-	return burn_builtin_triggered_action;
-}
-
-
-/* ts B00225 */
-/* @return 0= no abort action 2 pending , 1= not control thread
-*/
-int burn_init_catch_on_abort(int flag)
-{
-	if (burn_builtin_triggered_action != 2)
-		return 0;
-	if (abort_control_pid != getpid() ||
-		abort_control_thread != pthread_self())
-		return 1;
-	burn_abort(4440, burn_abort_pacifier, abort_message_prefix);
-	fprintf(stderr,
-	"\n%sABORT : Program done. Even if you do not see a shell prompt.\n\n",
-		abort_message_prefix);
-	exit(1);
-}
-
-
 /* ts A70223 : API */
 void burn_allow_untested_profiles(int yes)
 {
@@ -575,25 +453,3 @@ void burn_set_scsi_logging(int flag)
 {
 	burn_sg_log_scsi = flag & 7;
 }
-
-
-/* ts B10312 API */
-void burn_allow_drive_role_4(int allowed)
-{
-	burn_drive_role_4_allowed = (allowed & 0xf);
-}
-
-
-/* ts B10606 */
-void *burn_alloc_mem(size_t size, size_t count, int flag)
-{
-	void *pt;
-
-	pt = calloc(size, count);
-	if(pt == NULL)
-		libdax_msgs_submit(libdax_messenger, -1, 0x00000003,
-				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
-				"Out of virtual memory", 0, 0);
-	return pt;
-}
-

libburn/init.h

@@ -17,35 +17,5 @@ extern int burn_global_abort_signum;
 extern void *burn_global_signal_handle;
 extern burn_abort_handler_t burn_global_signal_handler;
 
-extern int burn_builtin_signal_action;         /* burn_set_signal_handling() */
-extern volatile int burn_builtin_triggered_action;    /*  burn_is_aborting() */
-
-
-/* ts B00225 */
-/* @return 0= no abort pending , 1= not control thread ,
-          -1= surprisingly burn_abort returned
-*/
-int burn_init_catch_on_abort(int flag);
-
-/* ts B10606 */
-void *burn_alloc_mem(size_t size, size_t count, int flag);
-
-#define BURN_ALLOC_MEM(pt, typ, count) { \
-	pt= (typ *) burn_alloc_mem(sizeof(typ), (size_t) (count), 0); \
-	if(pt == NULL) { \
-		ret= -1; goto ex; \
-	} }
-
-#define BURN_ALLOC_MEM_VOID(pt, typ, count) { \
-	pt= (typ *) burn_alloc_mem(sizeof(typ), (size_t) (count), 0); \
-	if(pt == NULL) { \
-		goto ex; \
-	} }
-
-#define BURN_FREE_MEM(pt) { \
-	if(pt != NULL) \
-		free((char *) pt); \
-	}
-
 
 #endif /* BURN__INIT_H */

libburn/libburn.h

@@ -1,17 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-
-   This is the official API definition of libburn.
-
-*/
-/* Important: If you add a public API function then add its name to file
-                 libburn/libburn.ver
-*/
-
-
 #ifndef LIBBURN_H
 #define LIBBURN_H
 
@@ -739,22 +727,17 @@ void burn_finish(void);
 
 
 /* ts A61002 */
-/** Abort any running drive operation and eventually call burn_finish().
-
-    You MUST shut down the busy drives if an aborting event occurs during a
+/** Abort any running drive operation and finally call burn_finish().
+    You MUST calm down the busy drive if an aborting event occurs during a
     burn run. For that you may call this function either from your own signal
-    handling code or indirectly by activating the built-in signal handling:
+    handling code or indirectly by activating the builtin signal handling:
       burn_set_signal_handling("my_app_name : ", NULL, 0);
-    Else you may eventually call burn_drive_cancel() on the active drives and
-    wait for them to assume state BURN_DRIVE_IDLE.
-    @param patience      Maximum number of seconds to wait for drives to
-                         finish.
-                         @since 0.7.8 :
-                         If this is -1, then only the cancel operations will
-                         be performed and no burn_finish() will happen.
+    Else you may eventually call burn_drive_cancel() on the active drive and
+    wait for it to assume state BURN_DRIVE_IDLE.
+    @param patience Maximum number of seconds to wait for drives to finish
     @param pacifier_func If not NULL: a function to produce appeasing messages.
                          See burn_abort_pacifier() for an example.
-    @param handle        Opaque handle to be used with pacifier_func
+    @param handle Opaque handle to be used with pacifier_func
     @return 1  ok, all went well
             0  had to leave a drive in unclean state
             <0 severe error, do no use libburn again
@@ -782,7 +765,7 @@ int burn_abort_pacifier(void *handle, int patience, int elapsed);
 void burn_set_verbosity(int level);
 
 /* ts A91111 */
-/** Enable resp. disable logging of SCSI commands (currently GNU/Linux only).
+/** Enable resp. disable logging of SCSI commands (currently Linux only).
     This call can be made at any time - even before burn_initialize().
     It is in effect for all active drives and currently not very thread
     safe for multiple drives.
@@ -799,11 +782,12 @@ void burn_set_scsi_logging(int flag);
     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
+    @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
-                     on GNU/Linux , flock(LOCK_EX) on FreeBSD.)
+                     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 .
                      One may select a device SCSI file family by adding
@@ -812,8 +796,8 @@ void burn_set_scsi_logging(int flag);
                       8 = /dev/scd%d
                      16 = /dev/sg%d
                      Do not use other values !
-                     Add 32 to demand on GNU/Linux an exclusive lock by
-                     fcntl(,F_SETLK,) after open() has succeeded.
+                     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.
@@ -828,7 +812,7 @@ 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 no media types are under test reservation -
+    Currently it contains: 0x15 "DVD-R/DL sequential recording",
     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
@@ -1059,39 +1043,6 @@ int burn_drive_convert_fs_adr(char *path, char adr[]);
 int burn_drive_convert_scsi_adr(int bus_no, int host_no, int channel_no,
 				 int target_no, int lun_no, char adr[]);
 
-/* ts B10728 */
-/** Try to convert a given persistent drive address into the address of a
-    symbolic link that points to this drive address.
-    Modern GNU/Linux systems may shuffle drive addresses from boot to boot.
-    The udev daemon is supposed to create links which always point to the
-    same drive, regardless of its system address.
-    This call tries to find such links.
-    @param dev_adr     Should contain a drive address as returned by
-                       burn_drive_scan().
-    @param link_adr    An application provided array of at least
-                       BURN_DRIVE_ADR_LEN characters size. The found link
-                       address gets copied to it.
-    @param dir_adr     The address of the directory where to look for links.
-                       Normally: "/dev"
-    @param templ       An array of pointers to name templates, which
-                       links have to match. A symbolic link in dir_adr matches
-                       a name template if it begins by that text. E.g.
-                       link address "/dev/dvdrw1" matches template "dvdrw".
-                       If templ is NULL, then the default array gets used:
-                        {"dvdrw", "cdrw", "dvd", "cdrom", "cd"}
-                       If several links would match, then a link will win,
-                       which matches the template with the lowest array index.
-                       Among these candidates, the one with the lowest strcmp()
-                       rank will be chosen as link_adr.
-    @param num_templ   Number of array elements in templ.
-    @param flag        Bitfield for control purposes. Unused yet. Submit 0.
-    @return            <0 severe error, 0 failed to search, 2 nothing found
-                       1 success, link_adr is valid
-    @since 1.1.4
-*/
-int burn_lookup_device_link(char *dev_adr, char link_adr[],
-                         char *dir_adr, char **templ, int num_templ, int flag);
-
 /* 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
@@ -1146,6 +1097,7 @@ int burn_drive_snooze(struct burn_drive *d, int flag);
 
 /** Release a drive. This should not be done until the drive is no longer
     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.
 */
@@ -1270,50 +1222,12 @@ char *burn_guess_cd_manufacturer(int m_li, int s_li, int f_li,
                      bit5= Disc is nominally erasable (Erasable bit)
                            This will be set with overwriteable media which
                            libburn normally considers to be unerasable blank.
-    @return          1 success, <= 0 an error occured
     @since 0.7.2
 */
 int burn_disc_get_cd_info(struct burn_drive *d, char disc_type[80],
                         unsigned int *disc_id, char bar_code[9], int *app_code,
 			int *valid);
 
-/* ts B00924 */
-/** Read the current usage of the eventual BD Spare Area. This area gets
-    reserved on BD media during formatting. During writing it is used to
-    host replacements of blocks which failed the checkread immediately after
-    writing.
-    This call applies only to recordable BD media. I.e. profiles 0x41 to 0x43.
-    @param d            The drive to query.
-    @param alloc_blocks Returns the number of blocks reserved as Spare Area
-    @param free_blocks  Returns the number of yet unused blocks in that area
-    @param flag         Bitfield for control purposes (unused yet, submit 0)
-    @return             1 = reply prarameters are valid,
-                        <=0 = reply is invalid (e.g. because no BD profile)
-    @since 0.8.8
-*/
-int burn_disc_get_bd_spare_info(struct burn_drive *d,
-                                int *alloc_blocks, int *free_blocks, int flag);
-
-/* ts B10801 */
-/** Retrieve some media information which is mainly specific to media of
-    the DVD-R family: DVD-R , DVD-RW , DVD-R DL , HD DVD-R
-    Currently the information cannot be retrieved from other media types.
-    @param d              The drive to query.
-    @param disk_category  returns DVD Book to which the media complies
-    @param book_name      returns a pointer to the book name of disk_category.
-                          This memory is static. Do not alter or free it !
-    @param part_version   returns the Media Version in the DVD Book
-    @param num_layers     returns the number of media layers
-    @param num_blocks     returns the number of blocks between pysical start
-                          and physical end of the media
-    @param flag           Bitfield for control purposes (unused yet, submit 0)
-    @return               1 = reply prarameters are valid,
-                          <=0 = reply is invalid (e.g. because no DVD-R)
-    @since 1.1.4
-*/
-int burn_disc_get_phys_format_info(struct burn_drive *d, int *disk_category,
-                        char **book_name, int *part_version, int *num_layers,
-                        int *num_blocks, int flag);
 
 /* ts A61110 */
 /** Read start lba and Next Writeable Address of a track from media.
@@ -1333,45 +1247,6 @@ int burn_disc_get_phys_format_info(struct burn_drive *d, int *disk_category,
 int burn_disc_track_lba_nwa(struct burn_drive *d, struct burn_write_opts *o,
 				int trackno, int *lba, int *nwa);
 
-/* ts B10525 */
-/** Tells whether a previous attempt to determine the Next Writeable Address
-    of the upcomming track reveiled that the READ TRACK INFORMATION Damage Bit
-    is set for this track, resp. that no valid writable address is available. 
-    See MMC-5 6.27.3.7 Damage Bit, 6.27.3.11 NWA_V (NWA valid)
-    @param d     The drive to query.
-    @param flag  Bitfield for control purposes (unused yet, submit 0)
-    @return      0= Looks ok: Damage Bit is not set, NWA_V is set
-                 1= Damaged and theoretically writable (NWA_V is set)
-                 2= Not writable: NWA_V is not set
-                 3= Damaged and not writable (NWA_V is not set),
-    @since 1.1.0
-*/
-int burn_disc_next_track_is_damaged(struct burn_drive *d, int flag);
-
-/* ts B10527 */
-/** Try to close the last track and session of media which have bit0 set in
-    the return value of call burn_disc_next_track_is_damaged().
-    Whether it helps depends much on the reason why the media is reported
-    as damaged by the drive.
-    This call works only for profiles 0x09 CD-R, 0x0a CD-RW, 0x11 DVD-R,
-    0x14 DVD-RW sequential, 0x1b DVD+R, 0x2b DVD+R DL, 0x41 BD-R sequential.
-    Note: After writing it is advised to give up the drive and to grab it again
-          in order to learn about its view on the new media state.
-    @param o     Write options created by burn_write_opts_new() and
-                 manipulated by burn_write_opts_set_multi().
-                 burn_write_opts_set_write_type() should be set to
-                 BURN_WRITE_TAO, burn_write_opts_set_simulate() should be
-                 set to 0.
-    @param flag  Bitfield for control purposes
-                 bit0= force close, even if no damage was seen
-    @return      <=0 media not marked as damaged, or media type not suitable,
-                     or closing attempted but failed
-                 1= attempt finished without error indication
-    @since 1.1.0
-*/
-int burn_disc_close_damaged(struct burn_write_opts *o, int flag);
-
-
 /* ts A70131 */
 /** Read start lba of the first track in the last complete session.
     This is the first parameter of mkisofs option -C. The second parameter
@@ -1393,9 +1268,6 @@ int burn_disc_get_msc1(struct burn_drive *d, int *start_lba);
     An eventual start address from burn_write_opts_set_start_byte() will be
     subtracted from the obtained capacity estimation. Negative results get
     defaulted to 0.
-    If the drive is actually a file in a large filesystem or a large block
-    device, then the capacity is curbed to a maximum of 0x7ffffff0 blocks
-    = 4 TB - 32 KB.
     @param d The drive to query.
     @param o If not NULL: write parameters to be set on drive before query
     @return number of most probably available free bytes
@@ -1404,29 +1276,25 @@ int burn_disc_get_msc1(struct burn_drive *d, int *start_lba);
 off_t burn_disc_available_space(struct burn_drive *d,
                                 struct burn_write_opts *o);
 
+
 /* 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 sequential recording"
-      0x12 "DVD-RAM"
-      0x13 "DVD-RW restricted overwrite"
-      0x14 "DVD-RW sequential recording",
-      0x15 "DVD-R/DL sequential recording",
-      0x1a "DVD+RW"
-      0x1b "DVD+R",
+      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",
       0x2b "DVD+R/DL",
-      0x41 "BD-R sequential recording",
-      0x43 "BD-RE",
+      0x41 "BD-R sequential recording",     0x43 "BD-RE",
       0xffff "stdio file"
     Note: 0xffff is not a MMC profile but a libburn invention.
+    If enabled by burn_allow_untested_profiles() it also writes to profiles
+      0x15 "DVD-R/DL sequential recording",
     Read-only are the profiles
-      0x08 "CD-ROM",
-      0x10 "DVD-ROM",
+      0x08 "CD-ROM",                        0x10 "DVD-ROM",
       0x40 "BD-ROM",
-    Read-only for now is this BD-R profile (testers wanted)
+    For now read-only is BD-R profile (testers wanted)
       0x42 "BD-R random recording"
     @param d The drive where the media is inserted.
     @param pno Profile Number. See also mmc5r03c.pdf, table 89
@@ -1543,8 +1411,6 @@ void burn_read_opts_free(struct burn_read_opts *opts);
     cancellable, as control of the operation is passed wholly to the drive and
     there is no way to interrupt it safely.
     @param drive The drive with which to erase a disc.
-                 Only drive roles 1 (MMC) and 5 (stdio random write-only)
-                 support erasing.
     @param fast Nonzero to do a fast erase, where only the disc's headers are
                 erased; zero to erase the entire disc.
                 With DVD-RW, fast blanking yields media capable only of DAO.
@@ -1689,13 +1555,8 @@ int burn_precheck_write(struct burn_write_opts *o, struct burn_disc *disc,
     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().
-    Note: After writing it is advised to give up the drive and to grab it again
-          in order to learn about its view on the new media state.
-    Note: Before mounting the written media it might be necessary to eject
-          and reload in order to allow the operating system to notice the new
-          media state.
+    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
 */
@@ -2009,41 +1870,6 @@ int burn_os_free_buffer(void *buffer, size_t amount, int flag);
 struct burn_source *burn_fd_source_new(int datafd, int subfd, off_t size);
 
 
-/* ts B00922 */
-/** Creates an offset source which shall provide a byte interval of a stream
-    to its consumer. It is supposed to be chain-linked with other offset
-    sources which serve neighboring consumers. The chronological sequence
-    of consumers and the sequence of offset sources must match. The intervals
-    of the sources must not overlap.
-
-    A chain of these burn_source objects may be used to feed multiple tracks
-    from one single stream of input bytes.
-    Each of the offset sources will skip the bytes up to its start address and
-    provide the prescribed number of bytes to the track. Skipping takes into
-    respect the bytes which have been processed by eventual predecessors in the
-    chain.
-    Important: It is not allowed to free an offset source before its successor
-               has ended its work. Best is to keep them all until all tracks
-               are done.
-
-    @param inp   The burn_source object from which to read stream data.
-                 E.g. created by burn_file_source_new().
-    @param prev  The eventual offset source object which shall read data from
-                 inp before the new offset source will begin its own work.
-                 This must either be a result of  burn_offst_source_new()  or
-                 it must be NULL.
-    @param start The byte address where to start reading bytes for the
-                 consumer. inp bytes may get skipped to reach this address.
-    @param size  The number of bytes to be delivered to the consumer.
-    @param flag  Bitfield for control purposes (unused yet, submit 0).
-    @return      Pointer to a burn_source object, later to be freed by
-                 burn_source_free(). NULL indicates failure.
-    @since 0.8.8
-*/
-struct burn_source *burn_offst_source_new(
-                struct burn_source *inp, struct burn_source *prev,
-                off_t start, off_t size, int flag);
-
 /* 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
@@ -2316,7 +2142,7 @@ void burn_write_opts_set_format(struct burn_write_opts *opts, int format);
     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_disc_write() as a
+    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,
@@ -2353,10 +2179,6 @@ 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.
-    Note: DVD-R[W] in write mode BURN_WRITE_SAO are not capable of this.
-          DVD-R DL are not capable of this at all.
-          libburn will refuse to write if burn_write_opts_set_multi() is
-          enabled under such conditions.
     @param opts The option object to be manipulated
     @param multi 1=media will be appendable, 0=media will be closed (default) 
     @since 0.2.6
@@ -2792,13 +2614,13 @@ void burn_version(int *major, int *minor, int *micro);
       }
 
 */
-#define burn_header_version_major  1
-#define burn_header_version_minor  1
+#define burn_header_version_major  0
+#define burn_header_version_minor  7
 #define burn_header_version_micro  6
 /** Note:
     Above version numbers are also recorded in configure.ac because libtool
     wants them as parameters at build time.
-    For the library compatibility check, BURN_*_VERSION in configure.ac
+    For the library compatibility check BURN_*_VERSION in configure.ac
     are not decisive. Only the three numbers above do matter.
 */
 /** Usage discussion:
@@ -2848,8 +2670,8 @@ These two advises are mutually exclusive.
 /** Obtain the id string of the SCSI transport interface.
     This interface may be a system specific adapter module of libburn or
     an adapter to a supporting library like libcdio.
-    @param flag  Bitfield for control puposes, submit 0 for now
-    @return      A pointer to the id string. Do not alter the string content.
+    @flag     Bitfield for control puposes, submit 0 for now
+    @return   A pointer to the id string. Do not alter the string content.
     @since 0.7.6
 */
 char *burn_scsi_transport_id(int flag);
@@ -2882,7 +2704,7 @@ int burn_msgs_set_severities(char *queue_severity,
                       "DEBUG", "ALL".
                       To call with minimum_severity "NEVER" will discard the
                       whole queue.
-    @param error_code Will become a unique error code as listed in
+    @param error_code Will become a unique error code as liste in
                       libburn/libdax_msgs.h
     @param msg_text   Must provide at least BURN_MSGS_MESSAGE_LEN bytes.
     @param os_errno   Will become the eventual errno related to the message
@@ -2955,82 +2777,30 @@ int burn_set_messenger(void *messenger);
 
 /* ts A61002 */
 /* @since 0.2.6 */
-/** The prototype of a handler function suitable for burn_set_signal_handling()
+/** 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);
 
-/** Control built-in signal handling. Either by setting an own handler or
-    by activating the built-in signal handler.
-
-    A function parameter handle of NULL activates the built-in abort handler. 
-    Depending on mode it may cancel all drive operations, wait for all drives
-    to become idle, exit(1). It may also prepare function
-    burn_drive_get_status() for waiting and performing exit(1). 
-    If parameter handle may be NULL or a text that shall be used as prefix for
-    pacifier messages of burn_abort_pacifier(). Other than with an application
-    provided handler, the prefix char array does not have to be kept existing
-    until the eventual signal event.
-    Before version 0.7.8 only action 0 was available. I.e. the built-in handler
-    waited for the drives to become idle and then performed exit(1) directly.
-    But during burn_disc_write() onto real CD or DVD, FreeBSD 8.0 pauses the
-    other threads until the signal handler returns.
-    The new actions try to avoid this deadlock. It is advised to use action 3
-    at least during burn_disc_write(), burn_disc_erase(), burn_disc_format():
-      burn_set_signal_handling(text, NULL, 0x30);
-    and to call burn_is_aborting(0) when the drive is BURN_DRIVE_IDLE.
-    If burn_is_aborting(0) returns 1, then call burn_abort() and exit(1).
-
+/** Control builtin signal handling. See also burn_abort().
     @param handle Opaque handle eventually pointing to an application
                   provided memory object
     @param handler A function to be called on signals. It will get handle as
-                  argument. flag will be 0.
-                  It should finally call burn_abort(). See there.
-    @param mode : bit0 - bit3:
-                    Receiving signals:
-                    0 Call handler(handle, signum, 0) on nearly all signals
-                    1 Enable system default reaction on all signals
-                    2 Try to ignore nearly all signals
-                   10 like mode 2 but handle SIGABRT like with mode 0
-                  bit4 - bit7: With handler == NULL :
-                    Action of built-in handler. "control thread" is the one
-                    which called burn_set_signal_handling().
-                    All actions activate receive mode 2 to ignore further
-                    signals.
-                    0 Same as 1 (for pre-0.7.8 backward compatibility)
-                    @since 0.7.8
-                    1 Catch the control thread in abort handler, call
-                      burn_abort(>0) and finally exit(1).
-                      Does not always work with FreeBSD.
-                    2 Call burn_abort(-1) and return from handler. When the
-                      control thread calls burn_drive_get_status(), then do
-                      burn_abort(>0) instead, and finally exit(1).
-                      Does not always work with FreeBSD.
-                    3 Call burn_abort(-1), return from handler. It is duty of
-                      the application to detect a pending abort condition
-                      by calling burn_is_aborting() and to wait for all
-                      drives to become idle. E.g. by calling burn_abort(>0).
-                    4 Like 3, but without calling burn_abort(-1). Only the
-                      indicator of burn_is_aborting() gets set.
+                  argument. It should finally call burn_abort(). See there.
+    @param mode : 0 call handler(handle, signum, 0) on nearly all signals
+                  1 enable system default reaction on all signals
+                  2 try to ignore nearly all signals
+                 10 like mode 2 but handle SIGABRT like with mode 0
+    Arguments (text, NULL, 0) activate the builtin abort handler. It will
+    eventually call burn_abort() and then perform exit(1). If text is not NULL
+    then it is used as prefix for pacifier messages of burn_abort_pacifier().
     @since 0.2.6
 */
 void burn_set_signal_handling(void *handle, burn_abort_handler_t handler, 
 			     int mode);
 
 
-/* ts B00304 */
-/* Inquire whether the built-in abort handler was triggered by a signal.
-   This has to be done to detect pending abort handling if signal handling
-   was set to the built-in handler and action was set to 2 or 3.
-   @param flag  Bitfield for control purposes (unused yet, submit 0)
-   @return    0 = no abort was triggered
-             >0 = action that was triggered (action 0 is reported as 1)
-   @since 0.7.8
-*/
-int burn_is_aborting(int flag);
-
-
 /* ts A70811 */
 /** Write data in random access mode.
     The drive must be grabbed successfully before calling this function which
@@ -3070,8 +2840,6 @@ int burn_random_access_write(struct burn_drive *d, off_t byte_address,
     can be read via burn_read_data() although some of them may never have been
     recorded. If tracks are recognizable then it is better to only read
     LBAs which are part of some track.
-    If the drive is actually a large file or block device, then the capacity
-    is curbed to a maximum of 0x7ffffff0 blocks = 4 TB - 32 KB.
     @param d            The drive from which to read
     @param capacity     Will return the result if valid
     @param flag         Bitfield for control purposes: Unused yet, submit 0.
@@ -3100,20 +2868,15 @@ int burn_get_read_capacity(struct burn_drive *d, int *capacity, int flag);
                         bit0= - reserved -
                         bit1= do not submit error message if read error
                         bit2= on error do not try to read a second time
-                              with single block steps.
-                              @since 0.5.2 
-                        bit3= return -2 on permission denied error rather than
-                              issueing a warning message.
-                              @since 1.0.6
+                              with single block steps. @since 0.5.2 
     @return 1=sucessful , <=0 an error occured
-                          with bit3:  -2= permission denied error
     @since 0.4.0
 */
 int burn_read_data(struct burn_drive *d, off_t byte_address,
                    char data[], off_t data_size, off_t *data_count, int flag);
 
 
-/* ts A70904 */
+/* 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
@@ -3121,49 +2884,11 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
                   1= real MMC drive
                   2= stdio-drive, random access, read-write
                   3= stdio-drive, sequential, write-only
-                  4= stdio-drive, random access, read-only
-                     (only if enabled by burn_allow_drive_role_4())
-                  5= stdio-drive, random access, write-only
-                     (only if enabled by burn_allow_drive_role_4())
     @since 0.4.0
 */
 int burn_drive_get_drive_role(struct burn_drive *d);
 
 
-/* ts B10312 */
-/** Allow drive role 4 "random access read-only"
-    and drive role 5 "random access write-only".
-    By default a random access file assumes drive role 2 "read-write"
-    regardless whether it is actually readable or writeable.
-    If enabled, random-access file objects which recognizably allow no
-    writing will be classified as role 4 and those which allow no reading
-    will get role 5.
-    Candidates are drive addresses of the form stdio:/dev/fd/# , where # is
-    the integer number of an open file descriptor. If this descriptor was
-    opened read-only resp. write-only, then it gets role 4 resp. role 5.
-    Other paths may get tested by an attempt to open them for read-write
-    (role 2) resp. read-only (role 4) resp. write-only (role 5). See bit1.
-    @param allowed      Bitfield for control purposes:
-                        bit0= Enable roles 4 and 5 for drives which get
-                              aquired after this call
-                        bit1= with bit0:
-                              Test whether the file can be opened for
-                              read-write resp. read-only resp. write-only.
-                              Classify as roles 2 resp. 4 resp. 5.
-                        bit2= with bit0 and bit1:
-                              Classify files which cannot be opened at all
-                              as role 0 : useless dummy.
-                              Else classify as role 2.
-                        bit3= Classify non-empty role 5 drives as
-                              BURN_DISC_APPENDABLE with Next Writeable Address
-                              after the end of the file. It is nevertheless
-                              possible to change this address by call
-                              burn_write_opts_set_start_byte().
-    @since 1.0.6
-*/
-void burn_allow_drive_role_4(int allowed);
-
-
 /* 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
@@ -3191,110 +2916,6 @@ void burn_allow_drive_role_4(int allowed);
 int burn_drive_equals_adr(struct burn_drive *d1, char *adr2, int drive_role2);
 
 
-
-/*
-  Audio track data extraction facility.
-*/
-
-/* Maximum size for address paths and fmt_info strings */
-#define LIBDAX_AUDIOXTR_STRLEN 4096
-
-
-/** Extractor object encapsulating intermediate states of extraction.
-    The clients of libdax_audioxtr shall only allocate pointers to this
-    struct and get a storage object via libdax_audioxtr_new().
-    Appropriate initial value for the pointer is NULL.
-*/
-struct libdax_audioxtr;
-
-
-/** Open an audio file, check wether suitable, create extractor object.
-    @param xtr Opaque handle to extractor. Gets attached extractor object.
-    @param path Address of the audio file to extract. "-" is stdin (but might
-                be not suitable for all futurely supported formats).
-    @param flag Bitfield for control purposes (unused yet, submit 0)
-    @return >0 success
-             0 unsuitable format
-            -1 severe error
-            -2 path not found
-    @since 0.2.4
-*/
-int libdax_audioxtr_new(struct libdax_audioxtr **xtr, char *path, int flag);
-
-
-/** Obtain identification parameters of opened audio source.
-    @param xtr Opaque handle to extractor
-    @param fmt Gets pointed to the audio file format id text: ".wav" , ".au"
-    @param fmt_info Gets pointed to a format info text telling parameters
-    @param num_channels     e.g. 1=mono, 2=stereo, etc
-    @param sample_rate      e.g. 11025, 44100
-    @param bits_per_sample  e.g. 8= 8 bits per sample, 16= 16 bits ...
-    @param msb_first Byte order of samples: 0=Intel 1=Motorola
-    @param flag Bitfield for control purposes (unused yet, submit 0)
-    @return >0 success, <=0 failure
-    @since 0.2.4
-*/
-int libdax_audioxtr_get_id(struct libdax_audioxtr *xtr,
-                           char **fmt, char **fmt_info,
-                           int *num_channels, int *sample_rate,
-                           int *bits_per_sample, int *msb_first, int flag);
-
-
-/** Obtain a prediction about the extracted size based on internal information
-    of the formatted file.
-    @param xtr Opaque handle to extractor
-    @param size Gets filled with the predicted size
-    @param flag Bitfield for control purposes (unused yet, submit 0)
-    @return 1 prediction was possible , 0 no prediction could be made
-    @since 0.2.4
-*/
-int libdax_audioxtr_get_size(struct libdax_audioxtr *o, off_t *size, int flag);
-
-
-/** Obtain next buffer full of extracted data in desired format (only raw audio
-    for now).
-    @param xtr Opaque handle to extractor
-    @param buffer Gets filled with extracted data
-    @param buffer_size Maximum number of bytes to be filled into buffer
-    @param flag Bitfield for control purposes
-                bit0= do not stop at predicted end of data
-    @return >0 number of valid buffer bytes,
-             0 End of file
-            -1 operating system reports error
-            -2 usage error by application
-    @since 0.2.4
-*/
-int libdax_audioxtr_read(struct libdax_audioxtr *xtr,
-                         char buffer[], int buffer_size, int flag);
-
-
-/** Try to obtain a file descriptor which will deliver extracted data
-    to normal calls of read(2). This may fail because the format is
-    unsuitable for that, but ".wav" is ok. If this call succeeds the xtr
-    object will have forgotten its file descriptor and libdax_audioxtr_read()
-    will return a usage error. One may use *fd after libdax_audioxtr_destroy()
-    and will have to close it via close(2) when done with it.
-    @param xtr Opaque handle to extractor
-    @param fd Eventually returns the file descriptor number
-    @param flag Bitfield for control purposes
-                bit0= do not dup(2) and close(2) but hand out original fd
-    @return 1 success, 0 cannot hand out fd , -1 severe error
-    @since 0.2.4
-*/
-int libdax_audioxtr_detach_fd(struct libdax_audioxtr *o, int *fd, int flag);
-
-
-/** Clean up after extraction and destroy extractor object.
-    @param xtr Opaque handle to extractor, *xtr is allowed to be NULL,
-               *xtr is set to NULL by this function
-    @param flag Bitfield for control purposes (unused yet, submit 0)
-    @return 1 = destroyed object, 0 = was already destroyed
-    @since 0.2.4
-*/
-int libdax_audioxtr_destroy(struct libdax_audioxtr **xtr, int flag);
-
-
-
 #ifndef DOXYGEN
 
 BURN_END_DECLS
@@ -3327,4 +2948,5 @@ BURN_END_DECLS
 #define Libburn_dummy_probe_write_modeS 1
 
 
+
 #endif /*LIBBURN_H*/

libburn/libburn.ver

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

libburn/libdax_audioxtr.c

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

libburn/libdax_audioxtr.h

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

libburn/libdax_msgs.c

@@ -2,13 +2,9 @@
 /* libdax_msgs
    Message handling facility of libdax.
    Copyright (C) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>,
-   provided under GPL version 2 or later.
+   provided under GPL
 */
 
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>
@@ -16,7 +12,6 @@
 #include <stdlib.h>
 #include <errno.h>
 #include <sys/time.h>
-#include <pthread.h>
 
 /* Only this single source module is entitled to do this */ 
 #define LIBDAX_MSGS_H_INTERNAL 1
@@ -37,7 +32,7 @@ static int libdax_msgs_item_new(struct libdax_msgs_item **item,
  struct timezone tz;
 
  (*item)= o= 
-        (struct libdax_msgs_item *) calloc(1, sizeof(struct libdax_msgs_item));
+           (struct libdax_msgs_item *) malloc(sizeof(struct libdax_msgs_item));
  if(o==NULL)
    return(-1);
  o->timestamp= 0.0;
@@ -140,7 +135,7 @@ int libdax_msgs_new(struct libdax_msgs **m, int flag)
 {
  struct libdax_msgs *o;
 
- (*m)= o= (struct libdax_msgs *) calloc(1, sizeof(struct libdax_msgs));
+ (*m)= o= (struct libdax_msgs *) malloc(sizeof(struct libdax_msgs));
  if(o==NULL)
    return(-1);
  o->refcount= 1;
@@ -370,7 +365,7 @@ int libdax_msgs_submit(struct libdax_msgs *m, int origin, int error_code,
  item->severity= severity;
  item->priority= priority;
  if(msg_text!=NULL) {
-   item->msg_text= calloc(1, strlen(msg_text)+1);
+   item->msg_text= malloc(strlen(msg_text)+1);
    if(item->msg_text==NULL)
      goto failed;
    strcpy(item->msg_text,msg_text);

libburn/libdax_msgs.h

@@ -1,8 +1,8 @@
 
 /* libdax_msgs
    Message handling facility of libdax.
-   Copyright (C) 2006-2011 Thomas Schmitt <scdbackup@gmx.net>,
-   provided under GPL version 2 or later.
+   Copyright (C) 2006-2010 Thomas Schmitt <scdbackup@gmx.net>,
+   provided under GPL
 */
 
 
@@ -395,7 +395,7 @@ int libdax_msgs_item_get_rank(struct libdax_msgs_item *item,
                               int *severity, int *priority, int flag);
 
 
-#ifdef LIBDAX_MSGS_________________
+#ifdef LIDBAX_MSGS_________________
 
 
                       /* Registered Error Codes */
@@ -434,8 +434,6 @@ Range "scdbackup"          :  0x00020000 to 0x0002ffff
  0x00020009 (SORRY,HIGH)   = Neither stdio-path nor its directory exist
  0x0002000a (FAILURE,HIGH) = Cannot accept '...' as SG_IO CDROM drive
  0x0002000b (FAILURE,HIGH) = File object '...' not found
- 0x0002000c (FAILURE,HIGH) = Cannot start device file enumeration
- 0x0002000d (FAILURE,HIGH) = Cannot enumerate next device
            
  General library operations:
 
@@ -519,7 +517,7 @@ Range "scdbackup"          :  0x00020000 to 0x0002ffff
  0x0002014d (SORRY,HIGH)   = Asynchromous SCSI error
  0x0002014f (SORRY,HIGH)   = Timeout with asynchromous SCSI command
  0x00020150 (DEBUG,LOW)    = Reporting asynchronous waiting time
- 0x00020151 (FAILURE,HIGH) = Read attempt on write-only drive
+ 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
@@ -556,24 +554,7 @@ Range "scdbackup"          :  0x00020000 to 0x0002ffff
  0x00020174 (SORRY,HIGH)   = Fifo alignment does not allow desired read size
  0x00020175 (FATAL,HIGH)   = Supporting library is too old
  0x00020176 (NOTE,HIGH)    = Stream recording disabled because of small OS buffer
- 0x00020177 (ABORT,HIGH)   = Urged drive worker threads to do emergency halt
- 0x00020178 (DEBUG,HIGH)   = Write thread ended
- 0x00020179 (FAILURE,HIGH) = Offset source start address is before end of previous source
- 0x0002017a (FAILURE,HIGH) = Expected offset source object as parameter
- 0x0002017b (WARNING,HIGH) = Sequential BD-R media likely to soon fail writing
- 0x0002017c (FAILURE,HIGH) = No valid write type selected
- 0x0002017d (FATAL,HIGH)   = Invalid file descriptor with stdio pseudo-drive
- 0x0002017e (FAILURE,HIGH) = Failed to close track, session, or disc
- 0x0002017f (FAILURE,HIGH) = Failed to synchronize drive cache
- 0x00020180 (FAILURE,HIGH) = Premature end of input encountered
- 0x00020181 (FAILURE,HIGH) = Pseudo-drive is a read-only file. Cannot write.
- 0x00020182 (FAILURE,HIGH) = Cannot truncate disk file for pseudo blanking
- 0x00020183 (WARNING,HIGH) = Failed to open device (a pseudo-drive) for reading
- 0x00020184 (WARNING,HIGH) = No Next-Writable-Address
- 0x00020185 (WARNING,HIGH) = Track damaged, not closed and not writable
- 0x00020186 (WARNING,HIGH) = Track damaged and not closed
- 0x00020187 (NOTE,HIGH)    = Track not marked as damaged. No action taken.
- 0x00020188 (FAILURE,HIGH) = Cannot close damaged track on given media type
+ 
 
  libdax_audioxtr:
  0x00020200 (SORRY,HIGH)   = Cannot open audio source file
@@ -694,7 +675,7 @@ Range "libisoburn"          :  0x00060000 to 0x00006ffff
 
 ------------------------------------------------------------------------------
 
-#endif /* LIBDAX_MSGS_________________ */
+#endif /* LIDBAX_MSGS_________________ */
 
 
 

libburn/mmc.h

@@ -1,11 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-
 #ifndef __MMC
 #define __MMC
 
@@ -106,13 +100,5 @@ int mmc_function_spy(struct burn_drive *d, char * text);
 /* ts A91118 */
 int mmc_start_if_needed(struct burn_drive *d, int flag);
 
-/* ts B00924 */
-int mmc_get_bd_spare_info(struct burn_drive *d,
-                                int *alloc_blocks, int *free_blocks, int flag);
-
-/* ts B10801 */
-int mmc_get_phys_format_info(struct burn_drive *d, int *disk_category,
-                        char **book_name, int *part_version, int *num_layers,
-                        int *num_blocks, int flag);
 
 #endif /*__MMC*/

libburn/null.c

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

libburn/options.c

@@ -1,13 +1,3 @@
-
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 #include "libburn.h"
 #include "options.h"
 #include "drive.h"
@@ -27,7 +17,7 @@ struct burn_write_opts *burn_write_opts_new(struct burn_drive *drive)
 {
 	struct burn_write_opts *opts;
 
-	opts = calloc(1, sizeof(struct burn_write_opts));
+	opts = malloc(sizeof(struct burn_write_opts));
 	if (opts == NULL) {
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020111,
 			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
@@ -68,7 +58,7 @@ struct burn_read_opts *burn_read_opts_new(struct burn_drive *drive)
 {
 	struct burn_read_opts *opts;
 
-	opts = calloc(1, sizeof(struct burn_read_opts));
+	opts = malloc(sizeof(struct burn_read_opts));
 	opts->drive = drive;
 	opts->refcount = 1;
 	opts->raw = 0;
@@ -125,7 +115,7 @@ void burn_write_opts_set_toc_entries(struct burn_write_opts *opts, int count,
 				     struct burn_toc_entry *toc_entries)
 {
 	opts->toc_entries = count;
-	opts->toc_entry = calloc(count, sizeof(struct burn_toc_entry));
+	opts->toc_entry = malloc(count * sizeof(struct burn_toc_entry));
 	memcpy(opts->toc_entry, &toc_entries,
 	       sizeof(struct burn_toc_entry) * count);
 }

libburn/options.h

@@ -1,9 +1,3 @@
-
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
 #ifndef BURN__OPTIONS_H
 #define BURN__OPTIONS_H
 

libburn/os-dummy.h

@@ -5,7 +5,7 @@
            Unknown POSIX like systems
            with the dummy MMC transport adapter sg-dummy.c
 
-   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
+   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
 */
 
 
@@ -29,37 +29,12 @@
 /* The number of above list items */
 #define BURN_OS_SIGNAL_COUNT 16
 
-/** The list of all signals which shall surely not be caught.
-    It depends on the particular signal whether it can be ignored or whether
-    it will lead to sudden death of the process.
-    Some signals are not POSIX,
-    but nevertheless ought to be ignored if they are defined.
-*/
-
-#ifdef SIGWINCH
-#define BURN_OS_SIG_WINCH ,SIGWINCH
-#define BURN_OS_SIG_WINCH_CNT 1
-#else
-#define BURN_OS_SIG_WINCH 
-#define BURN_OS_SIG_WINCH_CNT 0
-#endif
-
-#ifdef SIGURG
-#define BURN_OS_SIG_URG ,SIGURG
-#define BURN_OS_SIG_URG_CNT 1
-#else
-#define BURN_OS_SIG_URG 
-#define BURN_OS_SIG_URG_CNT 0
-#endif
-
-/** The combined list of all signals which shall not be caught.
- */
+/** To list all signals which shall surely not be caught */
 #define BURN_OS_NON_SIGNAL_MACRO_LIST \
-SIGKILL, SIGCHLD, SIGSTOP BURN_OS_SIG_WINCH BURN_OS_SIG_URG
+SIGKILL, SIGCHLD, SIGSTOP
 
 /* The number of above list items */
-#define BURN_OS_NON_SIGNAL_COUNT \
-( 3 + BURN_OS_SIG_WINCH_CNT + BURN_OS_SIG_URG_CNT )
+#define BURN_OS_NON_SIGNAL_COUNT 3
 
 
 /* The maximum size for a (SCSI) i/o transaction */

libburn/os-freebsd.h

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

libburn/os-libcdio.h

@@ -5,7 +5,7 @@
            Unknown X/Open-like systems
            with GNU libcdio MMC transport adapter sg-libcdio.c
 
-   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
+   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
 */
 
 
@@ -29,49 +29,26 @@
 /* The number of above list items */
 #define BURN_OS_SIGNAL_COUNT 16
 
-
-/** The list of all signals which shall surely not be caught.
-    It depends on the particular signal whether it can be ignored or whether
-    it will lead to sudden death of the process.
-    Some signals are not POSIX,
-    but nevertheless ought to be ignored if they are defined.
-*/
-
-#ifdef SIGWINCH
-#define BURN_OS_SIG_WINCH ,SIGWINCH
-#define BURN_OS_SIG_WINCH_CNT 1
-#else
-#define BURN_OS_SIG_WINCH 
-#define BURN_OS_SIG_WINCH_CNT 0
-#endif
-
-#ifdef SIGURG
-#define BURN_OS_SIG_URG ,SIGURG
-#define BURN_OS_SIG_URG_CNT 1
-#else
-#define BURN_OS_SIG_URG 
-#define BURN_OS_SIG_URG_CNT 0
-#endif
-
-/** The combined list of all signals which shall not be caught.
- */
+/** To list all signals which shall surely not be caught */
 #define BURN_OS_NON_SIGNAL_MACRO_LIST \
-SIGKILL, SIGCHLD, SIGSTOP BURN_OS_SIG_WINCH BURN_OS_SIG_URG
+SIGKILL, SIGCHLD, SIGSTOP
 
 /* The number of above list items */
-#define BURN_OS_NON_SIGNAL_COUNT \
-( 3 + BURN_OS_SIG_WINCH_CNT + BURN_OS_SIG_URG_CNT )
+#define BURN_OS_NON_SIGNAL_COUNT 3
 
 
 /* The maximum size for a (SCSI) i/o transaction */
+/* Important : MUST be at least 32768 ! */
 /* My Blu-ray burner LG GGW-H20 writes junk if stream recording is combined
    with buffer size 32 kB. So stream recording is allowed only with size 64k.
-   Older BSD info says that 32 kB is maximum. But 64 kB seems to work well
-   on 8-STABLE. It is by default only used with BD in streaming mode.
-   So older systems should still be quite safe with this buffer max size.
+   This makes it worth to have a special case for Linux buffer size here.
 */
-/* Important : MUST be at least 32768 ! */
+#ifdef __linux
 #define BURN_OS_TRANSPORT_BUFFER_SIZE 65536
+#else
+/* (It might be risky to use 64k. FreeBSD is said to can only 32k.) */
+#define BURN_OS_TRANSPORT_BUFFER_SIZE 32768
+#endif
 
 
 /* To hold the position of the most recently delivered address from

libburn/os-linux.h

@@ -2,10 +2,9 @@
 /* os-linux.h
    Operating system specific libburn definitions and declarations. Included
    by os.h in case of compilation for
-           Linux kernels 2.4 and 2.6, GNU/Linux SCSI Generic (sg)
+           Linux kernels 2.4 and 2.6 with Linux SCSI Generic (sg)
 
-   Copyright (C) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
+   Copyright (C) 2006 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
 */
 
 

libburn/os-solaris.h

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

libburn/os.h

@@ -3,7 +3,7 @@
    Operating system specific libburn definitions and declarations.
    The macros defined here are used by libburn modules in order to
    avoid own system dependent case distinctions.
-   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
+   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
 */
 
 #ifndef BURN_OS_H_INCLUDED
@@ -14,14 +14,6 @@
 */
 
 
-#ifdef Libburn_use_sg_dummY
-
-
-/* --------- Any other system. With dummy MMC transport sg-dummy.c --------- */
-#include "os-dummy.h"
-
-
-#else
 #ifdef Libburn_use_libcdiO
 
 
@@ -49,18 +41,10 @@
 #ifdef __linux
 
 
-/* ------- Linux kernels 2.4 and 2.6 with GNU/Linux SCSI Generic (sg) ------ */
+/* --------- Linux kernels 2.4 and 2.6 with Linux SCSI Generic (sg) -------- */
 #include "os-linux.h"
 
 
-#else
-#ifdef __sun
-
-
-/* ------- Solaris (e.g. SunOS 5.11) with uscsi ------ */
-#include "os-solaris.h"
-
-
 #else
 
 
@@ -68,12 +52,10 @@
 #include "os-dummy.h"
 
 
-#endif /* ! __sun*/
 #endif /* ! __linux */
 #endif /* ! __FreeBSD__kernel__ */
 #endif /* ! __FreeBSD__ */
 #endif /* ! Libburn_use_libcdiO */
-#endif /* ! Libburn_use_sg_dummY */
 
 
 #endif /* ! BURN_OS_H_INCLUDED */

libburn/read.c

@@ -1,13 +1,6 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
+/* #include <m alloc.h>  ts A61013 : not in Linux man 3 malloc */
 
 #include <stdlib.h>
 #include <unistd.h>
@@ -54,7 +47,7 @@ void burn_disc_read(struct burn_drive *d, const struct burn_read_opts *o)
 	int drive_lba;
 	unsigned short crc;
 	unsigned char fakesub[96];
-	struct buffer page;  <- needs to become dynamic memory
+	struct buffer page;
 	int speed;
 
 	/* ts A61007 : if this function gets revived, then these
@@ -101,13 +94,7 @@ drive, or only store a subset of the _opts structs in drives */
 		fakesub[20] = 2;
 		fakesub[12] = (d->toc->toc_entry[0].control << 4) +
 			d->toc->toc_entry[0].adr;
-
-#ifdef Libburn_no_crc_C
-		crc = 0; /* dummy */
-#else
 		crc = crc_ccitt(fakesub + 12, 10);
-#endif
-
 		fakesub[22] = crc >> 8;
 		fakesub[23] = crc & 0xFF;
 		write(o->subfd, fakesub, 96);
@@ -205,11 +192,9 @@ void burn_packet_process(struct burn_drive *d, unsigned char *data,
 			 const struct burn_read_opts *o)
 {
 	unsigned char sub[96];
+	unsigned short crc;
 	int ptr = 2352, i, j, code, fb;
 	int audio = 1;
-#ifndef Libburn_no_crc_C
-	unsigned short crc;
-#endif
 
 	if (o->c2errors) {
 		fb = bitcount(data + ptr, 294);
@@ -255,8 +240,6 @@ void burn_packet_process(struct burn_drive *d, unsigned char *data,
 				}
 			}
 		}
-
-#ifndef Libburn_no_crc_C
 		crc = (*(sub + 22) << 8) + *(sub + 23);
 		if (crc != crc_ccitt(sub + 12, 10)) {
 			burn_print(1, "sending error on %s %s\n",
@@ -266,8 +249,6 @@ void burn_packet_process(struct burn_drive *d, unsigned char *data,
 */
 			burn_print(1, "crc mismatch in Q\n");
 		}
-#endif
-
 		/* else process_q(d, sub + 12); */
 		/* 
 		   if (o->subfd != -1) write(o->subfd, sub, 96); */
@@ -288,12 +269,8 @@ void burn_packet_process(struct burn_drive *d, unsigned char *data,
 /*  so yeah, when you uncomment these, make them write zeros insted of crap
 static void write_empty_sector(int fd)
 {
-	static char sec[2352], initialized = 0;
+	char sec[2352];
 
-	if (!initialized) {
-		memset(sec, 0, 2352);
-		initialized = 1;
-	}
 	burn_print(1, "writing an 'empty' sector\n");
 	write(fd, sec, 2352);
 }
@@ -345,7 +322,7 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
 	int alignment = 2048, start, upto, chunksize = 1, err, cpy_size, i;
 	int sose_mem = 0, fd = -1, ret;
 	char msg[81], *wpt;
-	struct buffer *buf = NULL, *buffer_mem = d->buffer;
+	struct buffer buf, *buffer_mem = d->buffer;
 
 /*
 #define Libburn_read_data_adr_logginG 1
@@ -359,7 +336,7 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
 		fprintf(log_fp, "%d\n", (int) (byte_address / 2048));
 #endif /* Libburn_read_data_logginG */
 
-	BURN_ALLOC_MEM(buf, struct buffer, 1);
+
 	*data_count = 0;
 	sose_mem = d->silent_on_scsi_error;
 
@@ -368,20 +345,20 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
 			d->global_index, 0x00020142,
 			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 			"Drive is not grabbed on random access read", 0, 0);
-		{ret = 0; goto ex;}
+		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);
-		{ret = 0; goto ex;}
+		return 0;
 	} else if (d->drive_role == 3) {
 		libdax_msgs_submit(libdax_messenger, d->global_index,
 			0x00020151,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
+			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 			"Read attempt on write-only drive", 0, 0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 	if ((byte_address % alignment) != 0) {
 		sprintf(msg,
@@ -391,7 +368,7 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
 			0x00020143,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			msg, 0, 0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 	if (d->media_read_capacity != 0x7fffffff && byte_address >=
 		((off_t) d->media_read_capacity + (off_t) 1) * (off_t) 2048) {
@@ -405,7 +382,7 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
 				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 				msg, 0, 0);
 		}
-		{ret = 0; goto ex;}
+		return 0;
 	}
 
 	if (d->busy != BURN_DRIVE_IDLE) {
@@ -413,7 +390,7 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
 			d->global_index, 0x00020145,
 			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 			"Drive is busy on attempt to read data", 0, 0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 
 	if (d->drive_role != 1) {
@@ -429,41 +406,28 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
 			d->stdio_fd = fd =
 				open(d->devname, O_RDONLY | O_LARGEFILE);
 		if (fd == -1) {
-			if (errno == EACCES && (flag & 2)) {
-				if (!(flag & 8))
-					libdax_msgs_submit(libdax_messenger,
-					  d->global_index, 0x00020183,
-					  LIBDAX_MSGS_SEV_WARNING,
-					  LIBDAX_MSGS_PRIO_HIGH,
-			  "Failed to open device (a pseudo-drive) for reading",
-					  errno, 0);
-			} else if (errno!= ENOENT || !(flag & 2))
+			if (errno != ENOENT  || !(flag & 2))
 				libdax_msgs_submit(libdax_messenger,
-				  d->global_index, 0x00020005,
+				  d->global_index,
+				  0x00020005,
 				  LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			  "Failed to open device (a pseudo-drive) for reading",
 				   errno, 0);
-			ret = 0;
-			if (errno == EACCES && (flag & 8))
-				ret= -2;
-			goto ex;
+			ret = 0; goto ex;
 		}
 		if (lseek(fd, byte_address, SEEK_SET) == -1) {
-			if (!(flag & 2)) {
-				sprintf(msg, "Cannot address start byte %.f",
-					(double) byte_address);
+			if (!(flag & 2))
 				libdax_msgs_submit(libdax_messenger,
 				  d->global_index,
 				  0x00020147,
 				  LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
-				  msg, errno, 0);
-			}
+				  "Cannot address start byte", errno, 0);
 			ret = 0; goto ex;
 		}
 	}
 
 	d->busy = BURN_DRIVE_READING_SYNC;
-	d->buffer = buf;
+	d->buffer = &buf;
 
 	start = byte_address / 2048;
 	upto = start + data_size / 2048;
@@ -530,7 +494,10 @@ int burn_read_data(struct burn_drive *d, off_t byte_address,
 
 	ret = 1;
 ex:;
-	BURN_FREE_MEM(buf);
+/* <<< let it open until drive is given up or writing shall happen
+	if (fd != -1)
+		close(fd);
+*/
 	d->buffer = buffer_mem;
 	d->busy = BURN_DRIVE_IDLE;
 	return ret;

libburn/sbc.c

@@ -2,15 +2,6 @@
 
 /* scsi block commands */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 #include <string.h>
 #include <unistd.h>
 
@@ -54,21 +45,20 @@ static unsigned char SBC_STOP_UNIT[] = { 0x1b, 0, 0, 0, 0, 0 };
 
 void sbc_load(struct burn_drive *d)
 {
-	struct command *c;
+	struct command c;
 
-	c = &(d->casual_command);
 	if (mmc_function_spy(d, "load") <= 0)
 		return;
 
-	scsi_init_command(c, SBC_LOAD, sizeof(SBC_LOAD));
-	c->retry = 1;
+	scsi_init_command(&c, SBC_LOAD, sizeof(SBC_LOAD));
+	c.retry = 1;
 
 	/* ts A70921 : Had to revoke Immed because of LG GSA-4082B */
-	/* c->opcode[1] |= 1; / * ts A70918 : Immed */
+	/* c.opcode[1] |= 1; / * ts A70918 : Immed */
 
-	c->dir = NO_TRANSFER;
-	d->issue_command(d, c);
-	if (c->error)
+	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
@@ -78,21 +68,20 @@ void sbc_load(struct burn_drive *d)
 
 void sbc_eject(struct burn_drive *d)
 {
-	struct command *c;
+	struct command c;
 
-	c = &(d->casual_command);
 	if (mmc_function_spy(d, "eject") <= 0)
 		return;
 
-	scsi_init_command(c, SBC_UNLOAD, sizeof(SBC_UNLOAD));
-	/* c->opcode[1] |= 1; / * ts A70918 : Immed , ts B00109 : revoked */
-	c->page = NULL;
-	c->dir = NO_TRANSFER;
-	d->issue_command(d, c);
+	scsi_init_command(&c, SBC_UNLOAD, sizeof(SBC_UNLOAD));
+	/* c.opcode[1] |= 1; / * ts A70918 : Immed , ts B00109 : revoked */
+	c.page = NULL;
+	c.dir = NO_TRANSFER;
+	d->issue_command(d, &c);
 	/* ts A70918 : Wait long. A late eject could surprise or hurt user.
 	   ts B00109 : Asynchronous eject revoked, as one cannot reliably
 	               distinguish out from unready.
-	if (c->error)
+	if (c.error)
 		return;
 	spc_wait_unit_attention(d, 1800, "STOP UNIT (+ EJECT)", 0);
 	*/
@@ -104,19 +93,18 @@ void sbc_eject(struct burn_drive *d)
 */
 int sbc_start_unit_flag(struct burn_drive *d, int flag)
 {
-	struct command *c;
+	struct command c;
 	int ret;
 
-	c = &(d->casual_command);
 	if (mmc_function_spy(d, "start_unit") <= 0)
 		return 0;
 
-	scsi_init_command(c, SBC_START_UNIT, sizeof(SBC_START_UNIT));
-	c->retry = 1;
-	c->opcode[1] |= (flag & 1); /* ts A70918 : Immed */
-	c->dir = NO_TRANSFER;
-	d->issue_command(d, c);
-	if (c->error)
+	scsi_init_command(&c, SBC_START_UNIT, sizeof(SBC_START_UNIT));
+	c.retry = 1;
+	c.opcode[1] |= (flag & 1); /* ts A70918 : Immed */
+	c.dir = NO_TRANSFER;
+	d->issue_command(d, &c);
+	if (c.error)
 		return 0;
 	if (!(flag & 1))
 		return 1;
@@ -147,19 +135,18 @@ int sbc_start_unit(struct burn_drive *d)
 /* ts A90824 : Trying to reduce drive noise */
 int sbc_stop_unit(struct burn_drive *d)
 {
-	struct command *c;
+	struct command c;
 	int ret;
 
-	c = &(d->casual_command);
 	if (mmc_function_spy(d, "stop_unit") <= 0)
 		return 0;
 
-	scsi_init_command(c, SBC_STOP_UNIT, sizeof(SBC_STOP_UNIT));
-	c->retry = 0;
-	c->opcode[1] |= 1; /* Immed */
-	c->dir = NO_TRANSFER;
-	d->issue_command(d, c);
-	if (c->error)
+	scsi_init_command(&c, SBC_STOP_UNIT, sizeof(SBC_STOP_UNIT));
+	c.retry = 0;
+	c.opcode[1] |= 1; /* Immed */
+	c.dir = NO_TRANSFER;
+	d->issue_command(d, &c);
+	if (c.error)
 		return 0;
 	ret = spc_wait_unit_attention(d, 1800, "STOP UNIT", 0);
 	d->is_stopped = 1;

libburn/sbc.h

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

libburn/sector.c

@@ -1,14 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 #include <stdio.h>
 
 /* ts A61010 */
@@ -34,7 +25,7 @@ extern struct libdax_msgs *libdax_messenger;
 
 
 #ifdef Libburn_log_in_and_out_streaM
-/* ts A61031 */
+/* <<< ts A61031 */
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -105,7 +96,7 @@ static void get_bytes(struct burn_track *track, int count, unsigned char *data)
 	int valid, shortage, curr, i, tr;
 
 #ifdef Libburn_log_in_and_out_streaM 
-        /* ts A61031 */
+        /* <<< ts A61031 */
         static int tee_fd= -1;
         if(tee_fd==-1)
                 tee_fd= open("/tmp/libburn_sg_readin",
@@ -151,7 +142,7 @@ static void get_bytes(struct burn_track *track, int count, unsigned char *data)
 	track->sourcecount += valid;
 
 #ifdef Libburn_log_in_and_out_streaM
-	/* ts A61031 */
+	/* <<< ts A61031 */
         if(tee_fd!=-1 && valid>0) {
                 write(tee_fd, data + curr, valid);
         }
@@ -179,22 +170,10 @@ static void get_bytes(struct burn_track *track, int count, unsigned char *data)
 	if (!shortage)
 		goto ex;
 
-	/* ts A61031 - B10103 */
+	/* ts A61031 */
 	if (shortage >= count)
 		track->track_data_done = 1;
-	if (track->end_on_premature_eoi && shortage >= count &&
-	    !track->open_ended) {
-		char msg[80];
-		/* Memorize that premature end of input happened */
-		sprintf(msg,
-		    "Premature end of input encountered. Missing: %d bytes",
-		    shortage);
-		libdax_msgs_submit(libdax_messenger, -1, 0x00020180,
-				LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
-				msg, 0,0);
-		track->end_on_premature_eoi = 2;
-	}
-	if (track->open_ended || track->end_on_premature_eoi)
+	if (track->open_ended)
 		goto ex;
 
 /* If we're still short, and there's a "next" pointer, we pull from that.
@@ -426,13 +405,7 @@ a2 - lout ctrl
 	q[7] = dec_to_bcd(d->toc_entry[track].pmin);
 	q[8] = dec_to_bcd(d->toc_entry[track].psec);
 	q[9] = dec_to_bcd(d->toc_entry[track].pframe);
-
-#ifdef Libburn_no_crc_C
-	crc = 0; /* dummy */
-#else
 	crc = crc_ccitt(q, 10);
-#endif
-
 	q[10] = crc >> 8;
 	q[11] = crc & 0xFF;
 	d->toc_temp++;
@@ -529,13 +502,7 @@ static void subcode_lout(struct burn_write_opts *o, unsigned char control,
 	q[7] = dec_to_bcd(min);
 	q[8] = dec_to_bcd(sec);
 	q[9] = dec_to_bcd(frame);
-
-#ifdef Libburn_no_crc_C
-	crc = 0; /* dummy */
-#else
 	crc = crc_ccitt(q, 10);
-#endif
-
 	q[10] = crc >> 8;
 	q[11] = crc & 0xFF;
 }
@@ -655,13 +622,7 @@ void subcode_user(struct burn_write_opts *o, unsigned char *subcodes,
 	}
 	q[0] = (control << 4) + qmode;
 
-
-#ifdef Libburn_no_crc_C
-	crc = 0; /* dummy */
-#else
 	crc = crc_ccitt(q, 10);
-#endif
-
 	q[10] = crc >> 8;
 	q[11] = crc & 0xff;
 }
@@ -693,14 +654,14 @@ int sector_data(struct burn_write_opts *o, struct burn_track *t, int psub)
 	unsigned char *data;
 
 	data = get_sector(o, t, t->mode);
-	if (data == NULL)
+	if (!data)
 		return 0;
 	/* ts A61010 */
 	if (convert_data(o, t, t->mode, data) <= 0)
 		return 0;
 
 	/* ts A61031 */
-	if ((t->open_ended || t->end_on_premature_eoi) && t->track_data_done) {
+	if (t->open_ended && t->track_data_done) {
 		unget_sector(o, t->mode);
 		return 2;
 	}
@@ -807,13 +768,7 @@ int sector_headers(struct burn_write_opts *o, unsigned char *out,
 		out[15] = modebyte;
 	}
 	if (mode & BURN_MODE1) {
-
-#ifdef Libburn_no_crc_C
-		crc = 0; /* dummy */
-#else
 		crc = crc_32(out, 2064);
-#endif
-
 		out[2064] = crc & 0xFF;
 		crc >>= 8;
 		out[2065] = crc & 0xFF;

libburn/sector.h

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

libburn/sg-dummy.c

@@ -1,15 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* 
-   Copyright (c) 2009 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
-
 /*
 
 This is the main operating system dependent SCSI part of libburn. It implements
@@ -44,7 +34,6 @@ Present implementation: default dummy which enables libburn only to work
 #include "debug.h"
 #include "toc.h"
 #include "util.h"
-#include "init.h"
 
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
@@ -252,13 +241,12 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 	struct statvfs vfsbuf;
 #endif
 
-	char *testpath = NULL, *cpt;
+	char testpath[4096], *cpt;
+	long blocks;
 	off_t add_size = 0;
-	int ret;
-
-	BURN_ALLOC_MEM(testpath, char, 4096);
 
 	testpath[0] = 0;
+	blocks = *bytes / 512;
 	if (stat(path, &stbuf) == -1) {
 		strcpy(testpath, path);
 		cpt = strrchr(testpath, '/');
@@ -269,21 +257,18 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 		else
 			*cpt = 0;
 		if (stat(testpath, &stbuf) == -1)
-			{ret = -1; goto ex;}
+			return -1;
 
 #ifdef Libburn_if_this_was_linuX
 
 	} else if(S_ISBLK(stbuf.st_mode)) {
-		long blocks;
-
-		blocks = *bytes / 512;
 		fd = open(path, open_mode);
 		if (fd == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		ret = ioctl(fd, BLKGETSIZE, &blocks);
 		close(fd);
 		if (ret == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = ((off_t) blocks) * (off_t) 512;
 
 #endif /* Libburn_if_this_was_linuX */
@@ -292,28 +277,25 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 		add_size = stbuf.st_blocks * (off_t) 512;
 		strcpy(testpath, path);
 	} else
-		{ret = 0; goto ex;}
+		return 0;
 
 	if (testpath[0]) {	
 
 #ifdef Libburn_os_has_statvfS
 
 		if (statvfs(testpath, &vfsbuf) == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
 						(off_t) vfsbuf.f_bavail;
 
 #else /* Libburn_os_has_statvfS */
 
-		{ret = 0; goto ex;}
+		return 0;
 
 #endif /* ! Libburn_os_has_stavtfS */
 
 	}
-	ret = 1;
-ex:;
-	BURN_FREE_MEM(testpath);
-	return ret;
+	return 1;
 }
 
 

libburn/sg-freebsd-port.c

@@ -1,14 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/*
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-
-                  /* THIS CODE IS NOT FUNCTIONAL YET !!! */
-
-
 /*
 
 This is the main operating system dependent SCSI part of libburn. It implements
@@ -98,10 +89,6 @@ Send feedback to libburn-hackers@pykix.org .
 
 */
 
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 
 /** PORTING : ------- OS dependent headers and definitions ------ */
 
@@ -163,7 +150,7 @@ static int sg_init_enumerator(burn_drive_enumerator_t *idx)
 		return -1;
 	}
 
-	memset(&(idx->ccb), 0, sizeof(union ccb));
+	bzero(&(idx->ccb), sizeof(union ccb));
 
 	idx->ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
 	idx->ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
@@ -172,10 +159,9 @@ static int sg_init_enumerator(burn_drive_enumerator_t *idx)
 	idx->ccb.ccb_h.func_code = XPT_DEV_MATCH;
 	idx->bufsize = sizeof(struct dev_match_result) * 100;
 	idx->ccb.cdm.match_buf_len = idx->bufsize;
-	idx->ccb.cdm.matches = (struct dev_match_result *)
-						calloc(1, idx->bufsize);
+	idx->ccb.cdm.matches = (struct dev_match_result *)malloc(idx->bufsize);
 	if (idx->ccb.cdm.matches == NULL) {
-		warnx("cannot allocate memory for matches");
+		warnx("can't malloc memory for matches");
 		close(idx->fd);
 		return -1;
 	}
@@ -723,12 +709,13 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 {
 	struct stat stbuf;
 	struct statvfs vfsbuf;
-	char *testpath = NULL, *cpt;
+	char testpath[4096], *cpt;
+	long blocks;
+	int open_mode = O_RDWR, fd, ret;
 	off_t add_size = 0;
-	int fd, ret;
 
-	BURN_ALLOC_MEM(testpath, char, 4096);
 	testpath[0] = 0;
+	blocks = *bytes / 512;
 	if (stat(path, &stbuf) == -1) {
 		strcpy(testpath, path);
 		cpt = strrchr(testpath, '/');
@@ -739,54 +726,38 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 		else
 			*cpt = 0;
 		if (stat(testpath, &stbuf) == -1)
-			{ret = -1; goto ex;}
+			return -1;
 
 #ifdef Libburn_if_this_was_linuX
 
 	} else if(S_ISBLK(stbuf.st_mode)) {
-		int open_mode = O_RDWR, fd, ret;
-		long blocks;
-
-		blocks = *bytes / 512;
 		if(burn_sg_open_o_excl)
 			open_mode |= O_EXCL;
 		fd = open(path, open_mode);
 		if (fd == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		ret = ioctl(fd, BLKGETSIZE, &blocks);
 		close(fd);
 		if (ret == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = ((off_t) blocks) * (off_t) 512;
 
 #endif /* Libburn_if_this_was_linuX */
 
 
-	} else if(S_ISCHR(stbuf.st_mode)) {
-		fd = open(path, O_RDONLY);
-		if (fd == -1)
-			{ret = -2; goto ex;}
-		ret = ioctl(fd, DIOCGMEDIASIZE, &add_size);
-		close(fd);
-		if (ret == -1)
-			{ret = -2; goto ex;}
-		*bytes = add_size;
 	} else if(S_ISREG(stbuf.st_mode)) {
 		add_size = stbuf.st_blocks * (off_t) 512;
 		strcpy(testpath, path);
 	} else
-		{ret = 0; goto ex;}
+		return 0;
 
 	if (testpath[0]) {	
 		if (statvfs(testpath, &vfsbuf) == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
 						(off_t) vfsbuf.f_bavail;
 	}
-	ret = 1;
-ex:
-	BURN_FREE_MEM(testpath);
-	return ret;
+	return 1;
 }
 
 

libburn/sg-freebsd.c

@@ -1,15 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* 
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later
-        and under FreeBSD license revised, i.e. without advertising clause.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 #include <errno.h>
 #include <unistd.h>
 #include <stdio.h>
@@ -34,18 +24,6 @@
 #include <sys/disk.h> /* DIOCGMEDIASIZE */
 
 
-/* ts B00326 : For use of CAM_PASS_ERR_RECOVER with ahci */
-#define Libburn_for_freebsd_ahcI yes
-
-/* ts B00327 : for debugging of cam_send_cdb() failures
- # define Libburn_ahci_verbouS yes
-*/
-
-/* ts B00327 : Apply CAM_PASS_ERR_RECOVER to drives even if not ahci
- # define libburn_ahci_style_for_alL yes
-*/
-
-
 #include "transport.h"
 #include "drive.h"
 #include "sg.h"
@@ -55,7 +33,6 @@
 #include "debug.h"
 #include "toc.h"
 #include "util.h"
-#include "init.h"
 
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
@@ -162,21 +139,21 @@ static int sg_init_enumerator(burn_drive_enumerator_t *idx_)
 	struct burn_drive_enumeration_state *idx;
 	int bufsize;
 
-	idx = calloc(1, sizeof(*idx));
+	idx = malloc(sizeof(*idx));
 	if (idx == NULL) {
-		warnx("cannot allocate memory for enumerator");
+		warnx("can't malloc memory for enumerator");
 		return -1;
 	}
 	idx->skip_device = 0;
 
 	if ((idx->fd = open(XPT_DEVICE, O_RDWR)) == -1) {
-		warn("could not open %s", XPT_DEVICE);
+		warn("couldn't open %s", XPT_DEVICE);
 		free(idx);
 		idx = NULL;
 		return -1;
 	}
 
-	memset(&(idx->ccb), 0, sizeof(union ccb));
+	bzero(&(idx->ccb), sizeof(union ccb));
 
 	idx->ccb.ccb_h.path_id = CAM_XPT_PATH_ID;
 	idx->ccb.ccb_h.target_id = CAM_TARGET_WILDCARD;
@@ -185,9 +162,9 @@ static int sg_init_enumerator(burn_drive_enumerator_t *idx_)
 	idx->ccb.ccb_h.func_code = XPT_DEV_MATCH;
 	bufsize = sizeof(struct dev_match_result) * 100;
 	idx->ccb.cdm.match_buf_len = bufsize;
-	idx->ccb.cdm.matches = (struct dev_match_result *) calloc(1, bufsize);
+	idx->ccb.cdm.matches = (struct dev_match_result *)malloc(bufsize);
 	if (idx->ccb.cdm.matches == NULL) {
-		warnx("cannot allocate memory for matches");
+		warnx("can't malloc memory for matches");
 		close(idx->fd);
 		free(idx);
 		return -1;
@@ -452,7 +429,6 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 
 	out.cam = NULL;
 	out.lock_fd = -1;
-	out.is_ahci = 0;
 
 	out.start_lba= -2000000000;
 	out.end_lba= -2000000000;
@@ -489,9 +465,9 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 	out.close_session = mmc_close_session;
 	out.close_track_session = mmc_close;
 	out.read_buffer_capacity = mmc_read_buffer_capacity;
-	out.idata = calloc(1, sizeof(struct burn_scsi_inquiry_data));
+	out.idata = malloc(sizeof(struct burn_scsi_inquiry_data));
 	out.idata->valid = 0;
-	out.mdata = calloc(1, sizeof(struct scsi_mode_data));
+	out.mdata = malloc(sizeof(struct scsi_mode_data));
 	out.mdata->valid = 0;
 	if (out.idata == NULL || out.mdata == NULL) {
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020108,
@@ -545,7 +521,6 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 	/* Adapter specific handles and data */
 	out.cam = NULL;
 	out.lock_fd = -1;
-	out.is_ahci = 0;
 
 	/* Adapter specific functions */
 	out.grab = sg_grab;
@@ -675,9 +650,8 @@ static int freebsd_dev_lock(int dev_fd, char *devname,
 static int sg_lock(struct burn_drive *d, int flag)
 {
 	int ret, os_errno, pass_dev_no = -1, flock_fd = -1;
-	char *msg = NULL;
+	char msg[4096];
 
-	BURN_ALLOC_MEM(msg, char, 4096);
 	ret = freebsd_dev_lock(d->cam->fd, d->devname,
 				&os_errno, &pass_dev_no, &flock_fd, msg, 0);
 	if (ret <= 0) {
@@ -686,22 +660,18 @@ static int sg_lock(struct burn_drive *d, int flag)
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			msg, os_errno, 0);
 		sg_close_drive(d);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 	if (d->lock_fd > 0)
 		close(d->lock_fd);
 	d->lock_fd = flock_fd;
-	ret = 1;
-ex:;
-	BURN_FREE_MEM(msg);
-	return ret;
+	return 1;
 }
 
 
 int sg_grab(struct burn_drive *d)
 {
 	struct cam_device *cam;
-	char path_string[80];
 
 	if (mmc_function_spy(d, "sg_grab") <= 0)
 		return 0;
@@ -724,18 +694,6 @@ int sg_grab(struct burn_drive *d)
 		if (sg_lock(d, 0) <= 0)
 			return 0;
 	fcntl(cam->fd, F_SETOWN, getpid());
-
-	cam_path_string(d->cam, path_string, sizeof(path_string));
-
-#ifdef Libburn_ahci_verbouS
-	fprintf(stderr, "libburn_EXPERIMENTAL: CAM path = %s\n", path_string);
-#endif
-
-	if (strstr(path_string, ":ahcich") != NULL)
-		d->is_ahci = 1;
-	else
-		d->is_ahci = -1;
-
 	d->released = 0;
 	return 1;
 }
@@ -765,13 +723,14 @@ int sg_release(struct burn_drive *d)
 
 int sg_issue_command(struct burn_drive *d, struct command *c)
 {
-	int done = 0, err, sense_len = 0, ret, ignore_error, i;
-	int cam_pass_err_recover = 0, key, asc, ascq, timeout_ms;
+	int done = 0, err, sense_len, ret;
 	union ccb *ccb;
+	char buf[161];
 	static FILE *fp = NULL;
-	time_t start_time;
 
-	mmc_function_spy(NULL, "sg_issue_command");
+	snprintf(buf, sizeof (buf), "sg_issue_command  d->cam=%p d->released=%d",
+		(void*)d->cam, d->released);
+	mmc_function_spy(NULL, buf);
 
 	if (d->cam == NULL) {
 		c->error = 0;
@@ -812,23 +771,6 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 		break;
 	}
 
-#ifdef Libburn_for_freebsd_ahcI
-	/* ts B00325 : Advise by Alexander Motin */
-        /* Runs well on 8-STABLE (23 Mar 2003)
-	   But on 8-RELEASE cam_send_ccb() returns non-zero with errno 6
-           on eject. Long lasting TEST UNIT READY cycles break with
-           errno 16.
-        */
-#ifdef Libburn_ahci_style_for_alL
-	{
-#else
-	if (d->is_ahci > 0) {
-#endif
-		ccb->ccb_h.flags |= CAM_PASS_ERR_RECOVER;
-		cam_pass_err_recover = 1;
-	}
-#endif /* Libburn_for_freebsd_ahcI */
-
 	ccb->csio.cdb_len = c->oplen;
 	memcpy(&ccb->csio.cdb_io.cdb_bytes, &c->opcode, c->oplen);
 	
@@ -858,81 +800,9 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 		ccb->csio.dxfer_len = 0;
 	}
 
-	start_time = time(NULL);
-	timeout_ms = 200000;
-	for (i = 0; !done; i++) {
-		memset(c->sense, 0, sizeof(c->sense));
+	do {
 		err = cam_send_ccb(d->cam, ccb);
-
-		ignore_error = sense_len = 0;
-		/* ts B00325 : CAM_AUTOSNS_VALID advised by Alexander Motin */
-		if (ccb->ccb_h.status & CAM_AUTOSNS_VALID) {
-			/* ts B00110 */
-			/* Better curb sense_len */
-			sense_len = ccb->csio.sense_len;
-			if (sense_len > (int) sizeof(c->sense))
-				sense_len = sizeof(c->sense);
-			memcpy(c->sense, &ccb->csio.sense_data, sense_len);
-			spc_decode_sense(c->sense, sense_len,
-							&key, &asc, &ascq);
-			if (sense_len >= 14 && cam_pass_err_recover && key)
-				ignore_error = 1;
-		}
-
-		if (err == -1 && cam_pass_err_recover && ! ignore_error) {
-
-#ifdef Libburn_ahci_verbouS
-			fprintf(stderr, "libburn_EXPERIMENTAL: errno = %d . cam_errbuf = '%s'\n", errno, cam_errbuf);
-#endif
-
-			if (errno == ENXIO && c->opcode[0] != 0) {
-				/* Operations on empty or ejected tray */
-				/* MEDIUM NOT PRESENT */
-
-#ifdef Libburn_ahci_verbouS
-				fprintf(stderr, "libburn_EXPERIMENTAL: Emulating [2,3A,00] MEDIUM NOT PRESENT\n");
-#endif
-
-				c->sense[0] = 0x70; /*Fixed format sense data*/
-				c->sense[2] = 0x02;
-				c->sense[12] = 0x3A;
-				c->sense[13] = 0x00;
-				sense_len = 14;
-				ignore_error = 1;
-			} else if (c->opcode[0] == 0 && 
-					(errno == EBUSY || errno == ENXIO)) {
-				/* Timeout of TEST UNIT READY loop */
-				/* Inquiries while tray is being loaded */
-				/*LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE*/
-
-#ifdef Libburn_ahci_verbouS
-				fprintf(stderr, "libburn_EXPERIMENTAL: Emulating [2,04,00] LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE\n");
-#endif
-
-				c->sense[0] = 0x70; /*Fixed format sense data*/
-				c->sense[2] = 0x02;
-				c->sense[12] = 0x04;
-				c->sense[13] = 0x00;
-				sense_len = 14;
-				ignore_error = 1;
-			} else if (errno == EINVAL) {
-				/* Inappropriate MODE SENSE */
-				/* INVALID FIELD IN CDB */
-
-#ifdef Libburn_ahci_verbouS
-				fprintf(stderr, "libburn_EXPERIMENTAL: Emulating [5,24,00] INVALID FIELD IN CDB\n");
-#endif
-
-				c->sense[0] = 0x70; /*Fixed format sense data*/
-				c->sense[2] = 0x05;
-				c->sense[12] = 0x24;
-				c->sense[13] = 0x00;
-				sense_len = 14;
-				ignore_error = 1;
-			}
-		}
-
-		if (err == -1 && !ignore_error) {
+		if (err == -1) {
 			libdax_msgs_submit(libdax_messenger,
 				d->global_index, 0x0002010c,
 				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
@@ -946,34 +816,39 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 		}
 		/* XXX */
 
+		/* ts B00110 */
+		/* Better curb sense_len */
+		sense_len = ccb->csio.sense_len;
+		if (sense_len > sizeof(c->sense))
+			sense_len = sizeof(c->sense);
+		memcpy(c->sense, &ccb->csio.sense_data, ccb->csio.sense_len);
 		if ((ccb->ccb_h.status & CAM_STATUS_MASK) != CAM_REQ_CMP) {
-			if (sense_len < 14) {
-				/*LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE*/
-
-#ifdef Libburn_ahci_verbouS
-				fprintf(stderr, "libburn_EXPERIMENTAL: CAM_STATUS= %d .Emulating [2,04,00] LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE\n", (ccb->ccb_h.status & CAM_STATUS_MASK));
-#endif
-
-				c->sense[0] = 0x70; /*Fixed format sense data*/
-				c->sense[2] = 0x02;
-				c->sense[12] = 0x04;
-				c->sense[13] = 0x00;
-				done = 1;
+			if (!c->retry) {
+				c->error = 1;
+				{ret = 1; goto ex;}
+			}
+			switch (scsi_error(d, c->sense, 0)) {
+			case RETRY:
+				done = 0;
+				break;
+			case FAIL:
+				done = 1;
+				c->error = 1;
+				break;
 			}
-
-			/* >>> Need own duration time measurement.
-			       Then remove bit1 from flag.
-			*/
-			done = scsi_eval_cmd_outcome(d, c, fp, c->sense,
-						sense_len, 0, start_time,
-						timeout_ms, i,
-						2 | !!ignore_error);
 		} else {
 			done = 1;
 		}
 	} while (!done);
 	ret = 1;
 ex:;
+	if (c->error)
+		scsi_notify_error(d, c, c->sense, 18, 0);
+
+	if (burn_sg_log_scsi & 3)
+		/* >>> Need own duration time measurement. Then remove bit1 */
+		scsi_log_err(c, fp, c->sense, 0, (c->error != 0) | 2);
+
 	cam_freeccb(ccb);
 	return ret;
 }
@@ -986,13 +861,8 @@ ex:;
 int burn_os_is_2k_seekrw(char *path, int flag)
 {
         struct stat stbuf;
-#ifdef Libburn_DIOCGMEDIASIZE_ISBLK
-	int fd, ret;
-	off_t add_size;
-#else
 	char *spt;
 	int i, e;
-#endif /* ! Libburn_DIOCGMEDIASIZE_ISBLK */
 
         if (stat(path, &stbuf) == -1)
                 return 0;
@@ -1000,22 +870,6 @@ int burn_os_is_2k_seekrw(char *path, int flag)
                 return 1;
 	if (!S_ISCHR(stbuf.st_mode))
 		return 0;
-
-#ifdef Libburn_DIOCGMEDIASIZE_ISBLK
-
-	/* If it throws no error with DIOCGMEDIASIZE then it is a
-	   'block device'
-	*/
-	fd = open(path, O_RDONLY);
-	if (fd == -1)
-		return 0;
-	ret = ioctl(fd, DIOCGMEDIASIZE, &add_size);
-	close(fd);
-
-	return (ret != -1);
-
-#else /* Libburn_DIOCGMEDIASIZE_ISBLK */
-
 	spt = strrchr(path, '/');
 	if (spt == NULL)
 	        spt = path;
@@ -1038,9 +892,6 @@ int burn_os_is_2k_seekrw(char *path, int flag)
 	if (strncmp(spt, "fla", e) == 0) /* Flash drive */
 		return 1;
 	return 0;
-
-#endif /* ! Libburn_DIOCGMEDIASIZE_ISBLK */
-
 }
 
 
@@ -1058,12 +909,13 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 {
 	struct stat stbuf;
 	struct statvfs vfsbuf;
-	char *testpath = NULL, *cpt;
+	char testpath[4096], *cpt;
+	long blocks;
 	off_t add_size = 0;
 	int fd, ret;
 
-	BURN_ALLOC_MEM(testpath, char, 4096);
 	testpath[0] = 0;
+	blocks = *bytes / 512;
 	if (stat(path, &stbuf) == -1) {
 		strcpy(testpath, path);
 		cpt = strrchr(testpath, '/');
@@ -1074,24 +926,22 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 		else
 			*cpt = 0;
 		if (stat(testpath, &stbuf) == -1)
-			{ret = -1; goto ex;}
+			return -1;
 
 #ifdef Libburn_if_this_was_linuX
 
 	} else if(S_ISBLK(stbuf.st_mode)) {
 		int open_mode = O_RDWR, fd, ret;
-		long blocks;
 
-		blocks = *bytes / 512;
 		if(burn_sg_open_o_excl)
 			open_mode |= O_EXCL;
 		fd = open(path, open_mode);
 		if (fd == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		ret = ioctl(fd, BLKGETSIZE, &blocks);
 		close(fd);
 		if (ret == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = ((off_t) blocks) * (off_t) 512;
 
 #endif /* Libburn_if_this_was_linuX */
@@ -1100,28 +950,25 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 	} else if(S_ISCHR(stbuf.st_mode)) {
 		fd = open(path, O_RDONLY);
 		if (fd == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		ret = ioctl(fd, DIOCGMEDIASIZE, &add_size);
 		close(fd);
 		if (ret == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = add_size;
 	} else if(S_ISREG(stbuf.st_mode)) {
 		add_size = stbuf.st_blocks * (off_t) 512;
 		strcpy(testpath, path);
 	} else
-		{ret = 0; goto ex;}
+		return 0;
 
 	if (testpath[0]) {	
 		if (statvfs(testpath, &vfsbuf) == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
 						(off_t) vfsbuf.f_bavail;
 	}
-	ret = 1;
-ex:
-	BURN_FREE_MEM(testpath);
-	return ret;
+	return 1;
 }
 
 

libburn/sg-libcdio.c

@@ -1,11 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/*
-   Copyright (c) 2009 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-
 /*
 
 This is the main operating system dependent SCSI part of libburn. It implements
@@ -94,10 +88,6 @@ Send feedback to libburn-hackers@pykix.org .
 
 */
 
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 
 /** PORTING : ------- OS dependent headers and definitions ------ */
 
@@ -135,13 +125,6 @@ Send feedback to libburn-hackers@pykix.org .
 
 #define Libburn_guess_freebsd_atapi_devicE 1
 
-#ifdef sun
-#define Libburn_is_on_solariS 1
-#endif
-#ifdef __sun
-#define Libburn_is_on_solariS 1
-#endif
-
 #include <cdio/cdio.h>
 #include <cdio/logging.h>
 #include <cdio/mmc.h>
@@ -168,7 +151,6 @@ Send feedback to libburn-hackers@pykix.org .
 #include "debug.h"
 #include "toc.h"
 #include "util.h"
-#include "init.h"
 
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
@@ -237,9 +219,8 @@ static int sg_give_next_adr_raw(burn_drive_enumerator_t *idx,
 		}
 
 	} else if (initialize == -1) {
-		if (idx->ppsz_cd_drives != NULL)
-			if (*(idx->ppsz_cd_drives) != NULL)
-				cdio_free_device_list(idx->ppsz_cd_drives);
+		if (*(idx->ppsz_cd_drives) != NULL)
+			cdio_free_device_list(idx->ppsz_cd_drives);
 		idx->ppsz_cd_drives = NULL;
 	}
 
@@ -259,7 +240,7 @@ try_next:;
 	}
 #endif
 
-	if ((ssize_t) strlen(*(idx->pos)) >= adr_size)
+	if (strlen(*(idx->pos)) >= adr_size)
 		return -1;
 	strcpy(adr, *(idx->pos));
 	(idx->pos)++;
@@ -430,35 +411,17 @@ int sg_dispose_drive(struct burn_drive *d, int flag)
 int sg_give_next_adr(burn_drive_enumerator_t *idx,
 		     char adr[], int adr_size, int initialize)
 {
-	int ret, recursion_count = 0, path_size = 4096;
-	char *path = NULL;
-#ifdef Libburn_is_on_solariS
-	int l;
-#endif
-	BURN_ALLOC_MEM(path, char, path_size);
+	int ret, recursion_count = 0;
+	char path[4096];
 
 	ret = sg_give_next_adr_raw(idx, adr, adr_size, initialize);
 	if (ret <= 0)
-		goto ex;
-	if ((ssize_t) strlen(adr) >= path_size)
-		goto ex;
-
-#ifdef Libburn_is_on_solariS
-	/* >>> provisory : preserve Solaris /dev/rdsk/cXtYdZs2 addresses */
-	l = strlen(adr);
-	if (l >= 18)
-		if (strncmp(adr, "/dev/rdsk/c", 11) == 0 && adr[11] >= '0' &&
-		    adr[11] <= '9' && strcmp(adr + (l - 2), "s2") == 0)
-			{ret = 1; goto ex;}
-#endif /* Libburn_is_on_solariS */
-
-	ret = burn_drive_resolve_link(adr, path, &recursion_count, 2);
-        if(ret > 0 && (ssize_t) strlen(path) < adr_size)
-		strcpy(path, adr);
-	ret = (ret >= 0);
-ex:
-	BURN_FREE_MEM(path);
-	return ret;
+		return ret;
+	if (strlen(adr) >= sizeof(path))
+		return ret;
+	strcpy(path, adr);
+	ret = burn_drive_resolve_link(path, adr, &recursion_count, 2);
+	return (ret >= 0);
 }
 
 
@@ -470,36 +433,14 @@ int scsi_enumerate_drives(void)
 	burn_drive_enumerator_t idx;
 	int initialize = 1, ret, i_bus_no = -1, recursion_count = 0;
         int i_host_no = -1, i_channel_no = -1, i_target_no = -1, i_lun_no = -1;
-	int buf_size = 4096;
-	char *buf = NULL, *target = NULL;
-#ifdef Libburn_is_on_solariS
-	int l;
-#endif
-
-	BURN_ALLOC_MEM(buf, char, buf_size);
-	BURN_ALLOC_MEM(target, char, buf_size);
+	char buf[4096], target[4096];
 
 	while(1) {
-		ret = sg_give_next_adr_raw(&idx, buf, buf_size, initialize);
+		ret = sg_give_next_adr_raw(&idx, buf, sizeof(buf), initialize);
 		initialize = 0;
 		if (ret <= 0)
 	break;
-		ret = 1;
-
-#ifdef Libburn_is_on_solariS 
-		/* >>> provisory : preserve Solaris /dev/rdsk/cXtYdZs2 */
-		l = strlen(buf);
-		if (l >= 18)
-			if (strncmp(buf, "/dev/rdsk/c", 11) == 0 &&
-			    buf[11] >= '0' && buf[11] <= '9' &&
-			    strcmp(buf + (l - 2), "s2") == 0)
-				ret = 0;
-#endif /* Libburn_is_on_solariS */
-
-		if (ret == 1) {
-			ret = burn_drive_resolve_link(buf, target,
-							 &recursion_count,2);
-		}
+		ret = burn_drive_resolve_link(buf, target, &recursion_count,2);
 		if (ret <= 0)
 			strcpy(target, buf);
 		if (burn_drive_is_banned(target))
@@ -510,12 +451,8 @@ int scsi_enumerate_drives(void)
 				i_bus_no, i_host_no, i_channel_no,
 				i_target_no, i_lun_no);
 	}
-	sg_give_next_adr(&idx, buf, buf_size, -1);
-	ret = 1;
-ex:;
-	BURN_FREE_MEM(buf);
-	BURN_FREE_MEM(target);
-	return ret;
+	sg_give_next_adr(&idx, buf, sizeof(buf), -1);
+	return 1;
 }
 
 
@@ -539,12 +476,12 @@ int sg_drive_is_open(struct burn_drive * d)
 int sg_grab(struct burn_drive *d)
 {
 	CdIo_t *p_cdio;
-	char *am_eff, *msg = NULL, *am_wanted;
-	int os_errno, second_try = 0, ret;
+	char *am_eff, msg[4096], *am_wanted;
+	int os_errno, second_try = 0;
 
 	if (d->p_cdio != NULL) {
 		d->released = 0;
-		{ret = 1; goto ex;}
+		return 1;
 	}
 	if (d->libcdio_name[0] == 0) /* just to be sure it is initialized */
 		strcpy(d->libcdio_name, d->devname);
@@ -552,14 +489,13 @@ int sg_grab(struct burn_drive *d)
 try_to_open:;
 	p_cdio = cdio_open_am(d->libcdio_name, DRIVER_DEVICE, am_wanted);
 	if (p_cdio == NULL) {
-		BURN_ALLOC_MEM(msg, char, 4096);
 		os_errno = errno;
 		sprintf(msg, "Could not grab drive '%s'", d->devname);
 		libdax_msgs_submit(libdax_messenger, d->global_index,
 			0x00020003,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			msg, os_errno, 0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 	am_eff = (char *) cdio_get_arg(p_cdio, "access-mode");
         if (strncmp(am_eff, "MMC_RDWR", 8) != 0) {
@@ -574,15 +510,12 @@ try_to_open:;
 			0x00020003,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			"libcdio provides no MMC_RDWR access mode", 0, 0);
-		{ret = 0; goto ex;}
+		return 0;
         }
 
 	d->p_cdio = p_cdio;
 	d->released = 0;
-	ret = 1;
-ex:;
-	BURN_FREE_MEM(msg);
-	return ret;
+	return 1;
 }
 
 
@@ -614,8 +547,7 @@ int sg_release(struct burn_drive *d)
 */
 int sg_issue_command(struct burn_drive *d, struct command *c)
 {
-	int sense_valid = 0, i, timeout_ms;
-	int key = 0, asc = 0, ascq = 0, done = 0;
+	int sense_valid = 0, i, usleep_time, timeout_ms;
 	time_t start_time;
         driver_return_code_t i_status;
 	unsigned int dxfer_len;
@@ -630,15 +562,15 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 		return 0;
 	}
 	p_cdio = (CdIo_t *) d->p_cdio;
-	if (burn_sg_log_scsi & 1) {
-		if (fp == NULL) {
-			fp= fopen("/tmp/libburn_sg_command_log", "a");
-			fprintf(fp,
-			    "\n-----------------------------------------\n");
-		}
-	}
-	if (burn_sg_log_scsi & 3)
-		scsi_log_cmd(c,fp,0);
+        if (burn_sg_log_scsi & 1) {
+                if (fp == NULL) {
+                        fp= fopen("/tmp/libburn_sg_command_log", "a");
+                        fprintf(fp,
+                            "\n-----------------------------------------\n");
+                }
+        }
+        if (burn_sg_log_scsi & 3)
+                scsi_log_cmd(c,fp,0);
 
 	memcpy(cdb.field, c->opcode, c->oplen);
 	if (c->dir == TO_DRIVE) {
@@ -660,18 +592,15 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	/* retry-loop */
 	start_time = time(NULL);
 	timeout_ms = 200000;
-	for(i = 0; !done; i++) {
+	for(i = 0; ; i++) {
 
 		i_status = mmc_run_cmd(p_cdio, timeout_ms, &cdb, e_direction,
 				 	dxfer_len, c->page->data);
 		sense_valid = mmc_last_cmd_sense(p_cdio, &sense_pt);
-		if (sense_valid >= 18) {
+		if (sense_valid >= 18)
 			memcpy(c->sense, sense_pt,
-				(size_t) sense_valid >= sizeof(c->sense) ?
-				sizeof(c->sense) : (size_t) sense_valid );
-			spc_decode_sense(c->sense, 0, &key, &asc, &ascq);
-		} else
-			key = asc = ascq = 0;
+				sense_valid >= sizeof(c->sense) ?
+				sizeof(c->sense) : sense_valid );
 		if (sense_pt != NULL)
 			free(sense_pt);
 
@@ -693,25 +622,51 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 		}
 */
 
-		if ((!sense_valid) || (key == 0 && asc == 0 && ascq == 0)) {
+		if (!sense_valid) {
 			memset(c->sense, 0, sizeof(c->sense));
 			if (i_status != 0) { /* set dummy sense */
-				/*LOGICAL UNIT NOT READY,
-					CAUSE NOT REPORTABLE*/
-				c->sense[0] = 0x70; /*Fixed format sense data*/
+				/*LOGICAL UNIT NOT READY,CAUSE NOT REPORTABLE*/
 				c->sense[2] = 0x02;
 				c->sense[12] = 0x04;
-				done = 1;
 			}
-		} 
-		if (i_status != 0 || (key || asc || ascq)) {
-			done = scsi_eval_cmd_outcome(d, c, fp,  c->sense, 18,
-					0, start_time, timeout_ms, i, 2);
 		} else
-			done = 1;
-
+			c->sense[2] &= 15;
+	
+		if (i_status != 0 ||
+		    (c->sense[2] || c->sense[12] || c->sense[13])) {
+			if (!c->retry) {
+				c->error = 1;
+				goto ex;
+			}
+			switch (scsi_error(d, c->sense, 18)) {
+			case RETRY:
+				break;
+			case FAIL:
+				c->error = 1;
+				goto ex;
+			}
+			/* 
+			   Calming down retries and breaking up endless cycle
+			*/
+			usleep_time = Libburn_sg_libcdio_retry_usleeP +
+					i * Libburn_sg_libcdio_retry_incR;
+			if (time(NULL) + usleep_time / 1000000 - start_time >
+			    timeout_ms / 1000 + 1) {
+				c->error = 1;
+				goto ex;
+			}
+			usleep(usleep_time);
+		} else
+			break; /* retry-loop */
 	} /* end of retry-loop */
 
+ex:;
+	if (c->error)
+		scsi_notify_error(d, c, c->sense, 18, 0);
+
+	if (burn_sg_log_scsi & 3) 
+		/* >>> Need own duration time measurement. Then remove bit1 */
+		scsi_log_err(c, fp, c->sense, 0, (c->error != 0) | 2);
 	return 1;
 }
 
@@ -859,12 +814,12 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 	struct statvfs vfsbuf;
 #endif
 
-	char *testpath = NULL, *cpt;
+	char testpath[4096], *cpt;
+	long blocks;
 	off_t add_size = 0;
-	int ret;
 
-	BURN_ALLOC_MEM(testpath, char, 4096);
 	testpath[0] = 0;
+	blocks = *bytes / 512;
 	if (stat(path, &stbuf) == -1) {
 		strcpy(testpath, path);
 		cpt = strrchr(testpath, '/');
@@ -875,23 +830,21 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 		else
 			*cpt = 0;
 		if (stat(testpath, &stbuf) == -1)
-			{ret = -1; goto ex;}
+			return -1;
 
 #ifdef __linux
 
-	/* GNU/Linux specific determination of block device size */
+	/* Linux specific determination of block device size */
 	} else if(S_ISBLK(stbuf.st_mode)) {
 		int open_mode = O_RDONLY, fd, ret;
-		long blocks;
 
-		blocks = *bytes / 512;
 		fd = open(path, open_mode);
 		if (fd == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		ret = ioctl(fd, BLKGETSIZE, &blocks);
 		close(fd);
 		if (ret == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = ((off_t) blocks) * (off_t) 512;
 
 #endif /* __linux */
@@ -903,58 +856,38 @@ int burn_os_stdio_capacity(char *path, off_t *bytes)
 
 		fd = open(path, O_RDONLY);
 		if (fd == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		ret = ioctl(fd, DIOCGMEDIASIZE, &add_size);
 		close(fd);
 		if (ret == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = add_size;
 
-#endif /* Libburn_is_on_freebsD */
-
-#ifdef Libburn_is_on_solariS
-
-	} else if(S_ISBLK(stbuf.st_mode)) {
-		int open_mode = O_RDONLY, fd;
-		
-		fd = open(path, open_mode);
-		if (fd == -1)
-			{ret = -2; goto ex;}
-		*bytes = lseek(fd, 0, SEEK_END);
-		close(fd);
-		if (*bytes == -1) {
-			*bytes = 0;
-			{ret = 0; goto ex;}
-		}
-		
-#endif /* Libburn_is_on_solariS */
+#endif/* Libburn_is_on_freebsD */
 
 	} else if(S_ISREG(stbuf.st_mode)) {
 		add_size = stbuf.st_blocks * (off_t) 512;
 		strcpy(testpath, path);
 	} else
-		{ret = 0; goto ex;}
+		return 0;
 
 	if (testpath[0]) {	
 
 #ifdef Libburn_os_has_statvfS
 
 		if (statvfs(testpath, &vfsbuf) == -1)
-			{ret = -2; goto ex;}
+			return -2;
 		*bytes = add_size + ((off_t) vfsbuf.f_frsize) *
 						(off_t) vfsbuf.f_bavail;
 
 #else /* Libburn_os_has_statvfS */
 
-		{ret = 0; goto ex;}
+		return 0;
 
 #endif /* ! Libburn_os_has_stavtfS */
 
 	}
-	ret = 1;
-ex:;
-	BURN_FREE_MEM(testpath);
-	return ret;
+	return 1;
 }
 
 

libburn/sg-solaris.c

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

libburn/sg.c

@@ -1,21 +1,10 @@
 
 /* sg.c
    Switcher for operating system dependent transport level modules of libburn.
-   Copyright (C) 2009 - 2010 Thomas Schmitt <scdbackup@gmx.net>, 
-   provided under GPLv2+
+   Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPL
 */
 
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#undef HAVE_CONFIG_H
-#endif
 
-
-#ifdef Libburn_use_sg_dummY
-
-#include "sg-dummy.c"
-
-#else
 #ifdef Libburn_use_libcdiO
 
 #include "sg-libcdio.c"
@@ -23,31 +12,18 @@
 #else
 #ifdef __FreeBSD__
 
-#ifdef Libburn_use_sg_freebsd_porT
-#include "sg-freebsd-port.c"
-#else
 #include "sg-freebsd.c"
-#endif
 
 #else
 #ifdef __FreeBSD_kernel__
 
-#ifdef Libburn_use_sg_freebsd_porT
-#include "sg-freebsd-port.c"
-#else
 #include "sg-freebsd.c"
-#endif
 
 #else
 #ifdef __linux
 
 #include "sg-linux.c"
 
-#else
-#ifdef __sun
-
-#include "sg-solaris.c"
-
 #else
 
 /* The dummy adapter formally fulfills the expectations of libburn towards
@@ -58,11 +34,11 @@
 static int intentional_compiler_warning(void)
 {
  int INTENTIONAL_COMPILER_WARNING_;
- int Cannot_recognize_GNU_Linux_nor_FreeBSD_nor_Solaris_;
+ int Cannot_recognize_Linux_nor_FreeBSD_;
  int Have_to_use_dummy_MMC_transport_adapter_;
  int This_libburn_will_not_be_able_to_operate_on_real_CD_drives;
  int Have_to_use_dummy_MMC_transport_adapter;
- int Cannot_recognize_GNU_Linux_nor_FreeBSD_nor_Solaris;
+ int Cannot_recognize_Linux_nor_FreeBSD;
  int INTENTIONAL_COMPILER_WARNING;
 
  return(0);
@@ -70,10 +46,8 @@ static int intentional_compiler_warning(void)
 
 #include "sg-dummy.c"
 
-#endif /* ! __sun */
 #endif /* ! __linux */
 #endif /* ! __FreeBSD_kernel__ */
 #endif /* ! __FreeBSD__ */
 #endif /* ! Libburn_use_libcdiO */
-#endif /* ! Libburn_use_sg_dummY */
 

libburn/sg.h

@@ -1,8 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (C) 2009 Thomas Schmitt <scdbackup@gmx.net>, provided under GPLv2+
-*/
-
 #ifndef __SG
 #define __SG
 

libburn/source.c

@@ -1,15 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
-
 #include <stdlib.h>
 #include <string.h>
 #include "libburn.h"
@@ -63,15 +53,3 @@ int burn_source_cancel(struct burn_source *src)
 	return 1;
 }
 
-
-/* ts B00922 */
-int burn_source_read(struct burn_source *src, unsigned char *buffer, int size)
-{
-	int ret;
-
-	if (src->read != NULL)
-		 ret = src->read(src, buffer, size);
-	else
-		 ret = src->read_xt(src, buffer, size);
-	return ret;
-}

libburn/source.h

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

libburn/spc.h

@@ -1,11 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-
 #ifndef __SPC
 #define __SPC
 
@@ -49,7 +43,7 @@ int burn_scsi_setup_drive(struct burn_drive *d, int bus_no, int host_no,
 			int channel_no, int target_no, int lun_no, int flag);
 
 /* ts A61115 moved from sg-*.h */
-enum response { RETRY, FAIL, GO_ON };
+enum response { RETRY, FAIL };
 enum response scsi_error(struct burn_drive *, unsigned char *, int);
 
 /* ts A61122 */
@@ -78,29 +72,7 @@ int scsi_log_cmd(struct command *c, void *fp, int flag);
 /* ts A91221 (former sg_log_err ts A91108) */
 /** Logs outcome of a sg command. */
 int scsi_log_err(struct command *c, void *fp, unsigned char sense[18], 
-                 int sense_len, int duration, int flag);
-
-/* ts B00728 */
-int spc_decode_sense(unsigned char *sense, int senselen,
-                     int *key, int *asc, int *ascq);
-
-/* ts B00808 */
-/** Evaluates outcome of a single SCSI command, eventually logs sense data,
-    and issues DEBUG error message in case the command is evaluated as done.
-    @param flag   bit1 = do not print duration
-    @return 0 = not yet done , 1 = done , -1 = error
-*/
-int scsi_eval_cmd_outcome(struct burn_drive *d, struct command *c, void *fp_in,
-                        unsigned char *sense, int sense_len,
-                        int duration, time_t start_time, int timeout_ms,
-			int loop_count, int flag);
-
-/* The waiting time before eventually retrying a failed SCSI command.
-   Before each retry wait Libburn_scsi_retry_incR longer than with
-   the previous one.
-*/
-#define Libburn_scsi_retry_usleeP 100000
-#define Libburn_scsi_retry_incR   100000
+                 int duration, int flag);
 
 
 #endif /*__SPC*/

libburn/structure.c

@@ -1,13 +1,4 @@
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 /* ts A61008 */
 /* #include <a ssert.h> */
 
@@ -18,7 +9,6 @@
 #include "structure.h"
 #include "write.h"
 #include "debug.h"
-#include "init.h"
 
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
@@ -34,7 +24,7 @@ extern struct libdax_msgs *libdax_messenger;
 		return 0;\
 	if (pos == BURN_POS_END)\
 		pos = TO->NEW##s;\
-	if ((int) pos > TO->NEW##s)\
+	if (pos > TO->NEW##s)\
 		return 0;\
 \
 	tmp = realloc(TO->NEW, sizeof(struct NEW *) * (TO->NEW##s + 1));\
@@ -171,8 +161,6 @@ struct burn_track *burn_track_create(void)
 	/* ts A61031 */
 	t->open_ended = 0;
 	t->track_data_done = 0;
-	/* ts B10103 */
-	t->end_on_premature_eoi = 0;
 
 	t->postgap = 0;
 	t->pregap1 = 0;
@@ -270,14 +258,13 @@ void burn_track_define_data(struct burn_track *t, int offset, int tail,
 	int burn_sector_length(int tracktype);
 	unsigned char ctladr;
 	int form = -1; /* unchanged form will be considered an error too */
-	char msg[80];
 
 	type_to_form(mode, &ctladr, &form);
 	if (form == -1 || burn_sector_length(mode) <= 0) {
+		char msg[160];
 
-		sprintf(msg,
-			"Attempt to set track mode to unusable value 0x%X",
-			(unsigned int) mode);
+		sprintf(msg, "Attempt to set track mode to unusable value %d",
+			mode);
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020115,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			msg, 0, 0);
@@ -448,16 +435,14 @@ int burn_track_set_fillup(struct burn_track *t, int fill_up_media)
 int burn_track_apply_fillup(struct burn_track *t, off_t max_size, int flag)
 {
 	int max_sectors, ret = 2;
-	char msg[80];
+	char msg[160];
 
 	if (t->fill_up_media <= 0)
 		return 2;
 	max_sectors = max_size / 2048;
 	if (burn_track_get_sectors(t) < max_sectors || (flag & 1)) {
 		sprintf(msg, "Setting total track size to %ds (payload %ds)\n",
-			max_sectors & 0x7fffffff,
-			(int) ((t->source->get_size(t->source) / 2048)
-				& 0x7fffffff));
+		    max_sectors, (int) (t->source->get_size(t->source)/2048));
 		libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
 			LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
 			msg, 0, 0);
@@ -583,12 +568,11 @@ int burn_session_get_hidefirst(struct burn_session *session)
 /* ts A80808 : Enhance CD toc to DVD toc */
 int burn_disc_cd_toc_extensions(struct burn_disc *d, int flag)
 {
-	int sidx= 0, tidx= 0, ret;
+	int sidx= 0, tidx= 0;
 	struct burn_toc_entry *entry, *prev_entry= NULL;
 	/* ts A81126 : ticket 146 : There was a SIGSEGV in here */
-	char *msg_data = NULL, *msg;
+	char msg_data[321], *msg;
 
-	BURN_ALLOC_MEM(msg_data, char, 321);
 	strcpy(msg_data,
 		"Damaged CD table-of-content detected and truncated.");
 	strcat(msg_data, " In burn_disc_cd_toc_extensions: ");
@@ -651,15 +635,12 @@ int burn_disc_cd_toc_extensions(struct burn_disc *d, int flag)
 			prev_entry = entry;
 		}
 	}
-	{ret = 1; goto ex;}
+	return 1;
 failure:
 	libdax_msgs_submit(libdax_messenger, -1, 0x0002015f,
 		LIBDAX_MSGS_SEV_MISHAP, LIBDAX_MSGS_PRIO_HIGH, msg_data, 0, 0);
 	d->sessions= sidx;
-	ret = 0;
-ex:;
-	BURN_FREE_MEM(msg_data);
-	return ret;
+	return 0;
 }
 
 

libburn/structure.h

@@ -1,9 +1,3 @@
-
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
 #ifndef BURN__STRUCTURE_H
 #define BURN__STRUCTURE_H
 
@@ -55,14 +49,6 @@ struct burn_track
 	int open_ended;
 	/** End of open ended track flag : offset+payload+tail are delivered */
 	int track_data_done;
-	/* ts B10103 */
-	/** End track writing on premature End-of-input if source is of
-	    defined length.
-	    0= normal operation in case of eoi
-	    1= be ready to end track writing on eoi
-	    2= eoi was encountered with previously set value of 1
-	*/
-	int end_on_premature_eoi;
 
 	/** The audio/data mode for the entry. Derived from control and
 	    possibly from reading the track's first sector. */

libburn/toc.c

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

libburn/toc.h

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

libburn/transport.h

@@ -1,11 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-
 #ifndef __TRANSPORT
 #define __TRANSPORT
 
@@ -134,8 +128,6 @@ struct burn_drive
 		1=MMC drive ,
 		2=stdio random read-write
 		3=stdio sequential write-only
-                4=stdio random read-only
-                5=stdio random write-only
 	*/
 	int drive_role;
 
@@ -208,11 +200,6 @@ struct burn_drive
 	*/
 	int current_feat2fh_byte4;
 
-	/* ts B10524 : whether the damage bit was set for the future track.
-	               bit0= damage bit , bit1= nwa valid bit
-	*/
-	int next_track_damaged;
-
 	/* ts A70114 : whether a DVD-RW media holds an incomplete session
 	               (which could need closing after write) */
 	int needs_close_session;
@@ -279,10 +266,6 @@ struct burn_drive
 	/* ts A70129 :
 	   from 51h READ DISC INFORMATION Last Track Number in Last Session */
 	int last_track_no;
-
-	/* ts B10730 : whether a default mode page 05 was already sent.
-	*/
-	int sent_default_page_05;
 	/* ts A70212 : from various sources : free space on media (in bytes)
 	               With CD this might change after particular write
 	               parameters have been set and nwa has been inquired.
@@ -293,30 +276,15 @@ struct burn_drive
 	int media_lba_limit;
 
 	/* ts A81210 : Upper limit of readable data size,
-	               0x7fffffff = unknown
-	               0x7ffffff0 = 32 bit overflow, or unknown stdio size
-	 */
+	               0x7fffffff = unknown */
 	int media_read_capacity;
 
-	/* ts B10314 : Next Writeable Adress for drive_role == 5 */
-        int role_5_nwa;
-
 	int toc_temp;
 	struct burn_disc *disc;	/* disc structure */
 	int block_types[4];
 	struct buffer *buffer;
 	struct burn_progress progress;
 
-	/* To be used by mmc.c, sbc.c, spc.c for SCSI commands where the struct
-	   content surely does not have to persist while another command gets
-	   composed and executed.
-	   (Inherently, sending SCSI commands to the same drive cannot be
-	    thread-safe. But there are functions which send SCSI commands
-	    and also call other such functions. These shall use own allocated
-	    command structs and not this struct here.)
-	*/
-	struct command casual_command;
-
 	/* ts A70711 : keeping an eye on the drive buffer */
 	off_t pessimistic_buffer_free;
 	int pbf_altered;
@@ -338,8 +306,6 @@ struct burn_drive
 	/* ts A70929 */
 	pid_t thread_pid;
 	int thread_pid_valid;
-	/* ts B00225 */
-	pthread_t thread_tid;
 
 
 /* transport functions */

libburn/util.c

@@ -1,13 +1,3 @@
-
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 #include <string.h>
 
 /* ts A61008 */
@@ -34,7 +24,7 @@ char *burn_strdup(char *s)
 		return NULL;
 
 	l = strlen(s) + 1;
-	ret = calloc(1, l);
+	ret = malloc(l);
 	memcpy(ret, s, l);
 
 	return ret;
@@ -52,7 +42,7 @@ char *burn_strndup(char *s, int n)
 		return NULL;
 
 	l = strlen(s);
-	ret = calloc(1, l < n ? l : n);
+	ret = malloc(l < n ? l : n);
 
 	memcpy(ret, s, l < n - 1 ? l : n - 1);
 	ret[n - 1] = '\0';
@@ -74,6 +64,9 @@ struct cd_mid_record {
 	int m_li;
 	int s_li;
 	int f_li;
+	int m_lo;
+	int s_lo;
+	int f_lo;
 	char *other_brands;
 };
 typedef struct cd_mid_record cd_mid_record_t;
@@ -88,61 +81,57 @@ char *burn_guess_cd_manufacturer(int m_li, int s_li, int f_li,
                                  int m_lo, int s_lo, int f_lo, int flag)
 {
 	static cd_mid_record_t mid_list[]= {
-	{"SKC",                                 96, 40,  0,  ""},
-	{"Ritek Corp"                         , 96, 43, 30,  ""},
-	{"TDK / Ritek"                        , 97, 10,  0,  "TRAXDATA"},
-	{"TDK Corporation"                    , 97, 15,  0,  ""},
-	{"Ritek Corp"                         , 97, 15, 10,  "7-plus, Aopen, PONY, Power Source, TDK, TRAXDATA, HiCO, PHILIPS, Primdisc, Victor.JVC, OPTI STORAGE, Samsung"},
-	{"Mitsubishi Chemical Corporation"    , 97, 15, 20,  ""},
-	{"Nan-Ya Plastics Corporation"        , 97, 15, 30,  "Hatron, MMore, Acer, LITEON"},
-	{"Delphi"                             , 97, 15, 50,  ""},
-	{"Shenzhen SG&SAST"                   , 97, 16, 20,  ""},
-	{"Moser Baer India Limited"           , 97, 17,  0,  "EMTEC, Intenso, YAKUMO, PLATINUM, Silver Circle"},
-	{"SKY media Manufacturing SA"         , 97, 17, 10,  ""},
-	{"Wing"                               , 97, 18, 10,  ""},
-	{"DDT"                                , 97, 18, 20,  ""},
-	{"Daxon Technology Inc. / Acer"       , 97, 22, 60,  "Maxmax, Diamond Data, BenQ, gold, SONY"},
-	{"Taiyo Yuden Company Limited"        , 97, 24,  0,  "Maxell, FUJIFILM, SONY"},
-	{"Sony Corporation"                   , 97, 24, 10,  "LeadData, Imation"},
-	{"Computer Support Italcard s.r.l"    , 97, 24, 20,  ""},
-	{"Unitech Japan Inc."                 , 97, 24, 30,  ""},
-	{"MPO, France"                        , 97, 25,  0,  "TDK"},
-	{"Hitachi Maxell Ltd."                , 97, 25, 20,  ""},
-	{"Infodisc Technology Co,Ltd."        , 97, 25, 30,  "MEMOREX, SPEEDA, Lead data"},
-	{"Xcitec"                             , 97, 25, 60,  ""},
-	{"Fornet International Pte Ltd"       , 97, 26,  0,  "COMPUSA, Cdhouse"},
-	{"Postech Corporation"                , 97, 26, 10,  "Mr.Platinum"},
-	{"SKC Co Ltd."                        , 97, 26, 20,  "Infinite"},
-	{"Fuji Photo Film Co,Ltd."            , 97, 26, 40,  ""},
-	{"Lead Data Inc."                     , 97, 26, 50,  "SONY, Gigastorage, MIRAGE"},
-	{"CMC Magnetics Corporation"          , 97, 26, 60,  "Daxon, Verbatim, Memorex, Bi-Winner, PLEXTOR, YAMAHA, Melody, Office DEPOT, Philips, eMARK, imation, HyperMedia, Samsung, Shintaro, Techworks"},
-	{"Ricoh Company Limited"              , 97, 27,  0,  "Sony, Digital Storage, Csita"},
-	{"Plasmon Data Systems Ltd"           , 97, 27, 10,  "Ritek, TDK, EMTEC, ALPHAPET, MANIA"},
-	{"Princo Corporation"                 , 97, 27, 20,  ""},
-	{"Pioneer"                            , 97, 27, 30,  ""},
-	{"Eastman Kodak Company"              , 97, 27, 40,  ""},
-	{"Mitsui Chemicals Inc."              , 97, 27, 50,  "MAM-A, TDK"},
-	{"Ricoh Company Limited"              , 97, 27, 60,  "Ritek"},
-	{"Gigastorage Corporation"            , 97, 28, 10,  "MaxMax, Nan-Ya"},
-	{"Multi Media Masters&Machinary SA"   , 97, 28, 20,  "King, Mmirex"},
-	{"Ritek Corp"                         , 97, 31,  0,  "TDK"},
-	{"Grand Advance Technology Sdn. Bhd." , 97, 31, 30,  ""},
-	{"TDK Corporation"                    , 97, 32, 00,  ""},
-	{"Prodisc Technology Inc."            , 97, 32, 10,  "Smartbuy, Mitsubishi, Digmaster, LG, Media Market"},
-	{"Mitsubishi Chemical Corporation"    , 97, 34, 20,  "YAMAHA, Verbatim"},
-	{"Mitsui Chemicals Inc."              , 97, 48, 50, ""},
-	{"TDK Corporation"                    , 97, 49,  0, ""},
-	{"", 0, 0, 0, ""}
+	{"SKC",                                 96, 40,  0,  0, 0, 0, ""},
+	{"Ritek Corp"                         , 96, 43, 30,  0, 0, 0, ""},
+	{"TDK / Ritek"                        , 97, 10,  0,  0, 0, 0, "TRAXDATA"},
+	{"TDK Corporation"                    , 97, 15,  0,  0, 0, 0, ""},
+	{"Ritek Corp"                         , 97, 15, 10,  0, 0, 0, "7-plus, Aopen, PONY, Power Source, TDK, TRAXDATA, HiCO, PHILIPS, Primdisc, Victor.JVC, OPTI STORAGE, Samsung"},
+	{"Mitsubishi Chemical Corporation"    , 97, 15, 20,  0, 0, 0, ""},
+	{"Nan-Ya Plastics Corporation"        , 97, 15, 30,  0, 0, 0, "Hatron, MMore, Acer, LITEON"},
+	{"Delphi"                             , 97, 15, 50,  0, 0, 0, ""},
+	{"Shenzhen SG&SAST"                   , 97, 16, 20,  0, 0, 0, ""},
+	{"Moser Baer India Limited"           , 97, 17,  0,  0, 0, 0, "EMTEC, Intenso, YAKUMO, PLATINUM, Silver Circle"},
+	{"SKY media Manufacturing SA"         , 97, 17, 10,  0, 0, 0, ""},
+	{"Wing"                               , 97, 18, 10,  0, 0, 0, ""},
+	{"DDT"                                , 97, 18, 20,  0, 0, 0, ""},
+	{"Daxon Technology Inc. / Acer"       , 97, 22, 60,  0, 0, 0, "Maxmax, Diamond Data, BenQ, gold, SONY"},
+	{"Taiyo Yuden Company Limited"        , 97, 24,  0,  0, 0, 0, "Maxell, FUJIFILM, SONY"},
+	{"Sony Corporation"                   , 97, 24, 10,  0, 0, 0, "LeadData, Imation"},
+	{"Computer Support Italcard s.r.l"    , 97, 24, 20,  0, 0, 0, ""},
+	{"Unitech Japan Inc."                 , 97, 24, 30,  0, 0, 0, ""},
+	{"MPO, France"                        , 97, 25,  0,  0, 0, 0, "TDK"},
+	{"Hitachi Maxell Ltd."                , 97, 25, 20,  0, 0, 0, ""},
+	{"Infodisc Technology Co,Ltd."        , 97, 25, 30,  0, 0, 0, "MEMOREX, SPEEDA, Lead data"},
+	{"Xcitec"                             , 97, 25, 60,  0, 0, 0, ""},
+	{"Fornet International Pte Ltd"       , 97, 26,  0,  0, 0, 0, "COMPUSA, Cdhouse"},
+	{"Postech Corporation"                , 97, 26, 10,  0, 0, 0, "Mr.Platinum"},
+	{"SKC Co Ltd."                        , 97, 26, 20,  0, 0, 0, "Infinite"},
+	{"Fuji Photo Film Co,Ltd."            , 97, 26, 40,  0, 0, 0, ""},
+	{"Lead Data Inc."                     , 97, 26, 50,  0, 0, 0, "SONY, Gigastorage, MIRAGE"},
+	{"CMC Magnetics Corporation"          , 97, 26, 60,  0, 0, 0, "Daxon, Verbatim, Memorex, Bi-Winner, PLEXTOR, YAMAHA, Melody, Office DEPOT, Philips, eMARK, imation, HyperMedia, Samsung, Shintaro, Techworks"},
+	{"Ricoh Company Limited"              , 97, 27,  0,  0, 0, 0, "Sony, Digital Storage, Csita"},
+	{"Plasmon Data Systems Ltd"           , 97, 27, 10,  0, 0, 0, "Ritek, TDK, EMTEC, ALPHAPET, MANIA"},
+	{"Princo Corporation"                 , 97, 27, 20,  0, 0, 0, ""},
+	{"Pioneer"                            , 97, 27, 30,  0, 0, 0, ""},
+	{"Eastman Kodak Company"              , 97, 27, 40,  0, 0, 0, ""},
+	{"Mitsui Chemicals Inc."              , 97, 27, 50,  0, 0, 0, "MAM-A, TDK"},
+	{"Ricoh Company Limited"              , 97, 27, 60,  0, 0, 0, "Ritek"},
+	{"Gigastorage Corporation"            , 97, 28, 10,  0, 0, 0, "MaxMax, Nan-Ya"},
+	{"Multi Media Masters&Machinary SA"   , 97, 28, 20,  0, 0, 0, "King, Mmirex"},
+	{"Ritek Corp"                         , 97, 31,  0,  0, 0, 0, "TDK"},
+	{"Grand Advance Technology Sdn. Bhd." , 97, 31, 30,  0, 0, 0, ""},
+	{"TDK Corporation"                    , 97, 32, 00,  0, 0, 0, ""},
+	{"Prodisc Technology Inc."            , 97, 32, 10,  0, 0, 0, "Smartbuy, Mitsubishi, Digmaster, LG, Media Market"},
+	{"Mitsubishi Chemical Corporation"    , 97, 34, 20,  0, 0, 0, "YAMAHA, Verbatim"},
+	{"Mitsui Chemicals Inc."              , 97, 48, 50, 0, 0, 0, ""},
+	{"TDK Corporation"                    , 97, 49,  0, 0, 0, 0, ""},
+	{"", 0, 0, 0, 0, 0, 0, ""}
 	};
 
 	int i, f_li_0;
 	char buf[1024];
 	char *result = NULL;
 
-	if (m_li == 0 && s_li == 2 && f_li == 0) {
-		result = strdup("(no manufacturer code)");
-		return result;
-	}
 	f_li_0 = f_li - (f_li % 10);
 	for (i = 0; mid_list[i].manufacturer[0]; i++) {
 		if (m_li == mid_list[i].m_li &&
@@ -170,6 +159,7 @@ char *burn_guess_cd_manufacturer(int m_li, int s_li, int f_li,
 /* ts A90904 */
 struct dvd_mid_record {
 	char *mc1;
+	char *mc2;
 	int mc1_sig_len;
 	char *manufacturer;
 };
@@ -188,49 +178,49 @@ char *burn_guess_manufacturer(int prf,
 	                   Especially: ' ' -> '_' , {"_%/" unprintables -> %XY)
 	*/
 	static dvd_mid_record_t mid_list[]= {
-	{"AML",         8, "UML"},
-	{"BeAll",       5, "BeAll Developers, Inc."},
-	{"CMC",         3, "CMC Magnetics Corporation"},
-	{"DAXON",       5, "Daxon Technology Inc. / Acer"},
-	{"Daxon",       5, "Daxon Technology Inc. / Acer"},
-	{"FUJI",        4, "Fujifilm Holdings Corporation"},
-	{"INFODISC",    8, "New Star Digital Co., Ltd."},
-	{"INFOME",      6, "InfoMedia Inc."},
-	{"ISMMBD",      6, "Info Source Multi Media Ltd."},
-	{"JVC",         3, "JVC Limited"},
-	{"KIC01RG",     7, "AMC"},
-	{"LD",          8, "Lead Data Inc."},
-	{"LGE",         3, "LG Electronics"},
-	{"MAM",         8, "Mitsui Advanced Media, Inc. Europe"},
-	{"MAXELL",      6, "Hitachi Maxell Ltd."},
-	{"MBI",         3, "Moser Baer India Limited"},
-	{"MCC",         8, "Mitsubishi Chemical Corporation"},
-	{"MCI",         8, "Mitsui Chemicals Inc."},
-	{"MEI",         3, "Panasonic Corporation"},
-	{"MKM",         3, "Mitsubishi Kagaku Media Co."},
-	{"MMC",         8, "Mitsubishi Kagaku Media Co."},
-	{"MXL",         8, "Hitachi Maxell Ltd."},
-	{"NANYA",       5, "Nan-Ya Plastics Corporation"},
-	{"NSD",         8, "NESA International Inc."},
-	{"OPTODISC",    8, "Optodisc Technology Corporation"},
-	{"OTCBDR",      8, "Optodisc Technology Corporation"},
-	{"PHILIP",      8, "Moser Baer India Limited"},
-	{"PHILIPS",     8, "Philips"},
-	{"PRINCO",      6, "Princo Corporation"},
-	{"PRODISC",     7, "Prodisc Technology Inc."},
-	{"Prodisc",     7, "Prodisc Technology Inc."},
-	{"PVC",         3, "Pioneer"},
-	{"RICOHJPN",    8, "Ricoh Company Limited"},
-	{"RITEK",       5, "Ritek Corp"},
-	{"SONY",        4, "Sony Corporation"},
-	{"TDK",         3, "TDK Corporation"},
-	{"TT",          8, "TDK Corporation"},
-	{"TY",          8, "Taiyo Yuden Company Limited"},
-	{"TYG",         3, "Taiyo Yuden Company Limited"},
-	{"UTJR001",     7, "Unifino Inc."},
-	{"VERBAT",      5, "Mitsubishi Kagaku Media Co."},
-	{"YUDEN",       5, "Taiyo Yuden Company Limited"},
-	{"", 0, ""}
+	{"AML",      "",    8, "UML"},
+	{"BeAll",    "",    5, "BeAll Developers, Inc."},
+	{"CMC",      "",    3, "CMC Magnetics Corporation"},
+	{"DAXON",    "",    5, "Daxon Technology Inc. / Acer"},
+	{"Daxon",    "",    5, "Daxon Technology Inc. / Acer"},
+	{"FUJI",     "",    4, "Fujifilm Holdings Corporation"},
+	{"INFODISC", "",    8, "New Star Digital Co., Ltd."},
+	{"INFOME",   "",    6, "InfoMedia Inc."},
+	{"ISMMBD",   "",    6, "Info Source Multi Media Ltd."},
+	{"JVC",      "",    3, "JVC Limited"},
+	{"KIC01RG",  "",    7, "AMC"},
+	{"LD",       "",    8, "Lead Data Inc."},
+	{"LGE",      "",    3, "LG Electronics"},
+	{"MAM",      "",    8, "Mitsui Advanced Media, Inc. Europe"},
+	{"MAXELL",   "",    6, "Hitachi Maxell Ltd."},
+	{"MBI",      "",    3, "Moser Baer India Limited"},
+	{"MCC",      "",    8, "Mitsubishi Chemical Corporation"},
+	{"MCI",      "",    8, "Mitsui Chemicals Inc."},
+	{"MEI",      "",    3, "Panasonic Corporation"},
+	{"MKM",      "",    3, "Mitsubishi Kagaku Media Co."},
+	{"MMC",      "",    8, "Mitsubishi Kagaku Media Co."},
+	{"MXL",      "",    8, "Hitachi Maxell Ltd."},
+	{"NANYA",    "",    5, "Nan-Ya Plastics Corporation"},
+	{"NSD",      "",    8, "NESA International Inc."},
+	{"OPTODISC", "",    8, "Optodisc Technology Corporation"},
+	{"OTCBDR",   "",    8, "Optodisc Technology Corporation"},
+	{"PHILIP",   "",    8, "Moser Baer India Limited"},
+	{"PHILIPS",  "",    8, "Philips"},
+	{"PRINCO",   "",    6, "Princo Corporation"},
+	{"PRODISC",  "",    7, "Prodisc Technology Inc."},
+	{"Prodisc",  "",    7, "Prodisc Technology Inc."},
+	{"PVC",      "",    3, "Pioneer"},
+	{"RICOHJPN", "",    8, "Ricoh Company Limited"},
+	{"RITEK",    "",    5, "Ritek Corp"},
+	{"SONY",     "",    4, "Sony Corporation"},
+	{"TDK",      "",    3, "TDK Corporation"},
+	{"TT",       "",    8, "TDK Corporation"},
+	{"TY",       "",    8, "Taiyo Yuden Company Limited"},
+	{"TYG",      "",    3, "Taiyo Yuden Company Limited"},
+	{"UTJR001",  "",    7, "Unifino Inc."},
+	{"VERBAT",   "",    5, "Mitsubishi Kagaku Media Co."},
+	{"YUDEN",    "",    5, "Taiyo Yuden Company Limited"},
+	{"", "", 0, ""}
 	};
 
 	if (media_code2 != NULL &&

libburn/write.c

@@ -1,15 +1,5 @@
 /* -*- indent-tabs-mode: t; tab-width: 8; c-basic-offset: 8; -*- */
 
-/* Copyright (c) 2004 - 2006 Derek Foreman, Ben Jansens
-   Copyright (c) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net>
-   Provided under GPL version 2 or later.
-*/
-
-
-#ifdef HAVE_CONFIG_H
-#include "../config.h"
-#endif
-
 #include <unistd.h>
 #include <signal.h>
 
@@ -43,6 +33,7 @@
 #include "libburn.h"
 #include "drive.h"
 #include "transport.h"
+#include "crc.h"
 #include "debug.h"
 #include "init.h"
 #include "toc.h"
@@ -244,6 +235,7 @@ int burn_write_close_track(struct burn_write_opts *o, struct burn_session *s,
 {
 	char msg[81];
 	struct burn_drive *d;
+	struct burn_track *t;
 
 	/* ts A61106 */
 #ifdef Libburn_experimental_no_close_tracK
@@ -251,6 +243,7 @@ int burn_write_close_track(struct burn_write_opts *o, struct burn_session *s,
 #endif
 
 	d = o->drive;
+	t = s->track[tnum];
 
 	d->busy = BURN_DRIVE_CLOSING_TRACK;
 
@@ -274,7 +267,7 @@ int burn_write_close_track(struct burn_write_opts *o, struct burn_session *s,
 
 
 /* ts A61030 */
-int burn_write_close_session(struct burn_write_opts *o)
+int burn_write_close_session(struct burn_write_opts *o, struct burn_session *s)
 {
 
 	/* ts A61106 */
@@ -383,9 +376,9 @@ struct cue_sheet *burn_create_toc_entries(struct burn_write_opts *o,
  		runtime = nwa-150;
 #endif
 
-	sheet = calloc(1, sizeof(struct cue_sheet));
+	sheet = malloc(sizeof(struct cue_sheet));
 
-	/* ts A61009 : react on failures of calloc(), add_cue_sheet()
+	/* ts A61009 : react on failures of malloc(), add_cue_sheet()
 	               type_to_form() */
 	if (sheet == NULL) {
 		libdax_msgs_submit(libdax_messenger, -1, 0x00020111,
@@ -664,11 +657,19 @@ int burn_write_leadout(struct burn_write_opts *o,
 int burn_write_session(struct burn_write_opts *o, struct burn_session *s)
 {
 	struct burn_drive *d = o->drive;
+	struct burn_track *prev = NULL, *next = NULL;
 	int i, ret;
 
 	d->rlba = 0;
 	burn_print(1, "    writing a session\n");
 	for (i = 0; i < s->tracks; i++) {
+		if (i > 0)
+			prev = s->track[i - 1];
+		if (i + 1 < s->tracks)
+			next = s->track[i + 1];
+		else
+			next = NULL;
+
 		if (!burn_write_track(o, s, i))
 			{ ret = 0; goto ex; }
 	}
@@ -677,7 +678,7 @@ int burn_write_session(struct burn_write_opts *o, struct burn_session *s)
 	ret = 1;
 ex:;
 	if (o->write_type == BURN_WRITE_TAO)
-		burn_write_close_session(o);
+		burn_write_close_session(o, s);
 	return ret;
 }
 
@@ -936,8 +937,6 @@ int burn_disc_init_write_status(struct burn_write_opts *o,
 
 	d->cancel = 0;
 
-#ifdef Libburn_reset_progress_asynC
-	/* <<< This is now done in async.c */
 	/* init progress before showing the state */
 	d->progress.session = 0;
 	d->progress.sessions = disc->sessions;
@@ -952,7 +951,6 @@ int burn_disc_init_write_status(struct burn_write_opts *o,
 	d->progress.sectors = 0;
 	d->progress.sector = 0;
 	d->progress.track = 0;
-#endif /* Libburn_reset_progress_asynC */
 
 	/* ts A61023 */
 	d->progress.buffer_capacity = 0;
@@ -989,18 +987,15 @@ int burn_precheck_write(struct burn_write_opts *o, struct burn_disc *disc,
 {
 	enum burn_write_types wt;
 	struct burn_drive *d = o->drive;
-	char *msg = NULL, *reason_pt;
+	char msg[160], *reason_pt;
 	int no_media = 0;
 
 	reason_pt= reasons;
 	reasons[0] = 0;
 
-	if (d->drive_role == 0 || d->drive_role == 4) {
-		if (d->drive_role == 0)
-			sprintf(reasons,
-			       "DRIVE: is a virtual placeholder (null-drive)");
-		else
-			sprintf(reasons, "DRIVE: read-only pseudo drive");
+	if (d->drive_role == 0) {
+		sprintf(reasons,
+			 "DRIVE: is a virtual placeholder (null-drive)");
 		no_media = 1;
 		goto ex;
 	}
@@ -1017,7 +1012,7 @@ int burn_precheck_write(struct burn_write_opts *o, struct burn_disc *disc,
 	reason_pt= reasons + strlen(reasons);
 	if (d->status == BURN_DISC_UNSUITABLE)
 		goto unsuitable_profile;
-	if (d->drive_role == 2 || d->drive_role == 5 ||
+	if (d->drive_role == 2 ||
 		d->current_profile == 0x1a || d->current_profile == 0x12 ||
 		d->current_profile == 0x43) { 
 		/* DVD+RW , DVD-RAM , BD-RE, emulated drive on stdio file */
@@ -1046,18 +1041,13 @@ int burn_precheck_write(struct burn_write_opts *o, struct burn_disc *disc,
 			strcat(reasons, "write start address not supported, ");
 	} else {
 unsuitable_profile:;
-		msg = calloc(1, 160);
-		if (msg != NULL && !silent) {
-			sprintf(msg,
-			    "Unsuitable media detected. Profile %4.4Xh  %s",
-			    d->current_profile, d->current_profile_text);
+		sprintf(msg, "Unsuitable media detected. Profile %4.4Xh  %s",
+			d->current_profile, d->current_profile_text);
+		if (!silent)
 			libdax_msgs_submit(libdax_messenger, d->global_index,
 				0x0002011e,
 				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 				msg, 0, 0);
-		}
-		if (msg != NULL)
-			free(msg);
 		strcat(reasons, "no suitable media profile detected, ");
 		return 0;
 	}
@@ -1087,11 +1077,10 @@ int burn_disc_open_track_dvd_minus_r(struct burn_write_opts *o,
 					struct burn_session *s, int tnum)
 {
 	struct burn_drive *d = o->drive;
-	char *msg = NULL;
+	char msg[160];
 	int ret, lba, nwa;
 	off_t size;
 
-	BURN_ALLOC_MEM(msg, char, 160);
 	d->send_write_parameters(d, o);
 	ret = d->get_nwa(d, -1, &lba, &nwa);
 	sprintf(msg, 
@@ -1118,13 +1107,11 @@ int burn_disc_open_track_dvd_minus_r(struct burn_write_opts *o,
 #endif
 
 	if (o->write_type == BURN_WRITE_SAO) { /* DAO */
+ 		/* Round track size up to write chunk size and reserve track */
 		size = ((off_t) burn_track_get_sectors(s->track[tnum]))
 			* (off_t) 2048;
-
- 		/* Eventually round track size up to write chunk */
-		if (o->obs_pad && (size % o->obs))
+		if (size % o->obs)
 			size += (off_t) (o->obs - (size % o->obs));
-
 		ret = d->reserve_track(d, size);
 		if (ret <= 0) {
 			sprintf(msg, "Cannot reserve track of %.f bytes",
@@ -1133,13 +1120,10 @@ int burn_disc_open_track_dvd_minus_r(struct burn_write_opts *o,
 				0x00020138,
 				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 				msg, 0, 0);
-			{ret = 0; goto ex;}
+			return 0;
 		}
 	}
-	ret = 1;
-ex:;
-	BURN_FREE_MEM(msg);
-	return ret;
+	return 1;
 }
 
 
@@ -1148,11 +1132,10 @@ int burn_disc_open_track_dvd_plus_r(struct burn_write_opts *o,
 					struct burn_session *s, int tnum)
 {
 	struct burn_drive *d = o->drive;
-	char *msg = NULL;
+	char msg[160];
 	int ret, lba, nwa;
 	off_t size;
 
-	BURN_ALLOC_MEM(msg, char, 160);
 	ret = d->get_nwa(d, -1, &lba, &nwa);
 	sprintf(msg, 
 		"DVD+R pre-track %2.2d : get_nwa(%d), ret= %d , d->nwa= %d",
@@ -1169,10 +1152,6 @@ int burn_disc_open_track_dvd_plus_r(struct burn_write_opts *o,
  		/* Round track size up to write chunk size and reserve track */
 		size = ((off_t) burn_track_get_sectors(s->track[tnum]))
 			* (off_t) 2048;
-		/* o->obs should be 32k or 64k already. But 32k alignment
-		  was once performed in d->reserve_track() */
-		if (o->obs % 32768)
-			o->obs += 32768 - (o->obs % 32768);
 		if (size % o->obs)
 			size += (off_t) (o->obs - (size % o->obs));
 		ret = d->reserve_track(d, size);
@@ -1183,18 +1162,16 @@ int burn_disc_open_track_dvd_plus_r(struct burn_write_opts *o,
 				0x00020138,
 				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 				msg, 0, 0);
-			{ret = 0; goto ex;}
+			return 0;
 		}
 	}
-	ret = 1;
-ex:;
-	BURN_FREE_MEM(msg);
-	return ret;
+	return 1;
 }
 
 
 /* ts A70129 */
-int burn_disc_close_track_dvd_minus_r(struct burn_write_opts *o, int tnum)
+int burn_disc_close_track_dvd_minus_r(struct burn_write_opts *o,
+					struct burn_session *s, int tnum)
 {
 	struct burn_drive *d = o->drive;
 	char msg[80];
@@ -1251,7 +1228,7 @@ int burn_disc_finalize_dvd_plus_r(struct burn_write_opts *o)
 
 /* ts A70226 */
 int burn_disc_close_track_dvd_plus_r(struct burn_write_opts *o,
-			int tnum, int is_last_track)
+			struct burn_session *s, int tnum, int is_last_track)
 {
 	struct burn_drive *d = o->drive;
 	char msg[80];
@@ -1286,8 +1263,8 @@ int burn_disc_close_track_dvd_plus_r(struct burn_write_opts *o,
 
 /* ts A91114 : EXPERIMENTAL, NOT COMPLETELY IMPLEMENTED
 
-   Simplified data transmission for DVD. libburn via GNU/Linux USB is 30 %
-   slower than growisofs or cdrecord when transmitting 32 KB chunks.
+   Simplified data transmission for DVD. libburn via Linux USB is 30 % slower
+   than growisofs or cdrecord when transmitting 32 KB chunks.
    With 64 KB chunks it is 20% faster than the competitors.
    No heavy CPU load is visible but there might be subtle race conditions in
    the USB driver which work better with shorter time gaps between WRITE
@@ -1327,7 +1304,7 @@ static int transact_dvd_chunk(struct burn_write_opts *opts,
 	unsigned char *data = out->data;
 
 #ifdef Libburn_log_in_and_out_streaM
-	/* ts A61031 */
+	/* <<< ts A61031 */
 	static int tee_fd= -1;
 	if(tee_fd==-1)
 		tee_fd= open("/tmp/libburn_sg_readin",
@@ -1443,6 +1420,20 @@ int burn_dvd_write_track(struct burn_write_opts *o,
 
 	sectors = burn_track_get_sectors(t);
 	open_ended = burn_track_is_open_ended(t);
+	/* <<< */
+	{
+		char msg[160];
+
+		sprintf(msg,
+		 "DVD pre-track %2.2d : demand=%.f%s, cap=%.f\n",
+			tnum+1, (double) sectors * 2048.0,
+			(open_ended ? " (open ended)" : ""),
+			(double) d->media_capacity_remaining);
+		libdax_msgs_submit(libdax_messenger, d->global_index, 0x000002,
+				LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
+				msg, 0, 0);
+	}
+
 
 	/* (offset padding is done within sector_data()) */
 
@@ -1502,18 +1493,18 @@ int burn_dvd_write_track(struct burn_write_opts *o,
 	if (d->current_profile == 0x11 || d->current_profile == 0x14 ||
 	    d->current_profile == 0x15) {
 		/* DVD-R, DVD-RW Sequential, DVD-R/DL Sequential */
-		ret = burn_disc_close_track_dvd_minus_r(o, tnum);
+		ret = burn_disc_close_track_dvd_minus_r(o, s, tnum);
 		if (ret <= 0)
 			goto ex;
 	} else if (d->current_profile == 0x1b || d->current_profile == 0x2b) {
 		/* DVD+R , DVD+R/DL */
-		ret = burn_disc_close_track_dvd_plus_r(o, tnum,
+		ret = burn_disc_close_track_dvd_plus_r(o, s, tnum,
 							 is_last_track);
 		if (ret <= 0)
 			goto ex;
 	} else if (d->current_profile == 0x41) {
 		/* BD-R SRM */
-		ret = burn_disc_close_track_dvd_plus_r(o, tnum,
+		ret = burn_disc_close_track_dvd_plus_r(o, s, tnum,
 							 is_last_track);
 		if (ret <= 0)
 			goto ex;
@@ -1568,7 +1559,8 @@ int burn_disc_close_session_dvd_minus_rw(struct burn_write_opts *o,
 
 
 /* ts A70129 : for profile 0x11 DVD-R, 0x14 DVD-RW Seq, 0x15 DVD-R/DL Seq */
-int burn_disc_close_session_dvd_minus_r(struct burn_write_opts *o)
+int burn_disc_close_session_dvd_minus_r(struct burn_write_opts *o,
+					struct burn_session *s)
 {
 	struct burn_drive *d = o->drive;
 
@@ -1673,7 +1665,7 @@ int burn_dvd_write_session(struct burn_write_opts *o,
 		multi_mem = o->multi;
 		if (!is_last_session)
 			o->multi = 1;
-		ret = burn_disc_close_session_dvd_minus_r(o);
+		ret = burn_disc_close_session_dvd_minus_r(o, s);
 		o->multi = multi_mem;
 		if (ret <= 0)
 			return 0;
@@ -1733,7 +1725,7 @@ int burn_disc_setup_dvd_minus_rw(struct burn_write_opts *o,
 				struct burn_disc *disc)
 {
 	struct burn_drive *d = o->drive;
-	char msg[60];
+	char msg[160];
 	int ret;
 
 	d->nwa = 0;
@@ -1816,9 +1808,8 @@ int burn_dvd_write_sync(struct burn_write_opts *o,
 	off_t default_size = 0;
 	struct burn_drive *d = o->drive;
 	struct burn_track *t;
-	char *msg = NULL;
+	char msg[160];
 
-	BURN_ALLOC_MEM(msg, char, 160);
 	d->needs_close_session = 0;
 
 	/* buffer flush trigger for sector.c:get_sector() */
@@ -1889,8 +1880,6 @@ int burn_dvd_write_sync(struct burn_write_opts *o,
 				  msg, 0, 0);
 			burn_track_set_size(t, default_size);
 		}
-		/* Whether to fill-up last 32k buffer of track. */
-		o->obs_pad = (o->write_type != BURN_WRITE_SAO);
 		ret = burn_disc_setup_dvd_minus_r(o, disc);
 		if (ret <= 0) {
 			sprintf(msg,
@@ -1901,6 +1890,8 @@ int burn_dvd_write_sync(struct burn_write_opts *o,
 				msg, 0, 0);
 			goto early_failure;
 		}
+		/* ??? padding needed ??? cowardly doing it for now */
+		o->obs_pad = 1; /* fill-up track's last 32k buffer */
 		
 	} else if (d->current_profile == 0x1b || d->current_profile == 0x2b ||
 		   d->current_profile == 0x41) {
@@ -2003,16 +1994,9 @@ ex:;
 	burn_drive_mark_unready(d);
 	burn_drive_inquire_media(d);
 
-	if (d->current_profile == 0x41 && d->complete_sessions >= 300) {
-		sprintf(msg, "Sequential BD-R media now contains %d sessions. It is likely to soon fail writing.", d->complete_sessions);
-		libdax_msgs_submit(libdax_messenger, d->global_index,
-				0x0002017b, LIBDAX_MSGS_SEV_WARNING,
-				LIBDAX_MSGS_PRIO_ZERO, msg, 0, 0);
-	}
-	BURN_FREE_MEM(msg);
+	d->busy = BURN_DRIVE_IDLE;
 	return ret;
 early_failure:;
-	BURN_FREE_MEM(msg);
 	return 0;
 }
 
@@ -2022,8 +2006,7 @@ int burn_stdio_open_write(struct burn_drive *d, off_t start_byte,
 			 int sector_size, int flag)
 {
 
-/* We normally need _LARGEFILE64_SOURCE defined by the build system.
-   Nevertheless the system might use large address integers by default.
+/* <<< We need _LARGEFILE64_SOURCE defined by the build system.
 */
 #ifndef O_LARGEFILE
 #define O_LARGEFILE 0
@@ -2031,27 +2014,15 @@ int burn_stdio_open_write(struct burn_drive *d, off_t start_byte,
 
 	int fd = -1;
 	int mode = O_RDWR | O_CREAT | O_LARGEFILE;
-	char msg[60];
-	off_t lseek_res;
+	char msg[160];
 
-	if(d->drive_role == 4) {
-		libdax_msgs_submit(libdax_messenger, d->global_index,
-			0x00020181,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
-			"Pseudo-drive is a read-only file. Cannot write.",
-			0, 0);
-		return 0;
-	}
-	if (d->drive_role == 5 || d->drive_role == 3)
-		mode = O_WRONLY | O_CREAT | O_LARGEFILE;
 	if (d->devname[0] == 0) /* null drives should not come here */
 		return -1;
 	fd = burn_drive__fd_from_special_adr(d->devname);
 	if (fd >= 0)
 		fd = dup(fd); /* check validity and make closeable */
 	else
-		fd = open(d->devname, mode,
-                    S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH);
+		fd = open(d->devname, mode, S_IRUSR | S_IWUSR);
 	if (fd == -1) {
 		libdax_msgs_submit(libdax_messenger, d->global_index,
 			0x00020005,
@@ -2062,11 +2033,10 @@ int burn_stdio_open_write(struct burn_drive *d, off_t start_byte,
 	} 
 	if (start_byte < 0)
 		start_byte = 0;
-	if (d->drive_role == 2 || d->drive_role == 5) {
-		lseek_res = lseek(fd, start_byte, SEEK_SET);
-		if (lseek_res == -1) {
+	if (d->drive_role == 2)
+		if (lseek(fd, start_byte, SEEK_SET)==-1) {
 			sprintf(msg, "Cannot address start byte %.f",
-				(double) start_byte);
+			 	(double) start_byte);
 			libdax_msgs_submit(libdax_messenger, d->global_index,
 				0x00020147,
 				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
@@ -2075,7 +2045,6 @@ int burn_stdio_open_write(struct burn_drive *d, off_t start_byte,
 			d->cancel = 1;
 			fd = -1;
 		}
-	}
 	d->nwa = start_byte / sector_size;
 	return fd;
 }
@@ -2133,11 +2102,9 @@ int burn_stdio_mmc_write(struct burn_drive *d, int start, struct buffer *buf)
 	if (d->cancel)
 		return BE_CANCELLED;
 	if (d->stdio_fd < 0) {
-		libdax_msgs_submit(libdax_messenger, d->global_index,
-			0x0002017d,
-			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
-			"Invalid file descriptor with stdio pseudo-drive",
-			0, 0);
+
+		/* >>> program error */;
+
 		d->cancel = 1;
 		return BE_CANCELLED;
 	}
@@ -2184,14 +2151,10 @@ int burn_stdio_mmc_dummy_write(struct burn_drive *d, int start,
 */
 int burn_stdio_sync_cache(int fd, struct burn_drive *d, int flag)
 {
-	int ret;
-
 	if (fd < 0) {
-		libdax_msgs_submit(libdax_messenger, d->global_index,
-			0x0002017d,
-			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
-			"Invalid file descriptor with stdio pseudo-drive",
-			0, 0);
+
+		/* >>> program error */;
+
 		d->cancel = 1;
 		return 0;
 	}
@@ -2200,8 +2163,9 @@ int burn_stdio_sync_cache(int fd, struct burn_drive *d, int flag)
 		libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
 			   LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
 			   "syncing cache (stdio fsync)", 0, 0);
-	ret = fsync(fd);
-	if (ret != 0 && errno == EIO) {
+	if (fsync(fd) != 0) {
+		if (errno == EINVAL) /* E.g. /dev/null cannot fsync */
+			return 1;
 		libdax_msgs_submit(libdax_messenger, d->global_index,
 			0x00020148,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
@@ -2254,22 +2218,21 @@ int burn_stdio_slowdown(struct burn_drive *d, struct timeval *prev_time,
 int burn_stdio_write_track(struct burn_write_opts *o, struct burn_session *s,
 				int tnum, int flag)
 {
-	int open_ended, bufsize = 16 * 2048, ret, sectors;
+	int open_ended, bufsize, ret, sectors, fd;
 	struct burn_track *t = s->track[tnum];
 	struct burn_drive *d = o->drive;
-	char *buf = NULL;
+	char buf[16*2048];
 	int i, prev_sync_sector = 0;
 	struct buffer *out = d->buffer;
 	struct timeval prev_time;
 
-	BURN_ALLOC_MEM(buf, char, bufsize);
+	bufsize = sizeof(buf);
+	fd = d->stdio_fd;
 
 	sectors = burn_track_get_sectors(t);
 	burn_disc_init_track_status(o, s, tnum, sectors);
 	open_ended = burn_track_is_open_ended(t);
 
-	t->end_on_premature_eoi = (o->write_type == BURN_WRITE_TAO);
-
 	/* attach stdio emulators for mmc_*() functions */
 	if (o->simulate)
 		d->write = burn_stdio_mmc_dummy_write;
@@ -2282,9 +2245,8 @@ int burn_stdio_write_track(struct burn_write_opts *o, struct burn_session *s,
 		/* transact a (CD sized) sector */
 		if (!sector_data(o, t, 0))
 			{ret= 0; goto ex;}
-		if (open_ended)
+		if (open_ended) {
 			d->progress.sectors = sectors = d->progress.sector;
-		if (open_ended || t->end_on_premature_eoi) {
 			if (burn_track_is_data_done(t))
 	break;
 		}
@@ -2295,9 +2257,8 @@ int burn_stdio_write_track(struct burn_write_opts *o, struct burn_session *s,
 			prev_sync_sector = d->progress.sector;
 			if (!o->simulate)
 				burn_stdio_sync_cache(d->stdio_fd, d, 1);
-		}
-		if ((d->progress.sector % 512) == 0) 
 			burn_stdio_slowdown(d, &prev_time, 512 * 2, 0);
+		}
 	}
 
 	/* Pad up buffer to next full o->obs (usually 32 kB) */
@@ -2311,9 +2272,6 @@ int burn_stdio_write_track(struct burn_write_opts *o, struct burn_session *s,
 ex:;
 	if (d->cancel)
 		burn_source_cancel(t->source);
-	if (t->end_on_premature_eoi == 2)
-		d->cancel = 1;
-	BURN_FREE_MEM(buf);
 	return ret;
 }
 
@@ -2342,9 +2300,6 @@ int burn_stdio_write_sync(struct burn_write_opts *o,
 	/* open target file */
 	if (d->stdio_fd >= 0)
 		close(d->stdio_fd);
-	if (d->drive_role == 5 && d->status == BURN_DISC_APPENDABLE &&
-            o->start_byte < 0)
-		o->start_byte = d->role_5_nwa * 2048;
 	d->stdio_fd = burn_stdio_open_write(d, o->start_byte, 2048, 0);
 	if (d->stdio_fd == -1)
 		{ret = 0; goto ex;}
@@ -2366,7 +2321,7 @@ ex:;
 	/* update media state records */
 	burn_drive_mark_unready(d);
 
-	/* <<< d->busy = BURN_DRIVE_IDLE; */
+	d->busy = BURN_DRIVE_IDLE;
 	return ret;
 }
 
@@ -2427,14 +2382,6 @@ calloc() seems not to have the desired effect. valgrind warns:
 	d->rlba = -150;
 	d->toc_temp = 9;
 
-	if(d->drive_role == 4) {
-		libdax_msgs_submit(libdax_messenger, d->global_index,
-			0x00020181,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
-			"Pseudo-drive is a read-only file. Cannot write.",
-			0, 0);
-		goto fail_wo_sync;
-	}
 	/* ts A70904 */
 	if (d->drive_role != 1) {
 		ret = burn_stdio_write_sync(o, disc);
@@ -2450,7 +2397,7 @@ calloc() seems not to have the desired effect. valgrind warns:
 		goto ex;
 	}
 
-	/* ts A70521 : GNU/Linux 2.4 USB audio fails with 64 kiB */
+	/* ts A70521 : Linux 2.4 USB audio fails with 64 kiB */
 	/* ts A80414 : might need 64 kiB for BD-RE streaming */
         /* buffer flush trigger for sector.c:get_sector() */
 	o->obs = Libburn_cd_obS;
@@ -2521,8 +2468,6 @@ return crap.  so we send the command, then ignore the result.
 /*		print_cue(sheet);*/
 		if (o->write_type == BURN_WRITE_SAO)
 			d->send_cue_sheet(d, sheet);
-		if (sheet->data != NULL)
-			free(sheet->data);
 		free(sheet);
 
 		if (o->write_type == BURN_WRITE_RAW) {
@@ -2613,7 +2558,7 @@ return crap.  so we send the command, then ignore the result.
 	burn_drive_inquire_media(d);
 
 	burn_print(1, "done\n");
-	/* <<< d->busy = BURN_DRIVE_IDLE; */
+	d->busy = BURN_DRIVE_IDLE;
 
 	/* ts A61012 : This return was traditionally missing. I suspect this
 			to have caused Cdrskin_eject() failures */
@@ -2628,7 +2573,7 @@ fail_wo_sync:;
 			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 			"Burn run failed", 0, 0);
 	d->cancel = 1;
-	/* <<< d->busy = BURN_DRIVE_IDLE; */
+	d->busy = BURN_DRIVE_IDLE;
 ex:;
 	d->do_stream_recording = 0;
 	if (d->buffer != NULL)
@@ -2644,33 +2589,24 @@ int burn_random_access_write(struct burn_drive *d, off_t byte_address,
 {
 	int alignment = 0, start, upto, chunksize, err, fd = -1, ret;
 	char msg[81], *rpt;
-	struct buffer *buf = NULL, *buffer_mem = d->buffer;
+	struct buffer buf, *buffer_mem = d->buffer;
 
-	BURN_ALLOC_MEM(buf, struct buffer, 1);
 	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 write", 0, 0);
-		{ret = 0; goto ex;}
+		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);
-		{ret = 0; goto ex;}
-	}
-	if(d->drive_role == 4) {
-		libdax_msgs_submit(libdax_messenger, d->global_index,
-			0x00020181,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
-			"Pseudo-drive is a read-only file. Cannot write.",
-			0, 0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 
-	if(d->drive_role == 2 || d->drive_role == 5)
+	if(d->drive_role == 2)
 		alignment = 2 * 1024;
 	if (d->current_profile == 0x12) /* DVD-RAM */
 		alignment = 2 * 1024;
@@ -2686,7 +2622,7 @@ int burn_random_access_write(struct burn_drive *d, off_t byte_address,
 			0x00020125,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			"Write start address not supported", 0, 0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 	if ((byte_address % alignment) != 0) {
 		sprintf(msg,
@@ -2696,7 +2632,7 @@ int burn_random_access_write(struct burn_drive *d, off_t byte_address,
 			0x00020126,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			msg, 0, 0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 	if ((data_count % alignment) != 0) {
 		sprintf(msg,
@@ -2706,22 +2642,22 @@ int burn_random_access_write(struct burn_drive *d, off_t byte_address,
 			0x00020141,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			msg, 0, 0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 	if (d->busy != BURN_DRIVE_IDLE) {
 		libdax_msgs_submit(libdax_messenger,
 			d->global_index, 0x00020140,
 			LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 			"Drive is busy on attempt to write random access",0,0);
-		{ret = 0; goto ex;}
+		return 0;
 	}
 	if(d->drive_role != 1) {
 		fd = burn_stdio_open_write(d, byte_address, 2048, 0);
 		if (fd == -1)
-			{ret = 0; goto ex;}
+			return 0;
 	}
 	d->busy = BURN_DRIVE_WRITING_SYNC;
-	d->buffer = buf;
+	d->buffer = &buf;
 
 	start = byte_address / 2048;
 	upto = start + data_count / 2048;
@@ -2748,7 +2684,7 @@ int burn_random_access_write(struct burn_drive *d, off_t byte_address,
 			d->busy = BURN_DRIVE_IDLE;
 			if(fd >= 0)
 				close(fd);
-			{ret = -(start * 2048 - byte_address); goto ex;}
+			return (-(start * 2048 - byte_address));
 		}
 	}
 
@@ -2766,95 +2702,6 @@ int burn_random_access_write(struct burn_drive *d, off_t byte_address,
 		close(fd);
 	d->buffer = buffer_mem;
 	d->busy = BURN_DRIVE_IDLE;
-	ret = 1;
-ex:
-	BURN_FREE_MEM(buf);
-	return ret;
+	return 1;
 }
 
-
-/* ts B10527 */
-/* @param bit0= force close, even if no damage was seen
-*/
-int burn_disc_close_damaged(struct burn_write_opts *o, int flag)
-{
-	struct burn_drive *d;
-	int ret;
-	enum burn_drive_status busy;
-
-	d = o->drive;
-	busy = d->busy;
-
-	if (busy != BURN_DRIVE_IDLE) {
-		libdax_msgs_submit(libdax_messenger,
-			d->global_index, 0x00020106,
-			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
-			"Drive is busy on attempt to close damaged session",
-			0, 0);
-		{ret = 0; goto ex;}
-	}
-	if (!((d->next_track_damaged & 1) || (flag & 1))) {
-		libdax_msgs_submit(libdax_messenger,
-			d->global_index, 0x00020187,
-			LIBDAX_MSGS_SEV_NOTE, LIBDAX_MSGS_PRIO_HIGH,
-			"Track not marked as damaged. No action taken.",
-			0, 0);
-		{ret = 0; goto ex;}
-	}
-	d->busy = BURN_DRIVE_WRITING;
-
-	if (d->current_profile == 0x09 || d->current_profile == 0x0a) {
-		/* Close CD track and session */
-		o->write_type = BURN_WRITE_TAO; /* no action without TAO */
-
-		/* Send mode page 5 */;
-		d->send_write_parameters(d, o);
-
-		ret = burn_write_close_session(o);
-		if (ret <= 0)
-			goto ex;
-
-	} else if(d->current_profile == 0x11 || d->current_profile == 0x14) {
-		/* Close DVD-R[W] track and session */
-		o->write_type = BURN_WRITE_TAO; /* no action without TAO */
-
-		/* Send mode page 5 */;
-		d->send_write_parameters(d, o);
-
-		ret = burn_disc_close_track_dvd_minus_r(o, 0);
-		if (ret <= 0)
-			goto ex;
-		ret = burn_disc_close_session_dvd_minus_r(o);
-		if (ret <= 0)
-			goto ex;
-
-	} else if(d->current_profile == 0x1b || d->current_profile == 0x2b) {
-		/* Close DVD+R track and session */
-		ret = burn_disc_close_track_dvd_plus_r(o, d->last_track_no, 1);
-		if (ret <= 0)
-			goto ex;
-
-	} else if(d->current_profile == 0x41) {
-		/* Close BD-R track and session */
-		ret = burn_disc_close_track_dvd_plus_r(o, d->last_track_no, 1);
-		if (ret <= 0)
-			goto ex;
-
-	} else {
-		libdax_msgs_submit(libdax_messenger,
-			d->global_index, 0x00020188,
-			LIBDAX_MSGS_SEV_FAILURE, LIBDAX_MSGS_PRIO_HIGH,
-			"Cannot close damaged track on given media type",
-			0, 0);
-		{ret = 0; goto ex;}
-
-	}
-	ret = 1;
-ex:;
-	d->busy = busy;
-	/* Record with drive that repair was attempted */
-	d->next_track_damaged &= ~1;
-	return ret;
-}
-
-

libburn/write.h

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

releng/releng_build_os

@@ -1,41 +0,0 @@
-#!/bin/sh
-
-set -e
-
-cd ..
-
-if [ ! -x configure ]; then
- printf "\n*** please run ./bootstrap first.\n"
- exit 1
-fi
-
-build()
-{
- for F in ${1}
- do
-  make clean
-  clear
-  printf "\n *** building with: %s\n" CPPFLAGS=-D${F}
-  sleep 1
-  # libcdio is not autodetected by default; should be available everywhere
-  CPPFLAGS=-D${F} ./configure --enable-libcdio; make 2> releng/libburn.${F}.log
-  make clean
- done
-}
-
-OS=`uname -o`
-
-case ${OS} in
-GNU/Linux)
- printf "OS: %s\n" ${OS}
- sleep 1
- build  "__linux Libburn_use_sg_dummY Libburn_use_libcdiO"
-;;
-*)
- printf "Unknown OS: %s\n" ${OS}
- exit 1
-;;
-esac
-
-# just in case
-unset CPPFLAGS

test/dewav.c

@@ -25,19 +25,18 @@
 #include "../libburn/libdax_msgs.h"
 struct libdax_msgs *libdax_messenger= NULL;
 
-/* The API for .wav extraction */
-#define LIBDAX_AUDIOXTR_H_PUBLIC 1
-#include "../libburn/libdax_audioxtr.h"
-
 #else /* Dewav_without_libburN */
 
-/* This build environment uses libdax_msgs and libdax_audioxtr via libburn */
+/* This build environment uses libdax_msgs via libburn */
 /* Thus the API header of libburn */
 #include "../libburn/libburn.h"
 
 #endif /* ! Dewav_without_libburN */
 
 
+/* The API for .wav extraction */
+#include "../libburn/libdax_audioxtr.h"
+
 
 int main(int argc, char **argv)
 {

test/libburner.c

@@ -1,6 +1,6 @@
 
 /* test/libburner.c , API illustration of burning data or audio tracks to CD */
-/* Copyright (C) 2005 - 2011 Thomas Schmitt <scdbackup@gmx.net> */
+/* Copyright (C) 2005 - 2010 Thomas Schmitt <scdbackup@gmx.net> */
 /* Provided under GPL, see also "License and copyright aspects" at file end */
 
 
@@ -20,37 +20,25 @@
   Before you can do anything, you have to initialize libburn by
      burn_initialize()
   and provide some signal and abort handling, e.g. by the builtin handler, by
-     burn_set_signal_handling("libburner : ", NULL, 0x0) 
-  as it is done in main() at the end of this file.
-  Then you aquire a drive in an appropriate way conforming to the API. The twoi
-  main approaches are shown here in application functions:
+     burn_set_signal_handling() 
+  as it is done in main() at the end of this file. Then you aquire a
+  drive in an appropriate way conforming to the API. The two main
+  approaches are shown here in application functions:
      libburner_aquire_by_adr()     demonstrates usage as of cdrecord traditions
      libburner_aquire_by_driveno()      demonstrates a scan-and-choose approach
-
-  With that aquired drive you can blank a CD-RW or DVD-RW as shown in
+  With that aquired drive you can blank a CD-RW
      libburner_blank_disc()
   or you can format a DVD-RW to profile "Restricted Overwrite" (needed once)
   or an unused BD to default size with spare blocks
      libburner_format()
-  With the aquired drive you can burn to CD, DVD, BD. See
+  With the aquired drive you can burn to CD, DVD, BD
      libburner_payload()
-
-  These three functions switch temporarily to a non-fatal signal handler
-  while they are waiting for the drive to become idle again:
-     burn_set_signal_handling("libburner : ", NULL, 0x30)
-  After the waiting loop ended, they check for eventual abort events by
-     burn_is_aborting(0)
-  The 0x30 handler will eventually execute
-     burn_abort()
-  but not wait for the drive to become idle and not call exit().
-  This is needed because the worker threads might block as long as the signal
-  handler has not returned. The 0x0 handler would wait for them to finish.
-  Take this into respect when implementing own signal handlers.
-
   When everything is done, main() releases the drive and shuts down libburn:
      burn_drive_release();
      burn_finish()
-
+  
+*/
+/*
   Applications must use 64 bit off_t. E.g. by defining
     #define _LARGEFILE_SOURCE
     #define _FILE_OFFSET_BITS 64
@@ -66,7 +54,7 @@
 /*  This program insists in the own headerfile. */
 #include "../libburn/libburn.h"
 
-/* libburn works on Linux systems with kernel 2.4 or 2.6, FreeBSD, Solaris */
+/* libburn is intended for Linux systems with kernel 2.4 or 2.6 for now */
 #include <stdio.h>
 #include <ctype.h>
 #include <sys/types.h>
@@ -218,7 +206,7 @@ int libburner_aquire_by_driveno(int *driveno)
 	printf("\nOverview of accessible drives (%d found) :\n",
 		drive_count);
 	printf("-----------------------------------------------------------------------------\n");
-	for (i = 0; i < (int) drive_count; i++) {
+	for (i = 0; i < drive_count; i++) {
 		if (burn_drive_get_adr(&(drive_list[i]), adr) <=0)
 			strcpy(adr, "-get_adr_failed-");
 		printf("%d  --drive '%s'  :  '%s'  '%s'\n",
@@ -255,7 +243,7 @@ int libburner_aquire_by_driveno(int *driveno)
 		printf("Pseudo-drive \"-\" given : bus scanning done.\n");
 		return 2; /* the program will end after this */
 	}
-	if ((int) drive_count <= *driveno) {
+	if (drive_count <= *driveno) {
 		fprintf(stderr,
 			"Found only %d drives. Number %d not available.\n",
 			drive_count, *driveno);
@@ -263,7 +251,7 @@ int libburner_aquire_by_driveno(int *driveno)
 	}
 
 	/* Drop all drives which we do not want to use */
-	for (i = 0; i < (int) drive_count; i++) {
+	for (i = 0; i < drive_count; i++) {
 		if (i == *driveno) /* the one drive we want to keep */
 	continue;
 		ret = burn_drive_info_forget(&(drive_list[i]),0);
@@ -322,12 +310,9 @@ int libburner_blank_disc(struct burn_drive *drive, int blank_fast)
 			"FATAL : Media is not of erasable type\n");
 		return 0;
 	}
-	/* Switch to asynchronous signal handling for the time of waiting */
-	burn_set_signal_handling("libburner : ", NULL, 0x30);
-
-	printf("Beginning to %s-blank media.\n", (blank_fast?"fast":"full"));
+	printf(
+	      "Beginning to %s-blank media.\n", (blank_fast?"fast":"full"));
 	burn_disc_erase(drive, blank_fast);
-
 	sleep(1);
 	while (burn_drive_get_status(drive, &p) != BURN_DRIVE_IDLE) {
 		if(p.sectors>0 && p.sector>=0) /* display 1 to 99 percent */
@@ -336,10 +321,6 @@ int libburner_blank_disc(struct burn_drive *drive, int blank_fast)
 		printf("Blanking  ( %.1f%% done )\n", percent);
 		sleep(1);
 	}
-	if (burn_is_aborting(0) > 0)
-		return -1;
-	/* Back to synchronous handling */
-	burn_set_signal_handling("libburner : ", NULL, 0x0);
 	printf("Done\n");
 	return 1;
 }
@@ -392,7 +373,6 @@ int libburner_format(struct burn_drive *drive)
 		fprintf(stderr, "FATAL: Can only format DVD-RW or BD\n");
 		return 0;
 	}
-	burn_set_signal_handling("libburner : ", NULL, 0x30);
 
 	printf("Beginning to format media.\n");
 	burn_disc_format(drive, size, format_flag);
@@ -405,9 +385,6 @@ int libburner_format(struct burn_drive *drive)
 		printf("Formatting  ( %.1f%% done )\n", percent);
 		sleep(1);
 	}
-	if (burn_is_aborting(0) > 0)
-		return -1;
-	burn_set_signal_handling("libburner : ", NULL, 0x0);
 	burn_disc_get_profile(drive_list[0].drive, &current_profile,
 				 current_profile_name);
 	if (current_profile == 0x14 || current_profile == 0x13)
@@ -553,7 +530,6 @@ int libburner_payload(struct burn_drive *drive,
 		fprintf(stderr, "Reasons given:\n%s\n", reasons);
 		return 0;
 	}
-	burn_set_signal_handling("libburner : ", NULL, 0x30);
 
 	printf("Burning starts. With e.g. 4x media expect up to a minute of zero progress.\n");
 	start_time = time(0);
@@ -601,8 +577,6 @@ int libburner_payload(struct burn_drive *drive,
 	}
 	burn_session_free(session);
 	burn_disc_free(target_disc);
-	if (burn_is_aborting(0) > 0)
-		return -1;
 	if (multi && current_profile != 0x1a && current_profile != 0x13 &&
 		current_profile != 0x12 && current_profile != 0x43) 
 			/* not with DVD+RW, formatted DVD-RW, DVD-RAM, BD-RE */
@@ -738,13 +712,6 @@ int main(int argc, char **argv)
 {
 	int ret;
 
-	/* A warning to programmers who start their own projekt from here. */
-	if (sizeof(off_t) != 8) {
-		 fprintf(stderr,
-	   "\nFATAL: Compile time misconfiguration. off_t is not 64 bit.\n\n");
-		 exit(39);
-	}
-
 	ret = libburner_setup(argc, argv);
 	if (ret)
 		exit(ret);
@@ -761,9 +728,9 @@ int main(int argc, char **argv)
 	/* Print messages of severity SORRY or more directly to stderr */
 	burn_msgs_set_severities("NEVER", "SORRY", "libburner : ");
 
-	/* Activate the synchronous signal handler which eventually will try to
+	/* Activate the default signal handler which eventually will try to
 	   properly shutdown drive and library on aborting events. */
-	burn_set_signal_handling("libburner : ", NULL, 0x0);
+	burn_set_signal_handling("libburner : ", NULL, 0);
 
 	/** Note: driveno might change its value in this call */
 	ret = libburner_aquire_drive(drive_adr, &driveno);
@@ -795,14 +762,10 @@ release_drive:;
 		burn_drive_release(drive_list[driveno].drive, 0);
 
 finish_libburn:;
-	if (burn_is_aborting(0) > 0) {
-		burn_abort(4400, burn_abort_pacifier, "libburner : ");
-		fprintf(stderr,"\nlibburner run aborted\n");
-		exit(1);
-	} 
 	/* This app does not bother to know about exact scan state. 
 	   Better to accept a memory leak here. We are done anyway. */
 	/* burn_drive_info_free(drive_list); */
+
 	burn_finish();
 	exit(ret);
 }

test/offst_source.c

@@ -1,134 +0,0 @@
-
-/*
-  cc -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS -g -o test/offst_source test/offst_source.c -lburn
-*/
-
-#include "../libburn/libburn.h" 
-
-/* Just everything from test/libburner.c */
-#include <stdio.h>
-#include <ctype.h>
-#include <sys/types.h>
-#include <unistd.h>
-#include <string.h>
-#include <stdlib.h>
-#include <time.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <fcntl.h>
-
-
-static int create_original(struct burn_source **original, char *path, int flag)
-{
-	printf("create_original: path='%s'\n", path);
-	*original = burn_file_source_new(path, NULL);
-	if (*original == NULL)
-		return 0;
-	return 1;
-}
-
-
-static int set_up_offst_sources(struct burn_source *original,
-				struct burn_source *offsetters[],
-				int count, int flag)
-{
-	int i;
-	off_t start = 3, size = 10, gap = 7;
-
-	for (i = 0; i < count; i++) {
-		offsetters[i] = burn_offst_source_new(original,
-					i > 0 ? offsetters[i - 1] : NULL,
-					start, size, 0);
-		if (offsetters[i] == NULL)
-			return 0;
-		printf("set_up_offst_sources: idx=%d, start=%d\n",
-			 i, (int) start);
-		start += size + gap;
-	}
-	return 1;
-}
-
-
-static int consume_source(struct burn_source *src, int flag)
-{
-	int ret, count = 0;
-	unsigned char buf[1];
-
-	while (1) {
-		ret = src->read_xt(src, buf, 1);
-		if (ret < 0) {
-			printf("\n");
-			fprintf(stderr, "consume_source: count=%d, ret=%d\n",
-					count, ret);
-			return 0;
-		}
-		if (ret == 0)
-	break;
-		printf("%u ", buf[0]);
-		count++;
-	}
-	printf(" count=%d\n", count);
-	return 1;
-}
-
-
-static int consume_all_sources(struct burn_source *offsetters[],
-                                int count, int flag)
-{
-	int i, ret;
-
-	for (i = 0; i < count; i++) {
-		printf("consume_source: idx=%d\n", i);
-		ret = consume_source(offsetters[i], 0);
-		if (ret <= 0)
-			return ret;
-	}
-	return 1;
-}
-
-
-static int free_all_sources(struct burn_source *original,
-                                struct burn_source *offsetters[],
-                                int count, int flag)
-{
-	int i;
-
-	for (i = 0; i < count; i++)
-		burn_source_free(offsetters[i]);
-	burn_source_free(original);
-	return 1;
-}
-
-
-int main(int argc, char **argv)
-{
-	int ret;
-	char *path = "./COPYRIGHT";
-	struct burn_source *original = NULL, *offsetters[4];
-
-	if (argc > 1)
-		path = argv[1];
-
-	if (burn_initialize() == 0)
-		exit(1);
-
-	ret = create_original(&original, path, 0);
-	if (ret <= 0)
-		exit(2);
-
-	ret = set_up_offst_sources(original, offsetters, 4, 0);
-	if (ret <= 0)
-		exit(3);
-
-	ret = consume_all_sources(offsetters, 4, 0);
-	if (ret <= 0)
-		exit(4);
-
-	ret = free_all_sources(original, offsetters, 4, 0);
-	if (ret <= 0)
-		exit(5);
-
-	burn_finish();
-	exit(0);
-}
-

test/poll.c

@@ -20,6 +20,8 @@ static void catch_int ()
 
 static void poll_drive(int d)
 {
+	enum burn_disc_status s;
+
 	fprintf(stderr, "polling disc in %s - %s:\n",
 		drives[d].vendor, drives[d].product);
 
@@ -31,7 +33,8 @@ static void poll_drive(int d)
 	while (burn_drive_get_status(drives[d].drive, NULL))
 		usleep(1000);
 
-	while (burn_disc_get_status(drives[d].drive) == BURN_DISC_UNREADY)
+	while ((s = burn_disc_get_status(drives[d].drive))
+	       == BURN_DISC_UNREADY)
 		usleep(1000);
 	
 	while (NEXT == 0) {
@@ -64,7 +67,7 @@ int main()
 
 	newact.sa_handler = catch_int;
 	sigaction(SIGINT, &newact, &oldact);
-	for (i = 0; i < (int) n_drives; i++) {
+	for (i = 0; i < n_drives; i++) {
 	    NEXT=0;
 	    poll_drive(i);
 	}

test/telltoc.c

@@ -1,6 +1,6 @@
 
 /*  test/telltoc.c , API illustration of obtaining media status info */
-/*  Copyright (C) 2006 - 2011 Thomas Schmitt <scdbackup@gmx.net> 
+/*  Copyright (C) 2006 - 2010 Thomas Schmitt <scdbackup@gmx.net> 
     Provided under GPL */
 
 /**                               Overview 
@@ -178,7 +178,7 @@ int telltoc_aquire_by_driveno(int *driveno, int silent_drive)
 	}
 	fprintf(stderr, "Done\n");
 
-	for (i = 0; i < (int) drive_count; i++) {
+	for (i = 0; i < drive_count; i++) {
 		if (*driveno >= 0 && (silent_drive || *driveno != i))
 	continue;
 		if (burn_drive_get_adr(&(drive_list[i]), adr) <=0)
@@ -197,7 +197,7 @@ int telltoc_aquire_by_driveno(int *driveno, int silent_drive)
 	/* We already made our choice via command line. (default is 0)
 	   So we just have to keep our desired drive and drop all others.
 	 */
-	if ((int) drive_count <= *driveno) {
+	if (drive_count <= *driveno) {
 		fprintf(stderr,
 			"Found only %d drives. Number %d not available.\n",
 			drive_count, *driveno);
@@ -205,7 +205,7 @@ int telltoc_aquire_by_driveno(int *driveno, int silent_drive)
 	}
 
 	/* Drop all drives which we do not want to use */
-	for (i = 0; i < (int) drive_count; i++) {
+	for (i = 0; i < drive_count; i++) {
 		if (i == *driveno) /* the one drive we want to keep */
 	continue;
 		ret = burn_drive_info_forget(&(drive_list[i]),0);