Created 0.1.0pl01 branch

libisoburn/branches/ZeroOneZero-pl01/AUTHORS

@@ -0,0 +1,3 @@
+Thomas Schmitt
+Vreixo Formoso Lopes
+

libisoburn/branches/ZeroOneZero-pl01/COPYING

@@ -0,0 +1,280 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+     59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS

libisoburn/branches/ZeroOneZero-pl01/COPYRIGHT

@@ -0,0 +1,22 @@
+Vreixo Formoso <metalpain2002@yahoo.es> 
+Thomas Schmitt <scdbackup@gmx.net>
+libisoburn is Copyright (C) 2007-2008 Vreixo Formoso, Thomas Schmitt
+xorriso is Copyright (C) 2007-2008 Thomas Schmitt
+libisofs (if included) is Copyright (C) 2007-2008 Vreixo Formoso
+libburn (if included) is Copyright (C) 2002-2006 Derek Foreman, Ben Jansens
+                     and Copyright (C) 2006-2008 Mario Danic, Thomas Schmitt
+
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

libisoburn/branches/ZeroOneZero-pl01/INSTALL

@@ -0,0 +1,237 @@
+
+See file README for libisoburn and xorriso specific installation instructions.
+This file here is rather a manual for advanced usage of ./configure
+
+-------------------------------------------------------------------
+
+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005,
+2006 Free Software Foundation, Inc.
+
+This file is free documentation; the Free Software Foundation gives
+unlimited permission to copy, distribute and modify it.
+
+Basic Installation
+==================
+
+Briefly, the shell commands `./configure; make; make install' should
+configure, build, and install this package.  The following
+more-detailed instructions are generic; see the `README' file for
+instructions specific to this package.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+   It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring.  Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+   The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'.  You need `configure.ac' if
+you want to change it or regenerate `configure' using a newer version
+of `autoconf'.
+
+The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.
+
+     Running `configure' might take a while.  While running, it prints
+     some messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.
+
+  5. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+Compilers and Options
+=====================
+
+Some systems require unusual options for compilation or linking that the
+`configure' script does not know about.  Run `./configure --help' for
+details on some of the pertinent environment variables.
+
+   You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment.  Here
+is an example:
+
+     ./configure CC=c99 CFLAGS=-g LIBS=-lposix
+
+   *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you can use GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+   With a non-GNU `make', it is safer to compile the package for one
+architecture at a time in the source code directory.  After you have
+installed the package for one architecture, use `make distclean' before
+reconfiguring for another architecture.
+
+Installation Names
+==================
+
+By default, `make install' installs the package's commands under
+`/usr/local/bin', include files under `/usr/local/include', etc.  You
+can specify an installation prefix other than `/usr/local' by giving
+`configure' the option `--prefix=PREFIX'.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+pass the option `--exec-prefix=PREFIX' to `configure', the package uses
+PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=DIR' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+There may be some features `configure' cannot figure out automatically,
+but needs to determine by the type of machine the package will run on.
+Usually, assuming the package is built to be run on the _same_
+architectures, `configure' can figure that out, but if it prints a
+message saying it cannot guess the machine type, give it the
+`--build=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+     CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+     OS KERNEL-OS
+
+   See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+   If you are _building_ compiler tools for cross-compiling, you should
+use the option `--target=TYPE' to select the type of system they will
+produce code for.
+
+   If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+If you want to set default values for `configure' scripts to share, you
+can create a site shell script called `config.site' that gives default
+values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+Variables not defined in a site shell script can be set in the
+environment passed to `configure'.  However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost.  In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'.  For example:
+
+     ./configure CC=/usr/local2/bin/gcc
+
+causes the specified `gcc' to be used as the C compiler (unless it is
+overridden in the site shell script).
+
+Unfortunately, this technique does not work for `CONFIG_SHELL' due to
+an Autoconf bug.  Until the bug is fixed you can use this workaround:
+
+     CONFIG_SHELL=/bin/bash /bin/bash ./configure CONFIG_SHELL=/bin/bash
+
+`configure' Invocation
+======================
+
+`configure' recognizes the following options to control how it operates.
+
+`--help'
+`-h'
+     Print a summary of the options to `configure', and exit.
+
+`--version'
+`-V'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`--cache-file=FILE'
+     Enable the cache: use and save the results of the tests in FILE,
+     traditionally `config.cache'.  FILE defaults to `/dev/null' to
+     disable caching.
+
+`--config-cache'
+`-C'
+     Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`configure' also accepts some other, not widely useful, options.  Run
+`configure --help' for more details.
+

libisoburn/branches/ZeroOneZero-pl01/Makefile.am

@@ -0,0 +1,129 @@
+pkgconfigdir=$(libdir)/pkgconfig
+libincludedir=$(includedir)/libisoburn
+
+lib_LTLIBRARIES = libisoburn/libisoburn.la 
+
+## ========================================================================= ##
+
+# Build libraries
+libisoburn_libisoburn_la_LDFLAGS = \
+	-version-info $(LT_CURRENT):$(LT_REVISION):$(LT_AGE)
+libisoburn_libisoburn_la_SOURCES = \
+	libisoburn/burn_wrap.c \
+	libisoburn/data_source.c \
+	libisoburn/isoburn.c \
+	libisoburn/isoburn.h \
+	libisoburn/isofs_wrap.c \
+	libisoburn/libisoburn.h \
+	version.h
+
+libinclude_HEADERS = \
+	libisoburn/libisoburn.h 
+
+## ========================================================================= ##
+
+
+# This is the reference application of libisoburn. See man xorriso/xorriso.1
+# 
+bin_PROGRAMS = \
+	xorriso/xorriso
+
+xorriso_xorriso_CPPFLAGS = -Ilibisoburn
+xorriso_xorriso_CFLAGS = -DXorriso_with_maiN -DXorriso_with_regeX $(READLINE_DEF)
+xorriso_xorriso_LDADD = libisoburn/libisoburn.la -lisofs -lburn $(THREAD_LIBS)
+xorriso_xorriso_SOURCES = \
+	xorriso/xorriso.h \
+	xorriso/xorriso_private.h \
+	xorriso/xorriso.c \
+	xorriso/xorrisoburn.h \
+	xorriso/xorrisoburn.c \
+	xorriso/xorriso_timestamp.h
+
+
+## Build test applications
+noinst_PROGRAMS = \
+	test/compare_file
+
+# A program to compare two files in mirrored trees in mounted filesystems
+# To compare tree /media/dvd and /original/dir :
+#   find /media/dvd -exec test/compare_file '{}' /media/dvd /original/dir ';'
+#
+test_compare_file_CPPFLAGS =
+test_compare_file_CFLAGS =
+test_compare_file_LDADD =
+test_compare_file_SOURCES = test/compare_file.c
+
+# ts A80110 - A80210 : we need as minimal demo something better than test.c 
+#	test/test
+
+# test_test_CPPFLAGS = -Ilibisofs -Ilibburn -Ilibisoburn
+# test_test_LDADD = $(libisoburn_libisoburn_la_OBJECTS) $(THREAD_LIBS) -lburn -lisofs
+# test_test_SOURCES = test/test.c 
+
+
+## ========================================================================= ##
+
+## Build documentation (You need Doxygen for this to work)
+webhost = http://libburn-api.pykix.org
+webpath = /
+docdir = $(DESTDIR)$(prefix)/share/doc/$(PACKAGE)-$(VERSION)
+
+doc:	doc/html
+
+doc/html: doc/doxygen.conf
+	if [ -f ./doc/doc.lock ]; then \
+		$(RM) -r doc/html; \
+		doxygen doc/doxygen.conf; \
+	fi
+
+doc-upload: doc/html
+	scp -r $</* $(webhost):$(webpath)
+
+all: doc
+
+install-data-local: 
+	if [ -f ./doc/doc.lock ]; then \
+		$(mkinstalldirs) $(docdir)/html; \
+		$(INSTALL_DATA) doc/html/* $(docdir)/html; \
+	fi
+
+uninstall-local:
+	rm -rf $(docdir)
+
+## ========================================================================= ##
+
+# Indent source files
+indent_files = \
+	$(libisoburn_libisoburn_la_SOURCES)
+	
+
+indent: $(indent_files)
+	indent -bad -bap -nbbb -nbbo -nbc -bli0 -br -bls   \
+		-cdw -ce -cli0 -ncs -nbfda -i8 -l79 -lc79   \
+		-lp -saf -sai -nprs -npsl -saw -sob -ss -ut \
+		-sbi0 -nsc -ts8 -npcs -ncdb -fca            \
+		$^
+
+.PHONY: indent
+
+## ========================================================================= ##
+
+# Extra things
+nodist_pkgconfig_DATA = \
+	libisoburn-1.pc
+
+man_MANS = xorriso/xorriso.1
+
+EXTRA_DIST = \
+	libisoburn-1.pc.in \
+	version.h.in \
+	README \
+	AUTHORS \
+	CONTRIBUTORS \
+	COPYRIGHT \
+	COPYING \
+	INSTALL \
+	xorriso/changelog.txt \
+	xorriso/README \
+	$(man_MANS)
+

libisoburn/branches/ZeroOneZero-pl01/README

@@ -0,0 +1,152 @@
+------------------------------------------------------------------------------
+                          libburnia-project.org
+------------------------------------------------------------------------------
+libisoburn. By Vreixo Formoso <metalpain2002@yahoo.es> 
+            and Thomas Schmitt <scdbackup@gmx.net>
+Integrated sub project of libburnia-project.org.
+Copyright (C) 2006-2008 Vreixo Formoso, Thomas Schmitt.
+Provided under GPL version 2.
+------------------------------------------------------------------------------
+
+libisoburn is a frontend for libraries libburn and libisofs which enables
+creation and expansion of ISO-9660 filesystems on all CD/DVD media supported
+by libburn. This includes media like DVD+RW, which do not support multi-session
+management on media level and even plain disk files or block devices.
+
+The price for that is thorough specialization on data files in ISO-9660
+filesystem images. So libisoburn is not suitable for audio (CD-DA) or any
+other CD layout which does not entirely consist of ISO-9660 sessions.
+
+Currently it is only supported on Linux with kernels >= 2.4.
+
+By using this software you agree to the disclaimer at the end of this text:
+"... without even the implied warranty ..."
+
+
+                   Compilation, First Glimpse, Installation
+
+Dynamic library and compile time header requirements for libisoburn-0.1.0 :
+- libburn.so.4  , version libburn-0.4.2 or higher
+- libisofs.so.6 , version libisofs-0.6.2 or higher
+libisoburn and xorriso will not start with libraries which are older than their
+headers seen at compile time. So compile in the oldest possible installation
+setup unless you have reason to enforce a newer bug fix level.
+
+Obtain libisoburn-0.1.0.tar.gz, take it to a directory of your choice and do:
+
+    tar xzf libisoburn-0.1.0.tar.gz
+    cd libisoburn-0.1.0
+
+Within that directory execute:
+
+    ./configure --prefix=/usr
+    make
+
+Then become superuser and execute
+    make install
+which will make available libisoburn.so.1 .
+
+For the API concepts and calls see
+    ./libisoburn/libisoburn.h
+as well as
+    /usr/lib/libisofs/libisofs.h
+    /usr/lib/libburn/libburn.h
+
+
+                              xorriso
+
+libisoburn includes a command line and dialog application named xorriso,
+which offers a substantial part of libisoburn features to shell scripts and
+users. Its file xorriso/README describes a standlone tarball as first
+preference for xorriso installation.
+The installation described here produces a dynamically linked xorriso binary
+as described in chapter "libisoburn" at the end of that text.
+
+After installation documentation is available via
+    man xorriso
+
+
+                       Drives and Disk File Objects 
+
+The user of libisoburn applications needs rw-permission for the CD/DVD burner
+devices which shall be used.
+A list of rw-accessible drives can be obtained by
+    xorriso -devices
+resp. by libburn API call
+    burn_drive_scan()
+
+
+A possible source of problems are hald or other automounters. 
+If you can spot a process "hald-addon-storage" with the address of
+your desired drive, then consider to kill it.
+
+If you cannot get rid of the automounter that easily, try whether it helps
+to always load the drive tray manually before starting a write run of
+xorriso. Wait until the drive light is off.
+Better try to unmount an eventually mounted media before a write run.
+
+
+Besides true optical drives, libisoburn can also address disk files as input or
+output drives. The addresses of the disk files have to be preceded by "stdio:".
+Like:
+    "stdio:/tmp/pseudo_drive"
+
+
+                              Testing
+
+We are quite sure that libisofs produces accurate representations of the disk
+files. This opinion is founded on a lot of test burns and checks by a little
+test program which compares files from the mounted image with the orignals
+on disk. It uses the normal POSIX filesystem calls, i.e. no libburnia stuff.
+
+This program is not installed systemwide but stays in the installation
+directory of the xorriso tarball as  test/compare_file . Usually it is
+run as -exec payload of a find command. It demands at least three arguments:
+The path of the first file to compare, the prefix1 to be cut off from path
+and the prefix2 which gets prepended afterwards to obtain the path of the
+second file to compare.
+As further argument there can be -no_ctime which suppresses the comparison
+of ctime date stamps.
+The exit value is 0 if no difference was detected, non-0 else.
+
+Example: After
+   xorriso ... -pathspecs on -add /=/original/dir --
+   mount /media/dvd
+   cd test
+compare tree /media/dvd with tree /original/dir :
+   find /original/dir -exec ./compare_file '{}' /original/dir /media/dvd ';' \
+   | less
+and vice versa:
+   find /media/dvd -exec ./compare_file '{}' /media/dvd /original/dir ';' \
+   | less
+
+
+------------------------------------------------------------------------------
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License version 2 as
+    published by the Free Software Foundation.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+------------------------------------------------------------------------------
+Based on and sub project of:
+libburnia-project.org
+By Mario Danic           <mario.danic@gmail.com>,
+   Vreixo Formoso        <metalpain2002@yahoo.es>
+   Thomas Schmitt        <scdbackup@gmx.net>
+Copyright (C) 2006-2008 Mario Danic, Vreixo Formoso, Thomas Schmitt.
+
+libburnia-project.org is inspired by and in other components still containing
+parts of old
+Libburn. By Derek Foreman <derek@signalmarketing.com> and
+            Ben Jansens <xor@orodu.net>
+Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
+

libisoburn/branches/ZeroOneZero-pl01/TODO

@@ -0,0 +1,11 @@
+[Task] Figure out how to use "Requires" in pc.in (libisoburn and libisofs would benefit)
+[Task] Figure out the usage of Libs.private (used in libburn)
+[Task] Improve build system 
+[Task] Investigate build system, so other libburnia components can benefit
+[Task] Write Doxygen files
+[Task] Explain to Thomas & Vreixo about NEWS importance (all libburnia components
+       will benefit
+[Task] Write a document about ABI & API
+[Task] Create following targets for make: Src, Indent, Docs, Test, All [Any other suggestions?)
+
+All those tasks are currently assigned to Mario.

libisoburn/branches/ZeroOneZero-pl01/acinclude.m4

@@ -0,0 +1,22 @@
+AC_DEFUN([TARGET_SHIZZLE],
+[
+  ARCH=""
+
+  AC_MSG_CHECKING([target operating system])
+
+  case $target in
+    *-*-linux*)
+      ARCH=linux
+      LIBBURN_ARCH_LIBS=
+      ;;
+    *-*-freebsd*)
+      ARCH=freebsd
+      LIBBURN_ARCH_LIBS=-lcam
+      ;;
+    *)
+      AC_ERROR([You are attempting to compile for an unsupported platform])
+      ;;
+  esac
+
+  AC_MSG_RESULT([$ARCH])
+])

libisoburn/branches/ZeroOneZero-pl01/bootstrap

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

libisoburn/branches/ZeroOneZero-pl01/configure.ac

@@ -0,0 +1,125 @@
+AC_INIT([libisoburn], [0.1.0], [http://libburnia-project.org])
+AC_PREREQ([2.50])
+dnl AC_CONFIG_HEADER([config.h])	
+
+AC_CANONICAL_HOST
+AC_CANONICAL_TARGET
+
+AM_INIT_AUTOMAKE([subdir-objects])
+
+dnl The API version codes are now defined in libisoburn/libisoburn.h
+dnl #define  isoburn_header_version_*
+dnl configure.ac only rules the libtool revision numbering about
+dnl LT_CURREN, LT_AGE, LT_REVISION where SONAME becomes LT_CURRENT - LT_AGE
+dnl 
+dnl These three are only copies to provide libtool with unused LT_RELEASE
+ISOBURN_MAJOR_VERSION=0
+ISOBURN_MINOR_VERSION=1
+ISOBURN_MICRO_VERSION=0
+dnl ISOBURN_VERSION=$ISOBURN_MAJOR_VERSION.$ISOBURN_MINOR_VERSION.$ISOBURN_MICRO_VERSION
+ 
+AC_SUBST(ISOBURN_MAJOR_VERSION)
+AC_SUBST(ISOBURN_MINOR_VERSION)
+AC_SUBST(ISOBURN_MICRO_VERSION)
+dnl AC_SUBST(ISOBURN_VERSION)
+
+dnl Libtool versioning
+dnl Generate libisoburn.so.1.x.y
+dnl SONAME will become LT_CURRENT - LT_AGE
+dnl 
+dnl ts A80215
+dnl This ist the first release version after unreleased libisoburn.so.1.0.0
+dnl ### development: LT_CURRENT++, LT_AGE++ has not happened meanwhile.
+dnl
+dnl SONAME = 2 - 1 = 1 . Library name = libburn.so.1.1.0
+LT_RELEASE=$ISOBURN_MAJOR_VERSION.$ISOBURN_MINOR_VERSION
+LT_CURRENT=2
+LT_AGE=1
+LT_REVISION=0
+LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
+
+AC_SUBST(LT_RELEASE)
+AC_SUBST(LT_CURRENT)
+AC_SUBST(LT_REVISION)
+AC_SUBST(LT_AGE)
+AC_SUBST(LT_CURRENT_MINUS_AGE)
+
+AC_PREFIX_DEFAULT([/usr/local])
+test "$prefix" = "NONE" && prefix=$ac_default_prefix
+
+AM_MAINTAINER_MODE
+
+AM_PROG_CC_C_O
+AC_C_CONST
+AC_C_INLINE
+AC_C_BIGENDIAN
+
+dnl Large file support
+AC_SYS_LARGEFILE
+AC_FUNC_FSEEKO
+AC_CHECK_FUNC([fseeko])
+if test ! $ac_cv_func_fseeko; then
+   AC_ERROR([Libburn requires largefile support.])
+fi
+
+AC_PROG_LIBTOOL
+AC_SUBST(LIBTOOL_DEPS)
+LIBTOOL="$LIBTOOL --silent"
+
+AC_PROG_INSTALL
+
+AC_CHECK_HEADERS()
+
+THREAD_LIBS=-lpthread
+AC_SUBST(THREAD_LIBS)
+
+TARGET_SHIZZLE
+AC_SUBST(ARCH)
+AC_SUBST(LIBBURN_ARCH_LIBS)
+
+
+dnl Check whether there is readline-devel and readline-runtime.
+dnl If not, erase this macro which would enable use of readline(),add_history()
+READLINE_DEF="-DXorriso_with_readlinE"
+dnl The empty yes case obviously causes -lreadline to be linked
+AC_CHECK_HEADER(readline/readline.h, AC_CHECK_LIB(readline, readline, , READLINE_DEF= ), READLINE_DEF= )
+dnl The X= in the yes case prevents that -lreadline gets linked twice
+AC_CHECK_HEADER(readline/history.h, AC_CHECK_LIB(readline, add_history, X= , READLINE_DEF= ), READLINE_DEF= )
+AC_SUBST(READLINE_DEF)
+
+
+AC_CHECK_HEADER(libburn/libburn.h)
+AC_CHECK_HEADER(libisofs/libisofs.h)
+
+dnl Check for proper library versions
+LIBBURN_REQUIRED=0.4.2
+LIBISOFS_REQUIRED=0.6.2
+PKG_CHECK_MODULES(LIBBURN, libburn-1 >= $LIBBURN_REQUIRED)
+PKG_CHECK_MODULES(LIBISOFS, libisofs-1 >= $LIBISOFS_REQUIRED)
+
+dnl Add compiler-specific flags
+
+dnl See if the user wants aggressive optimizations of the code
+AC_ARG_ENABLE(debug,
+[  --enable-debug          Disable aggressive optimizations [default=yes]],
+              , enable_debug=yes)
+if test x$enable_debug != xyes; then
+    if test x$GCC = xyes; then
+        CFLAGS="$CFLAGS -O3"
+        CFLAGS="$CFLAGS -fexpensive-optimizations"
+    fi
+    CFLAGS="$CFLAGS -DNDEBUG"
+else
+    if test x$GCC = xyes; then
+        CFLAGS="$CFLAGS -g -pedantic -Wall"
+    fi
+    CFLAGS="$CFLAGS -DDEBUG"
+fi
+
+AC_CONFIG_FILES([
+	Makefile
+	doc/doxygen.conf
+	version.h
+	libisoburn-1.pc
+	])
+AC_OUTPUT

libisoburn/branches/ZeroOneZero-pl01/libisoburn-1.pc.in

@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libisoburn
+Description: Multi-session filesystem extension to libisofs, libburn.
+Version: @VERSION@
+Requires: 
+Libs: -L${libdir} -lisoburn
+Cflags: -I${includedir}/libisoburn
+

libisoburn/branches/ZeroOneZero-pl01/libisoburn/burn_wrap.c

@@ -0,0 +1,796 @@
+
+/*
+   cc -g -c \
+      -D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1 -D_LARGEFILE64_SOURCE \
+      burn_wrap.c
+*/
+/* libburn wrappers for libisoburn 
+
+   Copyright 2007 Thomas Schmitt, <scdbackup@gmx.net> 
+*/
+
+/* <<< A70929 : hardcoded CD-RW with fabricated -msinfo 
+#define Hardcoded_cd_rW 1
+#define Hardcoded_cd_rw_c1     12999
+#define Hardcoded_cd_rw_nwA   152660 
+*/
+
+#include <stdio.h>
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdlib.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+
+#ifndef Xorriso_standalonE
+
+#include <libburn/libburn.h>
+
+#include <libisofs/libisofs.h>
+
+#else /* ! Xorriso_standalonE */
+
+#include "../libisofs/libisofs.h"
+#include "../libburn/libburn.h"
+
+#endif /* Xorriso_standalonE */
+
+
+#include "libisoburn.h"
+#include "isoburn.h"
+
+
+/* The global list of isoburn objects. Usually there is only one. */
+extern struct isoburn *isoburn_list_start; /* in isoburn.c */
+
+
+int isoburn_initialize(char msg[1024], int flag)
+{
+ int major, minor, micro, bad_match= 0;
+
+
+/* First two ugly compile time checks for header version compatibility.
+   If everthing matches, then they produce no C code. In case of mismatch,
+   intentionally faulty C code will be inserted.
+*/
+
+#ifdef iso_lib_header_version_major
+/* The minimum requirement of libisoburn towards the libisofs header
+   at compile time is defined in libisoburn/libisoburn.h :
+     isoburn_libisofs_req_major
+     isoburn_libisofs_req_minor
+     isoburn_libisofs_req_micro
+   It gets compared against the version macros in libisofs/libisofs.h :
+     iso_lib_header_version_major
+     iso_lib_header_version_minor
+     iso_lib_header_version_micro
+   If the header is too old then the following code shall cause failure of
+   cdrskin compilation rather than to allow production of a program with
+   unpredictable bugs or memory corruption.
+   The compiler messages supposed to appear in this case are:
+      error: 'LIBISOFS_MISCONFIGURATION' undeclared (first use in this function)
+      error: 'INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisofs_dot_h_TOO_OLD__SEE_libisoburn_dot_h_and_burn_wrap_dot_h' undeclared (first use in this function)
+      error: 'LIBISOFS_MISCONFIGURATION_' undeclared (first use in this function)
+*/
+/* The indendation is an advise of man gcc to help old compilers ignoring */
+ #if isoburn_libisofs_req_major > iso_lib_header_version_major
+ #define Isoburn_libisofs_dot_h_too_olD 1
+ #endif
+ #if isoburn_libisofs_req_major == iso_lib_header_version_major && isoburn_libisofs_req_minor > iso_lib_header_version_minor
+ #define Isoburn_libisofs_dot_h_too_olD 1
+ #endif
+ #if isoburn_libisofs_req_minor == iso_lib_header_version_minor && isoburn_libisofs_req_micro > iso_lib_header_version_micro
+ #define Isoburn_libisofs_dot_h_too_olD 1
+ #endif
+
+#ifdef Isoburn_libisofs_dot_h_too_olD
+LIBISOFS_MISCONFIGURATION = 0;
+INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisofs_dot_h_TOO_OLD__SEE_libisoburn_dot_h_and_burn_wrap_dot_h = 0;
+LIBISOFS_MISCONFIGURATION_ = 0;
+#endif
+
+#endif /* iso_lib_header_version_major */
+
+/* The minimum requirement of libisoburn towards the libburn header
+   at compile time is defined in libisoburn/libisoburn.h :
+     isoburn_libburn_req_major
+     isoburn_libburn_req_minor
+     isoburn_libburn_req_micro
+   It gets compared against the version macros in libburn/libburn.h :
+     burn_header_version_major
+     burn_header_version_minor
+     burn_header_version_micro
+   If the header is too old then the following code shall cause failure of
+   cdrskin compilation rather than to allow production of a program with
+   unpredictable bugs or memory corruption.
+   The compiler messages supposed to appear in this case are:
+      error: 'LIBBURN_MISCONFIGURATION' undeclared (first use in this function)
+      error: 'INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libburn_dot_h_TOO_OLD__SEE_libisoburn_dot_h_and_burn_wrap_dot_h' undeclared (first use in this function)
+      error: 'LIBBURN_MISCONFIGURATION_' undeclared (first use in this function)
+*/
+
+/* The indendation is an advise of man gcc to help old compilers ignoring */
+ #if isoburn_libburn_req_major > burn_header_version_major
+ #define Isoburn_libburn_dot_h_too_olD 1
+ #endif
+ #if isoburn_libburn_req_major == burn_header_version_major && isoburn_libburn_req_minor > burn_header_version_minor
+ #define Isoburn_libburn_dot_h_too_olD 1
+ #endif
+ #if isoburn_libburn_req_minor == burn_header_version_minor && isoburn_libburn_req_micro > burn_header_version_micro
+ #define Isoburn_libburn_dot_h_too_olD 1
+ #endif
+
+#ifdef Isoburn_libburn_dot_h_too_olD
+LIBBURN_MISCONFIGURATION = 0;
+INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libburn_dot_h_TOO_OLD__SEE_libisoburn_dot_h_and_burn_wrap_dot_h = 0;
+LIBBURN_MISCONFIGURATION_ = 0;
+#endif
+
+/* End of ugly compile time tests (scroll up for explanation) */
+
+
+
+ msg[0]= 0;
+ if(iso_init()<0) {
+   sprintf(msg+strlen(msg), "Cannot initialize libisofs\n");
+   return(0);
+ }
+ iso_lib_version(&major, &minor, &micro);
+ sprintf(msg+strlen(msg), "libisofs-%d.%d.%d ", major, minor, micro);
+#ifdef iso_lib_header_version_major
+ if(iso_lib_is_compatible(iso_lib_header_version_major,
+                          iso_lib_header_version_minor,
+                          iso_lib_header_version_micro)) {
+   sprintf(msg+strlen(msg), "ok, ");
+ } else {
+   sprintf(msg+strlen(msg),"- TOO OLD -, need at least libisofs-%d.%d.%d ,\n",
+           iso_lib_header_version_major, iso_lib_header_version_minor,
+           iso_lib_header_version_micro);
+   bad_match= 1;
+ }
+#else
+ if(iso_lib_is_compatible(isoburn_libisofs_req_major,
+                          isoburn_libisofs_req_minor,
+                          isoburn_libisofs_req_micro)) {
+   sprintf(msg+strlen(msg), "suspicious, ");
+ } else {
+   sprintf(msg+strlen(msg),"- TOO OLD -, need at least libisofs-%d.%d.%d ,\n",
+           isoburn_libisofs_req_major, isoburn_libisofs_req_minor,
+           isoburn_libisofs_req_micro);
+   bad_match= 1;
+ }
+#endif /* ! iso_lib_header_version_major */
+
+ if(!burn_initialize()) {
+   sprintf(msg+strlen(msg), "Cannot initialize libburn\n");
+   return(0);
+ }
+ burn_version(&major, &minor, &micro);
+ sprintf(msg+strlen(msg), "libburn-%d.%d.%d ", major, minor, micro);
+ if(major > burn_header_version_major
+    || (major == burn_header_version_major
+        && (minor > burn_header_version_minor
+            || (minor == burn_header_version_minor
+                && micro >= burn_header_version_micro)))) {
+   sprintf(msg+strlen(msg), "ok, ");
+ } else {
+   sprintf(msg+strlen(msg), "- TOO OLD -, need at least libburn-%d.%d.%d ,\n",
+           burn_header_version_major, burn_header_version_minor,
+           burn_header_version_micro);
+   bad_match= 1;
+ }
+
+ isoburn_version(&major, &minor, &micro);
+ sprintf(msg+strlen(msg), "for libisoburn-%d.%d.%d", major, minor, micro);
+ if(bad_match)
+   return(0);
+
+ isoburn_destroy_all(&isoburn_list_start, 0); /* isoburn_list_start= NULL */
+ return(1);
+}
+
+
+/* API @since 0.1.0 */
+int isoburn_libisofs_req(int *major, int *minor, int *micro)
+{
+ *major= iso_lib_header_version_major;
+ *minor= iso_lib_header_version_minor;
+ *micro= iso_lib_header_version_micro;
+ return(1);
+}
+
+
+/* API @since 0.1.0 */
+int isoburn_libburn_req(int *major, int *minor, int *micro)
+{
+ *major= burn_header_version_major;
+ *minor= burn_header_version_minor;
+ *micro= burn_header_version_micro;
+ return(1);
+}
+
+
+/** Examine the media and sets appropriate emulation if needed.
+*/ 
+static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
+                                 int flag)
+{
+ int ret, lba, nwa;
+ struct burn_multi_caps *caps= NULL;
+
+ ret= burn_disc_get_multi_caps(d, BURN_WRITE_NONE, &caps, 0);
+ if(ret<0) /* == 0 is read-only media, but it is too early to reject it here */
+   goto ex;
+ ret= isoburn_new(o, 0);
+ if(ret<=0)
+   goto ex;
+ (*o)->drive= d;
+
+#ifdef Hardcoded_cd_rW
+ /* <<< A70929 : hardcoded CD-RW with fabricated -msinfo */
+ caps->start_adr= 0;
+ (*o)->fabricated_disc_status= BURN_DISC_APPENDABLE;
+#endif
+
+ if(caps->start_adr) {         /* set emulation to overwriteable */
+   (*o)->emulation_mode= 1;
+   ret= isoburn_start_emulation(*o, 0);
+   if(ret<=0) {
+     (*o)->emulation_mode= -1;
+     goto ex;
+   }
+ } else {
+
+   /* >>> recognize unsuitable media (but allow read-only media) */;
+
+#ifdef Hardcoded_cd_rW
+   (*o)->nwa= Hardcoded_cd_rw_nwA;
+#else
+   ret= burn_disc_track_lba_nwa(d, NULL, 0, &lba, &nwa);
+   if(ret>0)
+     (*o)->nwa= nwa;
+#endif
+
+ }
+ ret= 1;
+ex:
+ if(caps!=NULL)
+   burn_disc_free_multi_caps(&caps);
+ return(ret);
+}
+
+
+int isoburn_drive_scan_and_grab(struct burn_drive_info *drive_infos[],
+                                char *adr, int load)
+{
+ int ret, conv_ret, drive_grabbed= 0;
+ char libburn_drive_adr[BURN_DRIVE_ADR_LEN];
+ struct isoburn *o= NULL;
+ char msg[BURN_MSGS_MESSAGE_LEN+4096];
+
+ conv_ret= burn_drive_convert_fs_adr(adr, libburn_drive_adr);
+ if(conv_ret<=0) {
+   sprintf(msg, "Unsuitable drive address: '%s'\n",adr);
+   msg[BURN_MSGS_MESSAGE_LEN-1]= 0;
+   burn_msgs_submit(0x00060000, msg, 0, "FAILURE", NULL);
+   ret= 0; goto ex;
+ }
+
+ ret= burn_drive_scan_and_grab(drive_infos, libburn_drive_adr, load);
+ if(ret<=0)
+   goto ex;
+ drive_grabbed= 1;
+ ret= isoburn_welcome_media(&o, (*drive_infos)[0].drive, 0);
+ if(ret<=0)
+   goto ex;
+
+ ret= 1;
+ex:
+ if(ret<=0) {
+   if(drive_grabbed)
+     burn_drive_release((*drive_infos)[0].drive, 0);
+   isoburn_destroy(&o, 0);
+ }
+ return(ret);
+}
+
+
+int isoburn_drive_grab(struct burn_drive *drive, int load)
+{
+ int ret;
+ struct isoburn *o= NULL;
+
+ ret= burn_drive_grab(drive, load);
+ if(ret<=0)
+   goto ex;
+ ret= isoburn_welcome_media(&o, drive, 0);
+ if(ret<=0)
+   goto ex;
+ 
+ ret= 1;
+ex:
+ if(ret<=0)
+   isoburn_destroy(&o,0);
+ return(ret);
+}
+
+
+/** Retrieve media emulation and eventual isoburn emulator of drive.
+    @return -1 unsuitable media, 0 generic media, 1 emulated media.
+*/
+int isoburn_find_emulator(struct isoburn **pt,
+                                 struct burn_drive *drive, int flag)
+{
+ int ret;
+
+ ret= isoburn_find_by_drive(pt, drive, 0);
+ if(ret<=0)
+   return(0);
+ if((*pt)->emulation_mode==-1) {
+   burn_msgs_submit(0x00060000,
+                    "Unsuitable drive and media state", 0, "FAILURE", NULL);
+   return(-1);
+ }
+ if((*pt)->emulation_mode==0)
+   return(0);
+ return(1);
+} 
+
+
+enum burn_disc_status isoburn_disc_get_status(struct burn_drive *drive)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret= isoburn_find_emulator(&o, drive, 0);
+ if(ret<0)
+   return(BURN_DISC_UNSUITABLE);
+ if(o!=NULL)
+   if(o->fabricated_disc_status!=BURN_DISC_UNREADY)
+     return(o->fabricated_disc_status);
+ if(ret==0)
+   return(burn_disc_get_status(drive));
+
+ /* emulated status */
+ if(o->emulation_mode==-1)
+   return(BURN_DISC_UNSUITABLE);
+ if(o->nwa>0)
+   return(BURN_DISC_APPENDABLE);
+ return(BURN_DISC_BLANK);
+}
+
+
+int isoburn_disc_erasable(struct burn_drive *d)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret= isoburn_find_emulator(&o, d, 0);
+ if(ret>0)
+   if(o->emulation_mode==1)
+     return(1);
+ return burn_disc_erasable(d);
+}
+
+
+void isoburn_disc_erase(struct burn_drive *drive, int fast)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret= isoburn_find_emulator(&o, drive, 0);
+ if(ret>0) {
+   if(o->emulation_mode==-1) {
+     /* To cause a negative reply with burn_drive_wrote_well() */
+     burn_drive_cancel(drive);
+     return;
+   }
+   if(o->emulation_mode>0) {
+     ret= isoburn_invalidate_iso(o, 0);
+     if(ret<=0)
+       burn_drive_cancel(drive);
+     return;
+   }
+ }
+ burn_disc_erase(drive, fast);
+}
+
+
+off_t isoburn_disc_available_space(struct burn_drive *d,
+                                   struct burn_write_opts *opts)
+{
+ int ret;
+ struct isoburn *o;
+ off_t avail;
+
+ ret= isoburn_find_emulator(&o, d, 0);
+ if(ret>0 && o!=NULL)
+   if(o->emulation_mode!=0)
+       burn_write_opts_set_start_byte(opts, ((off_t) o->nwa) * (off_t) 2048);
+ avail= burn_disc_available_space(d, opts);
+ return(avail);
+}
+
+
+int isoburn_disc_get_msc1(struct burn_drive *d, int *start_lba)
+{
+ int ret;
+ struct isoburn *o;
+
+#ifdef Hardcoded_cd_rW
+ /* <<< A70929 : hardcoded CD-RW with fabricated -msinfo */
+ *start_lba= Hardcoded_cd_rw_c1;
+ return(1);
+#endif
+
+ if(isoburn_disc_get_status(d)!=BURN_DISC_APPENDABLE &&
+    isoburn_disc_get_status(d)!=BURN_DISC_FULL) {
+   burn_msgs_submit(0x00060000,
+                    "Media contains no recognizable data", 0, "SORRY",NULL);
+   return(0);
+ }
+ ret= isoburn_find_emulator(&o, d, 0);
+ if(ret<0)
+   return(0);
+ if(ret>0) if(o->emulation_mode>0) {
+   *start_lba= 0;
+   return(1);
+ }
+ return(burn_disc_get_msc1(d, start_lba));
+}
+
+
+int isoburn_disc_track_lba_nwa(struct burn_drive *d,
+                               struct burn_write_opts *opts,
+                               int trackno, int *lba, int *nwa)
+{
+ int ret;
+ struct isoburn *o;
+
+#ifdef Hardcoded_cd_rW
+ /* <<< A70929 : hardcoded CD-RW with fabricated -msinfo */
+ *lba= Hardcoded_cd_rw_c1;
+ *nwa= Hardcoded_cd_rw_nwA;
+ return(1);
+#endif
+
+ *nwa= *lba= 0;
+ ret= isoburn_find_emulator(&o, d, 0);
+ if(ret<0)
+   return(0);
+ if(ret>0) if(o->emulation_mode>0) {
+   *lba= 0;
+   *nwa= o->nwa;
+   return(1);
+ }
+ if(burn_drive_get_drive_role(d) != 1)
+   return(1);
+ return(burn_disc_track_lba_nwa(d, opts, trackno, lba, nwa));
+}
+
+
+void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
+{
+ int ret;
+ struct isoburn *o;
+ struct burn_drive *drive;
+ char reasons[BURN_REASONS_LEN],msg[160+BURN_REASONS_LEN];
+ enum burn_write_types write_type;
+
+ drive= burn_write_opts_get_drive(opts);
+ ret= isoburn_find_emulator(&o, drive, 0);
+ if(ret<0)
+   return;
+ if(o!=NULL) {
+   o->wrote_well= -1;
+   if(o->emulation_mode!=0) {
+     burn_write_opts_set_multi(opts, 0);
+     if(o->emulation_mode>0 && o->nwa >= 0)
+       burn_write_opts_set_start_byte(opts, ((off_t) o->nwa) * (off_t) 2048);
+   }
+ }
+
+ write_type= burn_write_opts_auto_write_type(opts, disc, reasons, 0);
+ if (write_type == BURN_WRITE_NONE) {
+    sprintf(msg, "Failed to find a suitable write mode:\n%s", reasons);
+    burn_msgs_submit(0x00060000, msg, 0, "FAILURE", NULL);
+    if(o!=NULL)
+      o->wrote_well= 0;
+    /* To cause a negative reply with burn_drive_wrote_well() */
+    burn_drive_cancel(drive);
+    return;
+ }
+
+/*
+ sprintf(reasons, "%d", (int) write_type);
+ fprintf(stderr, "isoburn_EXPERIMENTAL: write_type = %s\n",
+                 (write_type == BURN_WRITE_SAO ? "SAO" :
+                 (write_type == BURN_WRITE_TAO ? "TAO" : reasons)));
+*/
+
+#ifdef Hardcoded_cd_rW
+ /* <<< A70929 : hardcoded CD-RW with fabricated -msinfo */
+ fprintf(stderr, "Setting write address to LBA %d\n", Hardcoded_cd_rw_nwA);
+ burn_write_opts_set_start_byte(opts,
+				 ((off_t) Hardcoded_cd_rw_nwA) * (off_t) 2048);
+#endif
+
+ burn_disc_write(opts, disc);
+}
+
+
+void isoburn_drive_release(struct burn_drive *drive, int eject)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret= isoburn_find_emulator(&o, drive, 0);
+ if(ret<0)
+   return;
+ if(o!=NULL) {
+   isoburn_destroy(&o, 0);
+ }
+ burn_drive_release(drive, eject);
+}
+
+
+void isoburn_finish(void)
+{
+ isoburn_destroy_all(&isoburn_list_start, 0);
+ burn_finish();
+ iso_finish();
+}
+
+
+int isoburn_needs_emulation(struct burn_drive *drive)
+{
+ int ret;
+ struct isoburn *o;
+ enum burn_disc_status s;
+
+ s= isoburn_disc_get_status(drive);
+ if(s!=BURN_DISC_BLANK && s!=BURN_DISC_APPENDABLE)
+   return(-1);
+ ret= isoburn_find_emulator(&o, drive, 0);
+ if(ret<0)
+   return(-1);
+ if(ret>0)
+   if(o->emulation_mode>0)
+     return(1);
+ return(0);  
+}
+
+
+int isoburn_set_start_byte(struct isoburn *o, off_t value, int flag)
+{
+ int ret;
+ struct burn_drive *drive = o->drive;
+ struct burn_multi_caps *caps= NULL;
+ 
+ ret= burn_disc_get_multi_caps(drive, BURN_WRITE_NONE, &caps, 0);
+ if(ret<=0)
+   goto ex;
+ if(!caps->start_adr) {
+   burn_msgs_submit(0x00060000,
+                    "Cannot set start byte address with this type of media",
+                    0, "FAILURE", NULL);
+   {ret= 0; goto ex;}
+ }
+ o->min_start_byte= value;
+ if(value % caps->start_alignment)
+   value+= caps->start_alignment - (value % caps->start_alignment);
+ o->nwa= value/2048;
+ /* If suitable for alignment, round up to full 16 sector addresses */
+ if((o->nwa%16) && ((16*2048) % caps->start_alignment)==0 )
+   o->nwa+= 16 - (o->nwa%16);
+ ret= 1;
+ex:
+ if(caps!=NULL)
+   burn_disc_free_multi_caps(&caps);
+ return(ret);
+}
+
+
+int isoburn_get_min_start_byte(struct burn_drive *d, off_t *start_byte,
+                               int flag)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret= isoburn_find_emulator(&o, d, 0);
+ if(ret<0)
+   return(-1);
+ if(ret==0) 
+   return(0);
+ *start_byte= o->min_start_byte;
+ if(o->min_start_byte<=0)
+   return(0);
+ return(1);
+}
+
+
+int isoburn_drive_wrote_well(struct burn_drive *d)
+{
+ int ret;
+ struct isoburn *o;
+ 
+ ret= isoburn_find_emulator(&o, d, 0);
+ if(ret<0)
+   return(-1);
+ if(o!=NULL)
+   if(o->wrote_well>=0)
+     return(o->wrote_well);
+ ret= burn_drive_wrote_well(d);
+ return ret;
+}
+
+
+int isoburn_get_fifo_status(struct burn_drive *d, int *size, int *free_bytes,
+			    char **status_text)
+{
+ int ret;
+ struct isoburn *o;
+#ifdef Libisoburn_no_fifO
+ size_t hsize= 0, hfree_bytes= 0;
+#endif
+
+ ret= isoburn_find_emulator(&o, d, 0);
+ if(ret<0)
+   return(-1);
+
+#ifdef Libisoburn_no_fifO
+ if(o==NULL)
+   return(-1);
+ if(o->iso_source==NULL)
+   return(-1);
+ ret= iso_ring_buffer_get_status(o->iso_source, &hsize, &hfree_bytes);
+ if(hsize > 1024*1024*1024)
+   *size= 1024*1024*1024;
+ else
+   *size= hsize;
+ if(hfree_bytes > 1024*1024*1024)
+   *free_bytes= 1024*1024*1024;
+ else
+   *free_bytes= hfree_bytes;
+ *status_text= "";
+ if(ret==0)
+   *status_text= "standby";
+ else if(ret==1)
+   *status_text= "active";
+ else if(ret==2)
+   *status_text= "ending";
+ else if(ret==3)
+   *status_text= "failing";
+ else if(ret==4)
+   *status_text= "unused";
+ else if(ret==5)
+   *status_text= "abandoned";
+ else if(ret==6)
+   *status_text= "ended";
+ else if(ret==7)
+   *status_text= "aborted";
+#else
+ if(o==NULL)
+   return(0);
+ if(o->fifo==NULL)
+   return(0);
+ ret= burn_fifo_inquire_status(o->fifo, size, free_bytes, status_text);
+#endif /* ! Libisoburn_no_fifO */
+
+ return(ret);
+}
+
+
+
+/* <<< to be replaced by libburn-0.4.3 API call burn_sev_to_text().
+   This is a copy of libdax_msgs__sev_to_text() which is not exposed
+   by the API of of libburn-0.4.2 . As soon as xorriso gets based on
+   libburn-0.4.4 this redundancy is to be removed.
+   It is safe, nevertheless, because the severity codes are eternal.
+*/
+#define LIBDAX_MSGS_SEV_ALL                                          0x00000000
+#define LIBDAX_MSGS_SEV_DEBUG                                        0x10000000
+#define LIBDAX_MSGS_SEV_UPDATE                                       0x20000000
+#define LIBDAX_MSGS_SEV_NOTE                                         0x30000000
+#define LIBDAX_MSGS_SEV_HINT                                         0x40000000
+#define LIBDAX_MSGS_SEV_WARNING                                      0x50000000
+#define LIBDAX_MSGS_SEV_SORRY                                        0x60000000
+#define LIBDAX_MSGS_SEV_MISHAP                                       0x64000000
+#define LIBDAX_MSGS_SEV_FAILURE                                      0x68000000
+#define LIBDAX_MSGS_SEV_FATAL                                        0x70000000
+#define LIBDAX_MSGS_SEV_ABORT                                        0x71000000
+#define LIBDAX_MSGS_SEV_NEVER                                        0x7fffffff
+
+int isoburn__sev_to_text(int severity, char **severity_name,
+                         int flag)
+{
+ if(flag&1) {
+   *severity_name= "NEVER\nABORT\nFATAL\nFAILURE\nSORRY\nWARNING\nHINT\nNOTE\nUPDATE\nDEBUG\nALL";
+   return(1);
+ }
+ *severity_name= "";
+ if(severity>=LIBDAX_MSGS_SEV_NEVER)
+   *severity_name= "NEVER";
+ else if(severity>=LIBDAX_MSGS_SEV_ABORT)
+   *severity_name= "ABORT";
+ else if(severity>=LIBDAX_MSGS_SEV_FATAL)
+   *severity_name= "FATAL";
+ else if(severity>=LIBDAX_MSGS_SEV_FAILURE)
+   *severity_name= "FAILURE";
+ else if(severity>=LIBDAX_MSGS_SEV_MISHAP)
+   *severity_name= "MISHAP";
+ else if(severity>=LIBDAX_MSGS_SEV_SORRY)
+   *severity_name= "SORRY";
+ else if(severity>=LIBDAX_MSGS_SEV_WARNING)
+   *severity_name= "WARNING";
+ else if(severity>=LIBDAX_MSGS_SEV_HINT)
+   *severity_name= "HINT";
+ else if(severity>=LIBDAX_MSGS_SEV_NOTE)
+   *severity_name= "NOTE";
+ else if(severity>=LIBDAX_MSGS_SEV_UPDATE)
+   *severity_name= "UPDATE";
+ else if(severity>=LIBDAX_MSGS_SEV_DEBUG)
+   *severity_name= "DEBUG";
+ else if(severity>=LIBDAX_MSGS_SEV_ALL)
+   *severity_name= "ALL";
+ else {
+   *severity_name= "";
+   return(0);
+ }
+ return(1);
+}
+
+
+int isoburn__text_to_sev(char *severity_name, int *severity_number, int flag)
+{
+ int ret= 1;
+
+ if(severity_name[0]==0)
+   *severity_number= 0;
+ else if(strcmp(severity_name, "MISHAP")==0)
+   *severity_number= LIBDAX_MSGS_SEV_MISHAP;
+ else
+   ret= burn_text_to_sev(severity_name, severity_number, 0);
+ return(ret);
+}
+
+
+int isoburn_report_iso_error(int iso_error_code, char msg_text[], int os_errno,
+                             char min_severity[], int flag)
+{
+ int error_code, iso_sev, min_sev, ret;
+ char *sev_text_pt, *msg_text_pt= NULL;
+
+ error_code= iso_error_get_code(iso_error_code);
+ if(error_code < 0x00030000 || error_code >= 0x00040000)
+   error_code= (error_code & 0xffff) | 0x00050000;
+
+ if(iso_error_code<0)
+   msg_text_pt= (char *) iso_error_to_msg(iso_error_code);
+ if(msg_text_pt==NULL)
+   msg_text_pt= msg_text;
+ iso_sev= iso_error_get_severity(iso_error_code);
+ sev_text_pt= min_severity;
+ burn_text_to_sev(min_severity, &min_sev, 0);
+
+ /* <<< Tunnel MISHAP through libburn which knows no MISHAP
+        with libburn-0.4.4 this is not necessary */
+ if(iso_sev==LIBDAX_MSGS_SEV_MISHAP) {
+   iso_sev= LIBDAX_MSGS_SEV_SORRY;
+   error_code= 0x0005ff73;
+ }
+
+ if(min_sev < iso_sev) {
+
+   /* >>> with libburn-0.4.4 do: burn_sev_to_text(iso_sev, &sev_text_pt, 0); */
+   isoburn__sev_to_text(iso_sev, &sev_text_pt, 0);
+
+ }
+
+ ret= burn_msgs_submit(error_code, msg_text_pt, os_errno, sev_text_pt, NULL);
+ return(ret);
+}
+

libisoburn/branches/ZeroOneZero-pl01/libisoburn/data_source.c

@@ -0,0 +1,190 @@
+/*
+  data source for libisoburn.
+
+  Copyright 2007 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <stdio.h>
+
+
+#ifndef Xorriso_standalonE
+
+#include <libburn/libburn.h>
+
+#include <libisofs/libisofs.h>
+
+#else /* ! Xorriso_standalonE */
+
+#include "../libisofs/libisofs.h"
+#include "../libburn/libburn.h"
+
+#endif /* Xorriso_standalonE */
+
+
+#include "isoburn.h"
+
+
+/* Cached reading of image tree data */
+/* Current implementation : single tile 128 kB */
+
+/* powers of 2 only ! */
+#define Libisoburn_cache_blockS 64
+
+struct isoburn_cached_drive {
+ struct burn_drive *drive;
+
+ char cache_data[Libisoburn_cache_blockS * 2048];
+ uint32_t cache_lba;
+ uint32_t last_error_lba;
+ uint32_t last_aligned_error_lba;
+ int cache_hits;
+};
+
+
+/* Debugging only: This reports cache loads on stderr.
+#define Libisoburn_read_cache_reporT 1
+*/
+#define Libisoburn_use_read_cachE
+
+#ifdef Libisoburn_use_read_cachE
+
+int 
+ds_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
+{
+ int ret;
+ struct burn_drive *d;
+ off_t count;
+ uint32_t aligned_lba;
+ char msg[80];
+
+ struct isoburn_cached_drive *icd;
+
+ if(src == NULL || buffer == NULL)
+   return -1;
+
+ icd = (struct isoburn_cached_drive *) src->data;
+ d = (struct burn_drive*) icd->drive;
+
+ aligned_lba= lba & ~(Libisoburn_cache_blockS - 1);
+ if(aligned_lba == icd->cache_lba && icd->cache_lba != 0xffffffff) {
+   (icd->cache_hits)++;
+   memcpy(buffer, icd->cache_data + (lba - aligned_lba) * 2048, 2048);
+   count= 2048;
+   return 1;
+ } 
+
+ icd->cache_lba= 0xffffffff; /* invalidate cache */
+ if(icd->last_aligned_error_lba == aligned_lba) {
+   ret = 0;
+ } else {
+   ret = burn_read_data(d, (off_t) aligned_lba * (off_t) 2048,
+                        (char *) icd->cache_data,
+                        Libisoburn_cache_blockS * 2048, &count, 0);
+ }
+ if (ret <= 0 ) {
+   icd->last_aligned_error_lba = aligned_lba;
+
+   /* Read-ahead failure ? Try to read 2048 directly. */
+   if(icd->last_error_lba == lba)
+     ret = 0;
+   else
+     ret = burn_read_data(d, (off_t) lba * (off_t) 2048, (char *) buffer,
+                        2048, &count, 0);
+   if (ret > 0)
+     return 1;
+   icd->last_error_lba = lba;
+   sprintf(msg, "ds_read_block(%lu) returns -1", (unsigned long) lba);
+   burn_msgs_submit(0x00060000, msg, 0, "DEBUG", NULL);
+   return -1;
+ }
+
+#ifdef Libisoburn_read_cache_reporT
+ fprintf(stderr, "After %3d hits, new load from %8x , count= %d\n",
+         icd->cache_hits, aligned_lba, (int) count);
+#endif
+
+ icd->cache_lba= aligned_lba;
+ icd->cache_hits= 1;
+ memcpy(buffer, icd->cache_data + (lba - aligned_lba) * 2048, 2048);
+ count= 2048;
+
+ return 1;
+}
+
+#else /* Libisoburn_use_read_cachE */
+
+static int 
+ds_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
+{
+ int ret;
+ struct burn_drive *d;
+ off_t count;
+
+ if(src == NULL || buffer == NULL)
+   return -1;
+
+ d = (struct burn_drive*) ((struct isoburn_cached_drive *) src->data)->drive;
+
+ ret = burn_read_data(d, (off_t) lba * (off_t) 2048, (char *) buffer,
+                      2048, &count, 0);
+ if (ret <= 0 )
+   return -1;
+
+ return 1;
+}
+
+#endif /* ! Libisoburn_use_read_cachE */
+
+	
+static int
+ds_open(IsoDataSource *src)
+{
+ /* nothing to do, device is always grabbed */
+ return 1;
+}
+
+static int
+ds_close(IsoDataSource *src)
+{
+ /* nothing to do, device is always grabbed */
+ return 1;
+}
+
+static void 
+ds_free_data(IsoDataSource *src)
+{
+ /* nothing to do */;
+ if(src->data != NULL)
+   free(src->data);
+ src->data= NULL;
+}
+
+IsoDataSource *
+isoburn_data_source_new(struct burn_drive *d)
+{
+ IsoDataSource *ret;
+ struct isoburn_cached_drive *icd= NULL;
+
+ if (d==NULL)
+   return NULL;
+ ret = malloc(sizeof(IsoDataSource));
+ icd = calloc(1,sizeof(struct isoburn_cached_drive));
+ if (ret == NULL || icd == NULL)
+   return NULL;
+ ret->refcount = 1;
+ ret->read_block = ds_read_block;
+ ret->open = ds_open;
+ ret->close = ds_close;
+ ret->free_data = ds_free_data;
+ ret->data = icd;
+ icd->drive = d;
+ icd->cache_lba = 0xffffffff;
+ icd->cache_hits = 0;
+ icd->last_error_lba = 0xffffffff;
+ icd->last_aligned_error_lba = 0xffffffff;
+ return ret;
+}
+

libisoburn/branches/ZeroOneZero-pl01/libisoburn/isoburn.c

@@ -0,0 +1,838 @@
+
+/*
+  cc -g -c isoburn.c
+*/
+
+/*
+  Class core of libisoburn.
+
+  Copyright 2007 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+             and Thomas Schmitt <scdbackup@gmx.net>
+*/
+
+/* ( derived from stub generated by CgeN on  Sat, 01 Sep 2007 12:04:36 GMT ) */
+
+#include <sys/types.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+
+#ifndef Xorriso_standalonE
+
+#include <libburn/libburn.h>
+
+#include <libisofs/libisofs.h>
+
+#else /* ! Xorriso_standalonE */
+
+#include "../libisofs/libisofs.h"
+#include "../libburn/libburn.h"
+
+#endif /* Xorriso_standalonE */
+
+
+#include "libisoburn.h"
+
+#include "isoburn.h"
+
+/* No more: version numbers out of configure.ac
+   major.minor.micro now comes from libisoburn.h
+#include "../version.h"
+*/
+
+/* --------------------------  isoburn  ----------------------- */
+
+
+/* The global list of isoburn objects. Usually there is only one.
+   >>> we are not ready for multiple control threads yet. See >>> mutex .
+   Multiple burns under one control thread should work.
+*/
+struct isoburn *isoburn_list_start= NULL;
+
+
+int isoburn_new(struct isoburn **objpt, int flag)
+{
+ struct isoburn *o;
+ int i, ret;
+
+ *objpt= o= (struct isoburn *) malloc(sizeof(struct isoburn));
+ if(o==NULL) {
+   burn_msgs_submit(0x00060000,
+                    "Cannot allocate memory for isoburn control object",
+                    0, "FATAL", NULL);
+   return(-1);
+ }
+
+ o->drive= NULL;
+ o->emulation_mode= 0;
+ o->min_start_byte= 0;
+ o->nwa= 0;
+
+#ifdef Libisoburn_no_fifO
+ o->iso_source= NULL;
+#else
+ o->fifo= NULL;
+#endif
+
+ o->wrote_well= -1;
+ o->fabricated_disc_status= BURN_DISC_UNREADY;
+ for(i=0;i<65536;i++)
+   o->target_iso_head[i]= 0;
+ o->image= NULL;
+ o->read_pacifier= NULL;
+ o->read_pacifier_handle= NULL;
+ o->prev= NULL;
+ o->next= NULL;
+ ret= iso_image_new("ISOIMAGE", &o->image);
+ if(ret<0) {
+   isoburn_report_iso_error(ret, "Cannot create image", 0, "FATAL", 0);
+   goto failed;
+ }
+ isoburn_link(o, isoburn_list_start, 1);
+ return(1);
+failed:;
+ isoburn_destroy(objpt, 0);
+ return(-1);
+}
+
+
+int isoburn_destroy(struct isoburn **objpt, int flag)
+{
+ struct isoburn *o;
+
+ o= *objpt;
+ if(o==NULL)
+   return(0);
+
+ /* >>> mutex */
+
+ if(o==isoburn_list_start)
+   isoburn_list_start= o->next;
+ if(o->prev!=NULL)
+   o->prev->next= o->next;
+ if(o->next!=NULL)
+   o->next->prev= o->prev;
+
+ /* >>> end mutex */
+
+ if(o->image!=NULL)
+   iso_image_unref(o->image);
+
+#ifdef Libisoburn_no_fifO
+ if(o->iso_source!=NULL)
+   burn_source_free(o->iso_source);
+#else
+ if(o->fifo!=NULL)
+   burn_source_free(o->fifo);
+#endif /* ! Libisoburn_no_fifO */
+
+
+ free((char *) o);
+ *objpt= NULL;
+ return(1);
+}
+
+
+int isoburn_destroy_all(struct isoburn **objpt, int flag)
+{
+ struct isoburn *o,*n;
+
+ o= *objpt;
+ if(o==NULL)
+   return(0);
+ for(;o->prev!=NULL;o= o->prev);
+ for(;o!=NULL;o= n) {
+   n= o->next;
+   isoburn_destroy(&o,0);
+ }
+ *objpt= NULL;
+ return(1);
+}
+
+
+int isoburn_get_target_image(struct isoburn *o, IsoImage **pt, int flag)
+{
+ *pt= o->image;
+ return(1);
+}
+
+
+int isoburn_get_prev(struct isoburn *o, struct isoburn **pt, int flag)
+{
+ *pt= o->prev;
+ return(1);
+}
+
+
+int isoburn_get_next(struct isoburn *o, struct isoburn **pt, int flag)
+{
+ *pt= o->next;
+ return(1);
+}
+
+
+int isoburn_link(struct isoburn *o, struct isoburn *link, int flag)
+/*
+  bit0= insert as link->prev rather than as link->next
+*/
+{
+
+ /* >>> mutex */
+
+ if(isoburn_list_start==NULL ||
+    (isoburn_list_start==link && (flag&1)))
+   isoburn_list_start= o;
+ if(o->prev!=NULL)
+   o->prev->next= o->next;
+ if(o->next!=NULL)
+   o->next->prev= o->prev;
+ o->prev= o->next= NULL;
+ if(link==NULL)
+   return(1);
+ if(flag&1) {
+   o->next= link;
+   o->prev= link->prev;
+   if(o->prev!=NULL)
+     o->prev->next= o;
+   link->prev= o;
+ } else {
+   o->prev= link;
+   o->next= link->next;
+   if(o->next!=NULL)
+     o->next->prev= o;
+   link->next= o;
+ }
+
+ /* >>> end mutex */
+
+ return(1);
+}
+
+
+int isoburn_count(struct isoburn *o, int flag)
+/* flag: bit1= count from start of list */
+{
+ int counter= 0;
+
+ if(flag&2)
+   for(;o->prev!=NULL;o= o->prev);
+ for(;o!=NULL;o= o->next)
+   counter++;
+ return(counter);
+}
+
+
+int isoburn_by_idx(struct isoburn *o, int idx, struct isoburn **pt, int flag)
+/* flag: bit0= fetch first (idx<0) or last (idx>0) item in list
+         bit1= address from start of list */
+{
+ int i,abs_idx;
+ struct isoburn *npt;
+
+ if(flag&2)
+   for(;o->prev!=NULL;o= o->prev);
+ abs_idx= (idx>0?idx:-idx);
+ *pt= o;
+ for(i= 0;(i<abs_idx || (flag&1)) && *pt!=NULL;i++) {
+   if(idx>0)
+     npt= o->next;
+   else
+     npt= o->prev;
+   if(npt==NULL && (flag&1))
+ break;
+   *pt= npt;
+ }
+ return(*pt!=NULL);
+}
+
+
+int isoburn_find_by_drive(struct isoburn **pt, struct burn_drive *d, int flag)
+{
+ struct isoburn *o;
+
+ *pt= NULL;
+ for(o= isoburn_list_start;o!=NULL;o= o->next)
+   if(o->drive==d) {
+     *pt= o;
+     return(1);
+   }
+ return(0);
+}
+
+static
+int isoburn_prepare_disc_aux(struct burn_drive *d, struct burn_disc **disc,
+                             struct isoburn_imgen_opts *opts, int new_img)
+{
+ struct burn_source *wsrc;
+ struct burn_session *session;
+ struct burn_track *track;
+ struct isoburn *o;
+ IsoWriteOpts *wopts= NULL;
+ enum burn_disc_status state;
+ int ret, fifo_chunks;
+
+ ret= isoburn_find_emulator(&o, d, 0);
+ if(ret<0 || o==NULL)
+   {ret= -1; goto ex;}
+ o->wrote_well= 0; /* early end will be registered as failure */
+
+ state = isoburn_disc_get_status(d);
+ if (state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE
+     && (state != BURN_DISC_FULL || ! new_img)) {
+   /* unsuitable status */
+   burn_msgs_submit(0x00060000, "Unsuitable media state", 0, "FAILURE", NULL);
+   {ret= -2; goto ex;}
+ }
+ 
+ fifo_chunks= 32;
+ if(opts->fifo_size >= 64*1024 && opts->fifo_size <= 1024.0 * 1024.0 * 1024.0){
+   fifo_chunks= opts->fifo_size/2048;
+   if(fifo_chunks*2048 < opts->fifo_size)
+     fifo_chunks++;
+ }
+
+ ret = iso_write_opts_new(&wopts, 0);
+ if (ret < 0) {
+   isoburn_report_iso_error(ret, "Cannot create iso_write_opts", 0, "FATAL",0);
+   goto ex;
+ }
+ iso_write_opts_set_iso_level(wopts, opts->level);
+ iso_write_opts_set_rockridge(wopts, opts->rockridge);
+ iso_write_opts_set_joliet(wopts, opts->joliet);
+ iso_write_opts_set_iso1999(wopts, opts->iso1999);
+ iso_write_opts_set_omit_version_numbers(wopts, opts->omit_version_numbers);
+ iso_write_opts_set_allow_deep_paths(wopts, opts->allow_deep_paths);
+ iso_write_opts_set_allow_longer_paths(wopts, opts->allow_longer_paths);
+ iso_write_opts_set_max_37_char_filenames(wopts, opts->max_37_char_filenames);
+ iso_write_opts_set_no_force_dots(wopts, opts->no_force_dots);
+ iso_write_opts_set_allow_lowercase(wopts, opts->allow_lowercase);
+ iso_write_opts_set_allow_full_ascii(wopts, opts->allow_full_ascii);
+ iso_write_opts_set_relaxed_vol_atts(wopts, 1);
+ iso_write_opts_set_joliet_longer_paths(wopts, opts->joliet_longer_paths);
+ iso_write_opts_set_sort_files(wopts, opts->sort_files);
+ iso_write_opts_set_replace_mode(wopts, opts->replace_dir_mode,
+                opts->replace_file_mode, opts->replace_uid, opts->replace_gid);
+ iso_write_opts_set_default_dir_mode(wopts, opts->dir_mode);
+ iso_write_opts_set_default_file_mode(wopts, opts->file_mode);
+ iso_write_opts_set_default_uid(wopts, opts->uid);
+ iso_write_opts_set_default_gid(wopts, opts->gid);
+ iso_write_opts_set_output_charset(wopts, opts->output_charset);
+#ifdef Libisoburn_no_fifO
+ iso_write_opts_set_fifo_size(wopts, fifo_chunks);
+#endif /* Libisoburn_no_fifO */
+ 
+ if (new_img) {
+   iso_write_opts_set_ms_block(wopts, 0);
+   iso_write_opts_set_appendable(wopts, 0);
+   iso_write_opts_set_overwrite_buf(wopts, NULL);
+ } else {
+   int lba, nwa;
+   ret = isoburn_disc_track_lba_nwa(d, NULL, 0, &lba, &nwa);
+   if (ret != 1) {
+     burn_msgs_submit(0x00060000, "Cannot determine next writeable address", 0,
+                      "FAILURE", NULL);
+     {ret= -3; goto ex;}
+   }
+   if (nwa == 0 && state == BURN_DISC_APPENDABLE) {
+     /* invalid nwa */
+     burn_msgs_submit(0x00060000, "Encountered 0 as next writeable address", 0,
+                      "FAILURE", NULL);
+     {ret= -4; goto ex;}
+   }
+   iso_write_opts_set_ms_block(wopts, nwa);
+   iso_write_opts_set_appendable(wopts, 1);
+   iso_write_opts_set_overwrite_buf(wopts, o->target_iso_head);
+ }
+
+ ret = iso_image_create_burn_source(o->image, wopts, &wsrc);
+ if (ret < 0) {
+   isoburn_report_iso_error(ret, "Cannot create burn source", 0, "FAILURE", 0);
+   {ret= -1; goto ex;}
+ }
+ 
+ /* TODO check return values for failure. propertly clean-up on error */
+
+#ifdef Libisoburn_no_fifO
+ o->iso_source= wsrc;
+#else
+ o->fifo = burn_fifo_source_new(wsrc, 2048, fifo_chunks, 0);
+ burn_source_free(wsrc);
+ if (o->fifo == NULL) {
+   burn_msgs_submit(0x00060000, "Cannot attach fifo", 0, "FATAL", NULL);
+   {ret= -1; goto ex;}
+ }
+#endif /* ! Libisoburn_no_fifO */
+
+ *disc = burn_disc_create();
+ session = burn_session_create();
+ burn_disc_add_session(*disc, session, BURN_POS_END);
+ track = burn_track_create();
+
+#ifdef Libisoburn_no_fifO
+ burn_track_set_source(track, o->iso_source);
+#else
+ burn_track_set_source(track, o->fifo);
+#endif /* ! Libisoburn_no_fifO */
+
+ burn_session_add_track(session, track, BURN_POS_END);
+
+ /* give up local references */
+ burn_track_free(track);
+ burn_session_free(session);
+
+ o->wrote_well= -1; /* neutral */
+ ret= 1;
+ex:
+ if(wopts!=NULL)
+   {iso_write_opts_free(wopts); wopts= NULL;}
+ return ret;
+}
+
+int isoburn_prepare_disc(struct burn_drive *d, struct burn_disc **disc,
+                         struct isoburn_imgen_opts *opts)
+{
+	return isoburn_prepare_disc_aux(d, disc, opts, 0);
+}
+
+int isoburn_prepare_new_image(struct burn_drive *d, struct burn_disc **disc,
+                         struct isoburn_imgen_opts *opts,
+                         struct burn_drive *out_drive)
+{
+ int ret;
+ struct isoburn *in_o, *out_o;
+
+ ret= isoburn_prepare_disc_aux(d, disc, opts, 1);
+ if (ret<=0)
+   return ret;
+
+#ifdef Libisoburn_no_fifO
+ /* Hand over source reference for optional fifo status inquiry */
+ if(out_drive==NULL)
+   return 1;
+ ret= isoburn_find_emulator(&out_o, out_drive, 0);
+ if(ret<0 || out_o==NULL)
+   return 1;
+ ret= isoburn_find_emulator(&in_o, d, 0);
+ if(ret<0 || in_o==NULL)
+   return 1; /* then without fifo status inquiry */
+ if(out_o->iso_source!=NULL)
+   burn_source_free(out_o->iso_source);
+ out_o->iso_source= in_o->iso_source;
+ in_o->iso_source= NULL;
+#endif /* Libisoburn_no_fifO */
+
+ return 1; 
+}
+
+
+/* API @since 0.1.0
+   @param flag bit0= this is a regular end, not an abort
+                     give up source reference
+*/
+int isoburn_cancel_prepared_write(struct burn_drive *d,
+                                  struct burn_drive *output_drive, int flag)
+{
+ int ret;
+ struct isoburn *o= NULL;
+
+ if(output_drive!=NULL) {
+   ret= isoburn_find_emulator(&o, output_drive, 0);
+   if(ret<0 || o==NULL)
+     o= NULL;
+   else if(o->iso_source==NULL)
+     o= NULL;
+ }
+ if(o==NULL) {
+   ret= isoburn_find_emulator(&o, d, 0);
+   if(ret<0)
+     return(-1);
+   if(o==NULL)
+     return(0);
+   if(o->iso_source==NULL)
+     return(0);
+ }
+ if(o->iso_source->read!=NULL)
+   return(0);
+ if(o->iso_source->version<1)
+   return(0);
+ o->iso_source->cancel(o->iso_source);
+ burn_source_free(o->iso_source);
+ o->iso_source= NULL;
+ return(1);
+}
+
+
+/* API @since 0.1.0 */
+int isoburn_sync_after_write(struct burn_drive *d,
+                             struct burn_drive *output_drive, int flag)
+{
+ return isoburn_cancel_prepared_write(d, output_drive, 1);
+}
+
+
+void isoburn_version(int *major, int *minor, int *micro)
+{
+ *major= isoburn_header_version_major;
+ *minor= isoburn_header_version_minor;
+ *micro= isoburn_header_version_micro;
+
+/* No more: values from version.h generated from version.h.in and
+            macro values defined in configure.ac
+
+ *major = ISOBURN_MAJOR_VERSION;
+ *minor = ISOBURN_MINOR_VERSION;
+ *micro = ISOBURN_MICRO_VERSION;
+*/
+}
+
+
+int isoburn_is_compatible(int major, int minor, int micro, int flag)
+{
+ int own_major, own_minor, own_micro;
+
+ isoburn_version(&own_major, &own_minor, &own_micro);
+ return(own_major > major ||
+        (own_major == major && (own_minor > minor ||
+         (own_minor == minor && own_micro >= micro))));
+}
+
+
+/* ----------------------------------------------------------------------- */
+/*
+  Options for image reading.
+*/
+/* ----------------------------------------------------------------------- */
+
+
+int isoburn_ropt_new(struct isoburn_read_opts **new_o, int flag)
+{
+ struct isoburn_read_opts *o;
+
+ o= (*new_o)= calloc(1, sizeof(struct isoburn_read_opts));
+ if(o==NULL) {
+   burn_msgs_submit(0x00060000, "Cannot allocate memory for read options",
+                    0, "FATAL", NULL);
+   return(-1);
+ }
+ o->norock= 0;
+ o->nojoliet= 0;
+ o->noiso1999= 1;
+ o->preferjoliet= 0;
+ o->uid= geteuid();
+ o->gid= getegid();
+ o->mode= 0444;
+ o->dirmode= 0555;
+ o->input_charset= NULL;
+ o->hasRR= 0;
+ o->hasJoliet= 0;
+ o->hasIso1999= 0;
+ o->hasElTorito= 0;
+ o->size= 0;
+ o->pretend_blank= 1;
+ return(1);
+}
+
+
+int isoburn_ropt_destroy(struct isoburn_read_opts **o, int flag)
+{
+ if(*o==NULL)
+   return(0);
+ free(*o);
+ *o= NULL;
+ return(1);
+}
+
+
+int isoburn_ropt_set_extensions(struct isoburn_read_opts *o, int ext)
+{
+ o->norock= !!(ext&1);
+ o->nojoliet= !!(ext&2);
+ o->noiso1999= !!(ext&4);
+ o->preferjoliet= !!(ext&8);
+ o->pretend_blank= !!(ext&16);
+ return(1);
+}
+
+
+int isoburn_ropt_get_extensions(struct isoburn_read_opts *o, int *ext)
+{
+ *ext= (!!o->norock) | ((!!o->nojoliet)<<1) | ((!!o->noiso1999)<<2) |
+       ((!!o->preferjoliet)<<3) | ((!!o->pretend_blank)<<4);
+ return(1);
+}
+
+
+int isoburn_ropt_set_default_perms(struct isoburn_read_opts *o,
+                                   uid_t uid, gid_t gid, mode_t mode)
+{
+ mode_t dirmode;
+
+ o->uid= uid;
+ o->gid= gid;
+ o->mode= mode;
+ dirmode= mode;
+ if(dirmode & S_IRUSR)
+   dirmode|= S_IXUSR;
+ if(dirmode & S_IRGRP)
+   dirmode|= S_IXGRP;
+ if(dirmode & S_IROTH)
+   dirmode|= S_IXOTH;
+ o->dirmode= dirmode;
+ return(1);
+}
+
+
+int isoburn_ropt_get_default_perms(struct isoburn_read_opts *o,
+                                   uid_t *uid, gid_t *gid, mode_t *mode)
+{
+ *uid= o->uid;
+ *gid= o->gid;
+ *mode= o->mode;
+ return(1);
+}
+
+
+int isoburn_ropt_set_default_dirperms(struct isoburn_read_opts *o,
+                                       mode_t mode)
+{
+ o->dirmode= mode;
+ return(1);
+}
+
+
+int isoburn_ropt_get_default_dirperms(struct isoburn_read_opts *o,
+                                      mode_t *mode)
+{
+ *mode= o->dirmode;
+ return(1);
+}
+
+
+int isoburn_ropt_set_input_charset(struct isoburn_read_opts *o,
+                                   char *input_charset)
+{
+ o->input_charset= input_charset;
+ return(1);
+}
+
+
+int isoburn_igopt_get_in_charset(struct isoburn_read_opts *o,
+                                 char **input_charset)
+{
+ *input_charset= o->input_charset;
+ return(1);
+}
+
+
+int isoburn_ropt_get_size_what(struct isoburn_read_opts *o,
+                               uint32_t *size, int *has_what)
+{
+ *size= o->size;
+ *has_what= (!!o->hasRR) | ((!!o->hasJoliet)<<1) |
+            ((!!o->hasIso1999)<<2) | ((!!o->hasElTorito)<<3); 
+ return(1);
+}
+
+
+/* ----------------------------------------------------------------------- */
+/*
+  Options for image generation by libisofs and image transport to libburn.
+*/
+/* ----------------------------------------------------------------------- */
+
+
+int isoburn_igopt_new(struct isoburn_imgen_opts **new_o, int flag)
+{
+ struct isoburn_imgen_opts *o;
+
+ o= (*new_o)= calloc(1, sizeof(struct isoburn_imgen_opts));
+ if(o==NULL) {
+   burn_msgs_submit(0x00060000,
+                    "Cannot allocate memory for image generation options",
+                    0, "FATAL", NULL);
+   return(-1);
+ }
+ o->level= 2;
+ o->rockridge= 1;
+ o->joliet= 0;
+ o->iso1999= 0;
+ o->omit_version_numbers= 0;
+ o->allow_deep_paths= 1;
+ o->allow_longer_paths= 0;
+ o->max_37_char_filenames= 0;
+ o->no_force_dots= 0;
+ o->allow_lowercase= 0;
+ o->allow_full_ascii= 0;
+ o->joliet_longer_paths= 0;
+ o->sort_files= 0;
+ o->replace_dir_mode= 0;
+ o->replace_file_mode= 0;
+ o->replace_uid= 0;
+ o->replace_gid= 0;
+ o->dir_mode= 0555;
+ o->file_mode= 0444;
+ o->uid= 0;
+ o->gid= 0;
+ o->output_charset= 0;
+ o->fifo_size= 4*1024*1024;
+ return(1);
+}
+
+
+int isoburn_igopt_destroy(struct isoburn_imgen_opts **o, int flag)
+{
+ if(*o==NULL)
+   return(0);
+ free(*o);
+ *o= NULL;
+ return(1);
+}
+
+
+int isoburn_igopt_set_level(struct isoburn_imgen_opts *o, int level)
+{
+ o->level= level;
+ return(1);
+}
+
+
+int isoburn_igopt_get_level(struct isoburn_imgen_opts *o, int *level)
+{
+ *level= o->level;
+ return(1);
+}
+
+
+int isoburn_igopt_set_extensions(struct isoburn_imgen_opts *o, int ext)
+{
+ o->rockridge= !!(ext&1);
+ o->joliet= !!(ext&2);
+ o->iso1999= !!(ext&4);
+ return(1);
+}
+
+
+int isoburn_igopt_get_extensions(struct isoburn_imgen_opts *o, int *ext)
+{
+ *ext= (!!o->rockridge) | ((!!o->joliet)<<1) | ((!!o->iso1999)<<2);
+ return(1);
+}
+
+
+int isoburn_igopt_set_relaxed(struct isoburn_imgen_opts *o, int relax)
+{
+ o->omit_version_numbers= !!(relax&1);
+ o->allow_deep_paths= !!(relax&2);
+ o->allow_longer_paths= !!(relax&4);
+ o->max_37_char_filenames= !!(relax&8);
+ o->no_force_dots= !!(relax&16);
+ o->allow_lowercase= !!(relax&32);
+ o->allow_full_ascii= !!(relax&64);
+ o->joliet_longer_paths= !!(relax&128);
+ return(1);
+}
+
+
+int isoburn_igopt_get_relaxed(struct isoburn_imgen_opts *o, int *relax)
+{
+ *relax= (!!o->omit_version_numbers)    | ((!!o->allow_deep_paths)<<1) |
+         ((!!o->allow_longer_paths)<<2) | ((!!o->max_37_char_filenames)<<3) |
+         ((!!o->no_force_dots)<<4)      | ((!!o->allow_lowercase)<<5) |
+         ((!!o->allow_full_ascii)<<6)   | ((!!o->joliet_longer_paths)<<7);
+ return(1);
+}
+
+
+int isoburn_igopt_set_sort_files(struct isoburn_imgen_opts *o, int value)
+{
+ o->sort_files= !!(value&1);
+ return(1);
+}
+
+
+int isoburn_igopt_get_sort_files(struct isoburn_imgen_opts *o, int *value)
+{
+ *value= !!o->sort_files;
+ return(1);
+}
+
+
+int isoburn_igopt_set_over_mode(struct isoburn_imgen_opts *o,
+                               int replace_dir_mode, int replace_file_mode,
+                               mode_t dir_mode, mode_t file_mode)
+{
+ o->replace_dir_mode= replace_dir_mode%3;
+ o->replace_file_mode= replace_file_mode%3;
+ o->dir_mode= dir_mode;
+ o->file_mode= file_mode;
+ return(1);
+}
+
+
+int isoburn_igopt_get_over_mode(struct isoburn_imgen_opts *o,
+                               int *replace_dir_mode, int *replace_file_mode,
+                               mode_t *dir_mode, mode_t *file_mode)
+{
+ *replace_dir_mode= o->replace_dir_mode%3;
+ *replace_file_mode= o->replace_file_mode%3;
+ *dir_mode= o->dir_mode;
+ *file_mode= o->file_mode;
+ return(1);
+}
+
+
+int isoburn_igopt_set_over_ugid(struct isoburn_imgen_opts *o,
+                               int replace_uid, int replace_gid,
+                               uid_t uid, gid_t gid)
+{
+ o->replace_uid= replace_uid%3;
+ o->replace_gid= replace_gid%3;
+ o->uid= uid;
+ o->gid= gid;
+ return(1);
+}
+
+int isoburn_igopt_get_over_ugid(struct isoburn_imgen_opts *o,
+                               int *replace_uid, int *replace_gid,
+                               uid_t *uid, gid_t *gid)
+{
+ *replace_uid= o->replace_uid%3;
+ *replace_gid= o->replace_gid%3;
+ *uid= o->uid;
+ *gid= o->gid;
+ return(1);
+}
+
+
+int isoburn_igopt_set_out_charset(struct isoburn_imgen_opts *o,
+                                 char *output_charset)
+{
+ o->output_charset= output_charset;
+ return(1);
+}
+
+
+int isoburn_igopt_get_out_charset(struct isoburn_imgen_opts *o,
+                                 char **output_charset)
+{
+ *output_charset= o->output_charset;
+ return(1);
+}
+
+
+int isoburn_igopt_set_fifo_size(struct isoburn_imgen_opts *o, int fifo_size)
+{
+ o->fifo_size= fifo_size;
+ return(1);
+}
+
+
+int isoburn_igopt_get_fifo_size(struct isoburn_imgen_opts *o, int *fifo_size)
+{
+ *fifo_size= o->fifo_size;
+ return(1);
+}
+
+

libisoburn/branches/ZeroOneZero-pl01/libisoburn/isoburn.h

@@ -0,0 +1,321 @@
+
+/*
+  Class struct of libisoburn.
+
+  Copyright 2007 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+             and Thomas Schmitt <scdbackup@gmx.net>
+*/
+
+#ifndef Isoburn_includeD
+#define Isoburn_includeD
+
+
+/* <<< transition macro */
+#define Libisoburn_no_fifO 1
+
+
+/* for uint8_t */
+#include <stdint.h>
+
+
+struct isoburn {
+
+
+ /* The libburn drive to which this isoburn object is related
+    Most isoburn calls will use a burn_drive as object handle */
+ struct burn_drive *drive;
+
+ /* -1= inappropriate media state detected
+    0= libburn multi-session media, resp. undecided yet
+    1= random access media */
+ int emulation_mode;
+
+ /* Although rarely used, libburn can operate on several
+    drives simultaneously. */
+ struct isoburn *prev;
+ struct isoburn *next;
+
+
+ /* Start address as given by image examination (bytes, not blocks) */
+ off_t min_start_byte;
+
+ /* Aligned start address to be used for processing (counted in blocks) */
+ int nwa;
+
+ /* Eventual freely fabricated isoburn_disc_get_status().
+    BURN_DISC_UNREADY means that normally emulated status is in effect.
+ */
+ enum burn_disc_status fabricated_disc_status;
+
+#ifndef Libisoburn_no_fifO
+ /* The fifo which is installed between track and libisofs burn_source
+ */
+ struct burn_source *fifo;
+#endif /* ! Libisoburn_no_fifO */
+
+ /* Indicator wether the most recent burn run worked :
+    -1 = undetermined, ask libburn , 0 = failure , 1 = success
+    To be inquired by isoburn_drive_wrote_well()
+ */
+ int wrote_well;
+
+ 
+ /* Buffered ISO head from media (should that become part of
+    ecma119_read_opts ?) */
+ uint8_t target_iso_head[65536];
+
+ /* Libisofs image context */
+ IsoImage *image;
+
+#ifdef Libisoburn_no_fifO
+ /* The burn source which transfers data from libisofs to libburn.
+    It has its own fifo.
+ */
+ struct burn_source *iso_source;
+#endif /* Libisoburn_no_fifO */
+
+ /* For iso_tree_set_report_callback() */
+ int (*read_pacifier)(IsoImage*, IsoFileSource*);
+
+ /* For iso_image_attach_data() */
+ void *read_pacifier_handle;
+
+};
+
+
+/* Creation and disposal function */
+int isoburn_new(struct isoburn **objpt, int flag);
+int isoburn_destroy(struct isoburn **objpt, int flag);
+
+/* Eventual readers for public attributes */
+/* ( put into separate .h file then ) */
+int isoburn_get_emulation_mode(struct isoburn *o, int *pt, int flag);
+int isoburn_get_target_volset(struct isoburn *o, IsoImage **pt, int flag);
+
+/* List management */
+int isoburn_get_prev(struct isoburn *o, struct isoburn **pt, int flag);
+int isoburn_get_next(struct isoburn *o, struct isoburn **pt, int flag);
+int isoburn_destroy_all(struct isoburn **objpt, int flag);
+int isoburn_link(struct isoburn *o, struct isoburn *link, int flag);
+int isoburn_count(struct isoburn *o, int flag);
+int isoburn_by_idx(struct isoburn *o, int idx, struct isoburn **pt, int flag);
+int isoburn_find_by_drive(struct isoburn **pt, struct burn_drive *d, int flag);
+
+
+/* Non API inner interfaces */
+
+/* Submit a libisofs error to the libburn messenger. An application message
+   reader shall recognize the error code range and attribute it to the
+   libisofs message channel to which one cannot submit via API.
+   @param iso_error_code   return value <= 0 from a libisofs API call.
+   @param default_msg_text is to be put out if iso_error_code leads to no
+                           error message
+   @param os_errno         operating system errno, submit 0 if none is known
+   @param min_severity     minimum severity, might be be increased if libisofs
+                           error severity surpasses min_severity.
+   @param flag             Bitfield, submit 0 for now
+*/
+int isoburn_report_iso_error(int iso_error_code, char default_msg_text[],
+                             int os_errno, char min_severity[], int flag);
+
+/* Calls from burn_wrap.c into isofs_wrap.c */ 
+
+int isoburn_start_emulation(struct isoburn *o, int flag);
+int isoburn_invalidate_iso(struct isoburn *o, int flag);
+
+
+/* Calls from isofs_wrap.c into burn_wrap.c */
+
+/** Get an eventual isoburn object which is wrapped around the drive.
+    @param pt    Eventually returns a pointer to the found object.
+                 It is allowed to become NULL if return value is -1 or 0.
+                 In this case, the drive is a genuine libburn drive
+                 with no emulation activated by isoburn.
+    @param drive The drive to be searched for
+    @param flag  unused yet
+    @return -1 unsuitable media, 0 generic media, 1 emulated media.
+*/
+int isoburn_find_emulator(struct isoburn **pt,
+                          struct burn_drive *drive, int flag);
+
+
+/** Set the start address for an emulated add-on session. The value will
+    be rounded up to the alignment necessary for the media. The aligned
+    value will be divided by 2048 and then put into  o->nwa .
+    @param o     The isoburn object to be programmed.
+    @param value The start address in bytes
+    @param flag  unused yet
+    @return <=0 is failure , >0 success
+*/
+int isoburn_set_start_byte(struct isoburn *o, off_t value, int flag);
+
+/** Get a data source suitable for read from a drive using burn_read_data()
+    function.
+    @param d drive to read from. Must be grabbed.
+    @return the data source, NULL on error. Must be freed with libisofs
+            iso_data_source_unref() function. Note: this doesn't release
+            the drive.
+*/
+IsoDataSource *
+isoburn_data_source_new(struct burn_drive *d);
+
+
+/**
+ * Options for image reading.
+   (Comments here may be outdated. API getter/setter function descriptions
+    may override the descriptions here. Any difference is supposed to be a
+    minor correction only.)
+ */
+struct isoburn_read_opts {
+    unsigned int norock:1; /*< Do not read Rock Ridge extensions */
+    unsigned int nojoliet:1; /*< Do not read Joliet extensions */
+    unsigned int noiso1999:1; /*< Do not read ISO 9660:1999 enhanced tree */
+    unsigned int preferjoliet:1; 
+                /*< When both Joliet and RR extensions are present, the RR
+                 *  tree is used. If you prefer using Joliet, set this to 1. */
+    uid_t uid; /**< Default uid when no RR */
+    gid_t gid; /**< Default uid when no RR */
+    mode_t mode; /**< Default mode when no RR (only permissions) */
+    mode_t dirmode; /**< Default mode for directories 
+                         when no RR (only permissions) */
+
+    /**
+     * Input charset for RR file names. NULL to use default locale charset.
+     */
+    char *input_charset;
+
+    /* modified by the function isoburn_read_image */
+    unsigned int hasRR:1; /*< It will be set to 1 if RR extensions are present,
+                             to 0 if not. */
+    unsigned int hasJoliet:1; /*< It will be set to 1 if Joliet extensions are 
+                                  present, to 0 if not. */
+
+    /**
+     * It will be set to 1 if the image is an ISO 9660:1999, i.e. it has
+     * a version 2 Enhanced Volume Descriptor.
+     */
+    unsigned int hasIso1999:1;
+
+    /** It will be set to 1 if El-Torito boot record is present, to 0 if not.*/
+    unsigned int hasElTorito:1;
+
+    uint32_t size; /**< Will be filled with the size (in 2048 byte block) of 
+                    *   the image, as reported in the PVM. */
+    unsigned int pretend_blank:1; /* always create empty image */
+};
+
+
+/**
+ * Options for image generation by libisofs and image transport to libburn.
+   (Comments here may be outdated. API getter/setter function descriptions
+    may override the descriptions here. Any difference is supposed to be a
+    minor correction only.)
+ */
+struct isoburn_imgen_opts {
+
+    /* Options for image generation */
+
+    int level;  /**< ISO level to write at. */
+    
+    /** Which extensions to support. */
+    unsigned int rockridge :1;
+    unsigned int joliet :1;
+    unsigned int iso1999 :1;
+
+    /* relaxed constraints */
+
+    /*
+     * Relaxed constraints. Setting any of these to 1 break the specifications,
+     * but it is supposed to work on most moderns systems. Use with caution.
+     */
+
+    /**
+     * Omit the version number (";1") at the end of the ISO-9660 identifiers.
+     * Version numbers are usually not used.
+     */
+    unsigned int omit_version_numbers :1;
+
+    /**
+     * Allow ISO-9660 directory hierarchy to be deeper than 8 levels.
+     */
+    unsigned int allow_deep_paths :1;
+
+    /**
+     * Allow path in the ISO-9660 tree to have more than 255 characters.
+     */
+    unsigned int allow_longer_paths :1;
+
+    /**
+     * Allow a single file or directory hierarchy to have up to 37 characters.
+     * This is larger than the 31 characters allowed by ISO level 2, and the
+     * extra space is taken from the version number, so this also forces
+     * omit_version_numbers.
+     */
+    unsigned int max_37_char_filenames :1;
+
+    /**
+     * ISO-9660 forces filenames to have a ".", that separates file name from
+     * extension. libisofs adds it if original filename doesn't has one. Set
+     * this to 1 to prevent this behavior
+     */
+    unsigned int no_force_dots :1;
+
+    /**
+     * Allow lowercase characters in ISO-9660 filenames. By default, only
+     * uppercase characters, numbers and a few other characters are allowed.
+     */
+    unsigned int allow_lowercase :1;
+
+    /**
+     * Allow all ASCII characters to be appear on an ISO-9660 filename. Note
+     * that "/" and "\0" characters are never allowed, even in RR names.
+     */
+    unsigned int allow_full_ascii :1;
+
+    /**
+     * Allow paths in the Joliet tree to have more than 240 characters.
+     */
+    unsigned int joliet_longer_paths :1;
+
+    unsigned int sort_files:1;
+                /**< If files should be sorted based on their weight. */
+
+    /**
+     * The following options set the default values for files and directory
+     * permissions, gid and uid. All these take one of three values: 0, 1 or 2.
+     * If 0, the corresponding attribute will be kept as set in the IsoNode.
+     * Unless you have changed it, it corresponds to the value on disc, so it
+     * is suitable for backup purposes. If set to 1, the corresponding attrib.
+     * will be changed by a default suitable value. Finally, if you set it to
+     * 2, the attrib. will be changed with the value specified in the options
+     * below. Note that for mode attributes, only the permissions are set, the
+     * file type remains unchanged.
+     */
+    unsigned int replace_dir_mode :2; 
+    unsigned int replace_file_mode :2;
+    unsigned int replace_uid :2;
+    unsigned int replace_gid :2;
+    
+    mode_t dir_mode; /** Mode to use on dirs when replace_dir_mode == 2. */
+    mode_t file_mode; /** Mode to use on files when replace_file_mode == 2. */
+    uid_t uid; /** uid to use when replace_uid == 2. */
+    gid_t gid; /** gid to use when replace_gid == 2. */
+
+    char *output_charset; /**< NULL to use default charset */
+
+
+    /* Options for image transport */
+
+    /** The number of bytes to be used for the fifo which decouples libisofs
+        and libburn for better throughput and for reducing the risk of
+        interrupting signals hitting the libburn thread which operates the
+        MMC drive.
+        The size will be rounded up to the next full 2048.
+        Minimum is 64kiB, maximum is 1 GiB (but that is too much anyway).
+    */
+    int fifo_size;
+
+};
+
+#endif /* Isoburn_includeD */
+

libisoburn/branches/ZeroOneZero-pl01/libisoburn/isofs_wrap.c

@@ -0,0 +1,398 @@
+
+/*
+  cc -g -c isofs_wrap.c
+*/
+
+/*
+  libisofs related functions of libisoburn.
+
+  Copyright 2007 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+                 Thomas Schmitt <scdbackup@gmx.net>
+*/
+
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef Xorriso_standalonE
+
+#include <libburn/libburn.h>
+
+#include <libisofs/libisofs.h>
+
+#else /* ! Xorriso_standalonE */
+
+#include "../libisofs/libisofs.h"
+#include "../libburn/libburn.h"
+
+#endif /* Xorriso_standalonE */
+
+
+#include "isoburn.h"
+#include "libisoburn.h"
+
+#define BP(a,b) [(b) - (a) + 1]
+
+struct ecma119_pri_vol_desc
+{
+	uint8_t vol_desc_type		BP(1, 1);
+	uint8_t std_identifier		BP(2, 6);
+	uint8_t vol_desc_version	BP(7, 7);
+	uint8_t unused1			BP(8, 8);
+	uint8_t system_id		BP(9, 40);
+	uint8_t volume_id		BP(41, 72);
+	uint8_t unused2			BP(73, 80);
+	uint8_t vol_space_size		BP(81, 88);
+	uint8_t unused3			BP(89, 120);
+	uint8_t vol_set_size		BP(121, 124);
+	uint8_t vol_seq_number		BP(125, 128);
+	uint8_t block_size		BP(129, 132);
+	uint8_t path_table_size		BP(133, 140);
+	uint8_t l_path_table_pos	BP(141, 144);
+	uint8_t opt_l_path_table_pos	BP(145, 148);
+	uint8_t m_path_table_pos	BP(149, 152);
+	uint8_t opt_m_path_table_pos	BP(153, 156);
+	uint8_t root_dir_record		BP(157, 190);
+	uint8_t	vol_set_id		BP(191, 318);
+	uint8_t publisher_id		BP(319, 446);
+	uint8_t data_prep_id		BP(447, 574);
+	uint8_t application_id		BP(575, 702);
+	uint8_t copyright_file_id	BP(703, 739);
+	uint8_t abstract_file_id	BP(740, 776);
+	uint8_t bibliographic_file_id	BP(777, 813);
+	uint8_t vol_creation_time	BP(814, 830);
+	uint8_t vol_modification_time	BP(831, 847);
+	uint8_t vol_expiration_time	BP(848, 864);
+	uint8_t vol_effective_time	BP(865, 881);
+	uint8_t file_structure_version	BP(882, 882);
+	uint8_t reserved1		BP(883, 883);
+	uint8_t app_use			BP(884, 1395);
+	uint8_t reserved2		BP(1396, 2048);
+};
+
+static
+uint32_t iso_read_lsb(const uint8_t *buf, int bytes)
+{
+	int i;
+	uint32_t ret = 0;
+
+	for (i=0; i<bytes; i++) {
+		ret += ((uint32_t) buf[i]) << (i*8);
+	}
+	return ret;
+}
+
+
+/* API function. See libisoburn.h
+*/
+IsoImage *isoburn_get_attached_image(struct burn_drive *d)
+{
+ int ret;
+ struct isoburn *o= NULL;
+ ret = isoburn_find_emulator(&o, d, 0);
+ if (ret < 0)
+   return NULL;
+  
+ if (o == NULL) {
+   return NULL;
+ }
+ iso_image_ref(o->image);
+ return o->image;
+}
+
+
+static void isoburn_idle_free_function(void *ignored)
+{
+ return;
+}
+
+
+/* API function. See libisoburn.h
+*/
+int isoburn_read_image(struct burn_drive *d,
+                       struct isoburn_read_opts *read_opts, 
+                       IsoImage **image)
+{
+ int ret, int_num;
+ IsoReadOpts *ropts= NULL;
+ IsoReadImageFeatures *features= NULL;
+ uint32_t ms_block;
+
+ enum burn_disc_status status= BURN_DISC_BLANK;
+ IsoDataSource *ds= NULL;
+ struct isoburn *o= NULL;
+
+ if(read_opts==NULL) {
+   burn_msgs_submit(0x00060000,
+                    "Program error: isoburn_read_image: read_opts==NULL",
+                    0, "FATAL", NULL);
+   return(-1);
+ }
+ if(d != NULL) {
+   ret = isoburn_find_emulator(&o, d, 0);
+   if (ret < 0 || o == NULL)
+     return 0;
+   status = isoburn_disc_get_status(d);
+ }
+ if (d == NULL || status == BURN_DISC_BLANK || read_opts->pretend_blank) {
+   
+   /*
+    * Blank disc, we create a new image without files.
+    */
+   
+   if (d == NULL) {
+     /* New empty image without relation to a drive */
+     if (image==NULL) {
+       burn_msgs_submit(0x00060000,
+                        "Program error: isoburn_read_image: image==NULL",
+                    0, "FATAL", NULL);
+       return -1;
+     }
+     /* create a new image */
+     ret = iso_image_new("ISOIMAGE", image);
+     if (ret < 0) {
+       isoburn_report_iso_error(ret, "Cannot create image", 0, "FATAL", 0);
+       return ret;
+     }
+   } else {
+     /* Blank new image for the drive */
+     iso_image_unref(o->image);
+     ret = iso_image_new("ISOIMAGE", &o->image);
+     if (ret < 0) {
+       isoburn_report_iso_error(ret, "Cannot create image", 0, "FATAL", 0);
+       return ret;
+     }
+     if (image) {
+       *image = o->image;
+       iso_image_ref(*image); /*protects object from premature free*/
+     }
+   }
+   return 1;
+ }
+ 
+ if (status != BURN_DISC_APPENDABLE && status != BURN_DISC_FULL) {
+   burn_msgs_submit(0x00060000,
+                    "Program error: isoburn_read_image: incorrect disc status",
+                    0, "FATAL", NULL);
+   return -4;	
+ }
+ 
+ memset((char *) &ropts, 0, sizeof(ropts));
+
+ ret = isoburn_disc_get_msc1(d, &int_num);
+ if (ret <= 0)
+   return -2;
+ ms_block= int_num;
+
+ /* create the data source */
+ ret = iso_read_opts_new(&ropts, 0);
+ if (ret < 0) {
+   isoburn_report_iso_error(ret, "Cannot create write opts", 0, "FATAL", 0);
+   return ret;
+ }
+ /* Important: do not return until iso_read_opts_free() */
+ iso_read_opts_set_start_block(ropts, ms_block);
+ iso_read_opts_set_no_rockridge(ropts, read_opts->norock);
+ iso_read_opts_set_no_joliet(ropts, read_opts->nojoliet);
+ iso_read_opts_set_no_iso1999(ropts, read_opts->noiso1999);
+ iso_read_opts_set_preferjoliet(ropts, read_opts->preferjoliet);
+ iso_read_opts_set_default_permissions(ropts,
+                                       read_opts->mode, read_opts->dirmode);
+ iso_read_opts_set_default_uid(ropts, read_opts->uid);
+ iso_read_opts_set_default_gid(ropts, read_opts->gid);
+ iso_read_opts_set_input_charset(ropts, read_opts->input_charset);
+ ds = isoburn_data_source_new(d);
+ iso_image_attach_data(o->image, o->read_pacifier_handle,
+                       isoburn_idle_free_function);
+ if(o->read_pacifier_handle==NULL)
+   iso_tree_set_report_callback(o->image, NULL);
+ else
+   iso_tree_set_report_callback(o->image, o->read_pacifier);
+ ret = iso_image_import(o->image, ds, ropts, &features);
+ iso_tree_set_report_callback(o->image, NULL);
+ iso_read_opts_free(ropts);
+ iso_data_source_unref(ds);
+ if (ret < 0) {
+   isoburn_report_iso_error(ret, "Cannot import image", 0, "FAILURE", 0);
+   return ret;
+ }
+ /* Important: do not return until free(features) */
+ if (image!=NULL) {
+   *image = o->image;
+   iso_image_ref(*image); /*protects object from premature free*/
+ }
+ read_opts->hasRR = iso_read_image_features_has_rockridge(features);
+ read_opts->hasJoliet = iso_read_image_features_has_joliet(features);
+ read_opts->hasIso1999 = iso_read_image_features_has_iso1999(features);
+ read_opts->hasElTorito = iso_read_image_features_has_eltorito(features);
+ read_opts->size = iso_read_image_features_get_size(features);
+ 
+#ifdef NIX 
+ read_opts->hasRR = features->hasRR;
+ read_opts->hasJoliet = features->hasJoliet;
+ read_opts->hasIso1999 = features->hasIso1999;
+ read_opts->hasElTorito = features->hasElTorito;
+ read_opts->size = features->size;
+#endif
+
+ iso_read_image_features_destroy(features);
+ return 1;
+}
+
+
+/* API function. See libisoburn.h
+*/
+int isoburn_attach_image(struct burn_drive *d, IsoImage *image)
+{
+ int ret;
+ struct isoburn *o;
+
+ if (image == NULL) {
+   burn_msgs_submit(0x00060000,
+                    "Program error: isoburn_attach_image: image==NULL",
+                    0, "FATAL", NULL);
+   return -1;
+ }
+ ret = isoburn_find_emulator(&o, d, 0);
+ if (ret < 0 || o == NULL)
+   return 0;
+ if(o->image != NULL)
+   iso_image_unref(o->image);
+ o->image = image;
+ return(1);
+}
+
+
+/* API function. See libisoburn.h
+*/
+int isoburn_activate_session(struct burn_drive *drive)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret = isoburn_find_emulator(&o, drive, 0);
+ if (ret < 0)
+   return -1;
+
+ if (o->emulation_mode != 1)
+   return 1; /* don't need to activate session */
+ 
+ if (o->fabricated_disc_status != BURN_DISC_APPENDABLE)
+   return 1;
+ 
+ ret = burn_random_access_write(drive, 0, (char*)o->target_iso_head, 
+                                32*2048, 1);
+
+ return ret;
+}
+
+
+/** Initialize the emulation of multi-session on random access media.
+    The need for emulation is confirmed already.
+    @param o A freshly created isoburn object. isoburn_create_data_source() was
+             already called, nevertheless.
+    @return <=0 error , 1 = success
+*/
+int isoburn_start_emulation(struct isoburn *o, int flag)
+{
+ int ret, i;
+ off_t data_count;
+ struct burn_drive *drive;
+ struct ecma119_pri_vol_desc *pvm;
+ 
+ if(o==NULL) {
+   burn_msgs_submit(0x00060000,
+                    "Program error: isoburn_start_emulation: o==NULL",
+                    0, "FATAL", NULL);
+   return -1;
+ }
+
+ drive= o->drive;
+
+ /* we can assume 0 as start block for image */
+ /* TODO what about ms? where we validate valid iso image in ms disc? */
+ ret = burn_read_data(drive, (off_t) 0, (char*)o->target_iso_head, 
+                      sizeof(o->target_iso_head), &data_count, 2);
+
+ /* an error means an empty disc */
+ if (ret <= 0) {
+   o->fabricated_disc_status= BURN_DISC_BLANK;
+   return 1;
+ }
+
+ /* check first 64K. If 0's, the disc is treated as a blank disc, and thus
+    overwritten without extra check. */
+ i = sizeof(o->target_iso_head);
+ while (i && !o->target_iso_head[i-1]) 
+   --i;
+
+ if (!i) {
+   o->fabricated_disc_status= BURN_DISC_BLANK;
+   return 1;
+ }
+
+ pvm = (struct ecma119_pri_vol_desc *)(o->target_iso_head + 16 * 2048);
+
+ if (!strncmp((char*)pvm->std_identifier, "CD001", 5)) {
+   off_t size;
+
+   /* sanity check */
+   if (pvm->vol_desc_type[0] != 1 || pvm->vol_desc_version[0] != 1 
+       || pvm->file_structure_version[0] != 1 ) {
+     /* TODO for now I treat this as a full disc */
+     o->fabricated_disc_status= BURN_DISC_FULL;
+     return 1;
+   }
+
+   /* ok, PVM found, set size */
+   size = (off_t) iso_read_lsb(pvm->vol_space_size, 4);
+   size *= (off_t) 2048; /* block size in bytes */
+   isoburn_set_start_byte(o, size, 0);
+   o->fabricated_disc_status= BURN_DISC_APPENDABLE;
+ } else if (!strncmp((char*)pvm->std_identifier, "CDXX1", 5)) {
+
+   /* empty image */
+   isoburn_set_start_byte(o, (off_t) 0, 0);
+   o->fabricated_disc_status= BURN_DISC_BLANK;
+ } else {
+   /* treat any disc in an unknown format as full */
+   o->fabricated_disc_status= BURN_DISC_FULL;
+ }
+ return 1;
+}
+
+
+/** Alters and writes the first 64 kB of a "media" to invalidate
+    an ISO image. (It shall stay restorable by skilled humans, though).
+    The result shall especially keep libisoburn from accepting the media
+    image as ISO filesystem.
+    @param o A fully activated isoburn object. isoburn_start_emulation()
+             was already called.
+    @return <=0 error , 1 = success
+*/
+int isoburn_invalidate_iso(struct isoburn *o, int flag)
+{
+ /* 
+  * replace CD001 with CDXX1 in PVM.
+  * I think this is enought for invalidating an iso image
+  */
+ strncpy((char*)o->target_iso_head + 16 * 2048 + 1, "CDXX1", 5);
+ return isoburn_activate_session(o->drive);
+}
+
+
+/* API @since 0.1.0 */
+int isoburn_set_read_pacifier(struct burn_drive *drive,
+                              int (*read_pacifier)(IsoImage*, IsoFileSource*),
+                              void *read_handle)
+{
+ int ret;
+ struct isoburn *o;
+
+ ret = isoburn_find_emulator(&o, drive, 0);
+ if(ret < 0 || o == NULL)
+   return -1;
+ o->read_pacifier_handle= read_handle;
+ o->read_pacifier= read_pacifier;
+ return(1);
+}
+

libisoburn/branches/ZeroOneZero-pl01/test/compare_file.c

@@ -0,0 +1,216 @@
+/*
+  Compare two copies of a file object in as many aspects as i can imagine
+  to make sense. (E.g.: comparing atime makes no sense.)
+
+  To compare tree /media/dvd and /original/dir :
+      find /media/dvd -exec compare_file '{}' /media/dvd /original/dir ';'
+
+  Copyright 2008 Thomas Schmitt, <scdbackup@gmx.net>
+
+  Provided under GPL version 2.
+
+
+  cc -g -o compare_file compare_file.c
+*/
+
+#include <ctype.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <string.h>
+
+
+/* @param flag bit0= compare atime
+               bit1= compare ctime
+*/
+int Compare_2_files(char *adr1, char *adr2, char *adrc, int flag)
+{
+ struct stat s1, s2;
+ int ret, differs= 0, r1, r2, fd1= -1, fd2= -1, i, done;
+ char buf1[4096], buf2[4096], a[4096];
+ off_t r1count= 0, r2count= 0, diffcount= 0, first_diff= -1;
+
+ ret= lstat(adr1, &s1);
+ if(ret==-1) {
+   printf("? %s : cannot lstat() : %s\n", adr1, strerror(errno));
+   return(0);
+ }
+ if(S_ISDIR(s1.st_mode))
+   strcpy(a, "d");
+ else if(S_ISREG(s1.st_mode))
+   strcpy(a, "-");
+ else if(S_ISLNK(s1.st_mode))
+   strcpy(a, "l");
+ else if(S_ISBLK(s1.st_mode))
+   strcpy(a, "b");
+ else if(S_ISCHR(s1.st_mode))
+   strcpy(a, "c");
+ else if(S_ISFIFO(s1.st_mode))
+   strcpy(a, "p");
+ else if(S_ISSOCK(s1.st_mode))
+   strcpy(a, "s");
+ else
+   strcpy(a, "?");
+ strcat(a, " ");
+ if(adrc[0])
+   strcat(a, adrc);
+ else
+   strcat(a, ".");
+
+ ret= lstat(adr2, &s2);
+ if(ret==-1) {
+   printf("? %s : cannot lstat() : %s\n", adr2, strerror(errno));
+   return(0);
+ }
+
+ /* Attributes */
+ if(s1.st_mode != s2.st_mode) {
+   printf("%s : st_mode :  %7.7o  <>  %7.7o\n", a, s1.st_mode, s2.st_mode);
+   differs= 1;
+ }
+ if(s1.st_uid != s2.st_uid) {
+   printf("%s : st_uid :   %d  <>  %d\n", a, s1.st_uid, s2.st_uid);
+   differs= 1;
+ }
+ if(s1.st_gid != s2.st_gid) {
+   printf("%s : st_gid :   %d  <>  %d\n", a, s1.st_gid, s2.st_gid);
+   differs= 1;
+ }
+ if((S_ISCHR(s1.st_mode) && S_ISCHR(s2.st_mode)) ||
+    (S_ISBLK(s1.st_mode) && S_ISBLK(s2.st_mode))) {
+   if(s1.st_rdev != s2.st_rdev) {
+     printf("%s : %s st_rdev :  %lu  <>  %lu\n", a,
+            (S_ISCHR(s1.st_mode) ? "S_IFCHR" : "S_IFBLK"),
+            (unsigned long) s1.st_rdev, (unsigned long) s1.st_rdev);
+     differs= 1;
+   }
+ }
+ if(S_ISREG(s2.st_mode) && s1.st_size != s2.st_size) {
+   printf("%s : st_size :  %.f  <>  %.f\n",
+          a, (double) s1.st_size, (double) s2.st_size);
+   differs= 1;
+ }
+ if(s1.st_mtime != s2.st_mtime) {
+   printf("%s : st_mtime :  %u  <>  %u\n",
+          a, (unsigned int) s1.st_mtime, (unsigned int) s2.st_mtime);
+   differs= 1;
+ }
+ if(flag&1) {
+   if(s1.st_atime != s2.st_atime) {
+     printf("%s : st_atime :  %u  <>  %u\n",
+            a, (unsigned int) s1.st_atime, (unsigned int) s2.st_atime);
+     differs= 1;
+   }
+ }
+ if(flag&2) {
+   if(s1.st_ctime != s2.st_ctime) {
+     printf("%s : st_ctime :  %u  <>  %u\n",
+            a, (unsigned int) s1.st_ctime, (unsigned int) s2.st_ctime);
+     differs= 1;
+   }
+ }
+ if(S_ISREG(s1.st_mode)) {
+   fd1= open(adr1, O_RDONLY);
+   if(fd1==-1) {
+     printf("- %s : cannot open() : %s\n", adr1, strerror(errno));
+     return(0);
+   }
+   fd2= open(adr2, O_RDONLY);
+   if(fd2==-1) {
+     printf("- %s : cannot open() : %s\n", adr2, strerror(errno));
+     close(fd1);
+     return(0);
+   }
+  
+   /* Content */
+   done= 0;
+   while(!done) {
+     r1= read(fd1, buf1, sizeof(buf1));
+     r2= read(fd2, buf2, sizeof(buf2));
+     if((r1==EOF && r2==EOF) || (r1==0 && r2==0))
+   break;
+     if(r1==EOF || r1==0) {
+       if(r1==EOF)
+         r1= 0;
+       if(s1.st_size > r1count + r1)
+         printf("- %s : early EOF after %.f bytes\n", adr1, (double) r1count);
+       differs= 1;
+     }
+     r1count+= r1;
+     if(r2==EOF || r2<r1) {
+       if(r2==EOF)
+         r2= 0;
+       if(s2.st_size > r2count + r2)
+         printf("- %s : early EOF after %.f bytes\n", adr2, (double) r2count);
+       differs= 1;
+       done= 1;
+     }
+     if(r2>r1) {
+       if(s1.st_size > r1count + r1)
+         printf("- %s : early EOF after %.f bytes\n", adr1, (double) r1count);
+       differs= 1;
+       done= 1;
+     }
+     r2count+= r2;
+     if(r1>r2)
+       r1= r2;
+     for(i= 0; i<r1; i++) {
+       if(buf1[i]!=buf2[i]) {
+         if(first_diff<0)
+           first_diff= i;
+         diffcount++;
+       }
+     }
+   }
+   if(diffcount>0 || r1count!=r2count) {
+     if(first_diff<0)
+       first_diff= (r1count>r2count ? r2count : r1count);
+     printf("%s : %s : differs by at least %.f bytes. First at %.f\n", a,
+            (s1.st_mtime==s2.st_mtime ?  "CONTENT":"content"),
+            (double) (diffcount + abs(r1count-r2count)), (double) first_diff);
+     differs= 1;
+   }
+ }
+ if(fd1!=-1)
+   close(fd1);
+ if(fd2!=-1)
+   close(fd2);
+ return(!differs);
+}
+
+
+int main(int argc, char **argv)
+{
+ int ret, i, with_ctime= 1;
+ char adr1[4096], adr2[4096], adrc[4096];
+
+ if(argc<4) {
+   fprintf(stderr, "usage: %s  path  prefix1  prefix2\n", argv[0]);
+   exit(2);
+ }
+ for(i= 4; i<argc; i++) {
+   if(strcmp(argv[i], "-no_ctime")==0)
+     with_ctime= 0;
+   else {
+     fprintf(stderr, "%s : Option not recognized: '%s'\n", argv[0], argv[i]);
+     exit(1);
+   }
+ }
+
+ if(strncmp(argv[1], argv[2], strlen(argv[2]))!=0) {
+   fprintf(stderr, "%s: path '%s' does not match prefix1 '%s'\n",
+          argv[0], argv[1], argv[2]);
+   exit(2);
+ }
+ strcpy(adr1, argv[1]);
+ strcpy(adrc, argv[1]+strlen(argv[2]));
+ sprintf(adr2, "%s%s%s", argv[3], (adrc[0]=='/' ? "" : "/"), adrc);
+
+ ret=  Compare_2_files(adr1, adr2, adrc, (with_ctime<<1));
+ exit(ret<=0);
+}
+

libisoburn/branches/ZeroOneZero-pl01/test/test.c

@@ -0,0 +1,312 @@
+/*
+  Little test program for libisoburn.
+  It grows an iso filesystem on a disc.
+
+  Copyright 2007 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
+             and Thomas Schmitt <scdbackup@gmx.net>
+*/
+
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <getopt.h>
+#include <err.h>
+#include <string.h>
+#include <errno.h>
+#include <sys/stat.h>
+
+
+#include <libisofs/libisofs.h>
+#include <libburn/libburn.h>
+#include "../src/libisoburn.h"
+
+const char * const optstring = "JRh";
+extern char *optarg;
+extern int optind;
+
+
+/** Activates the usage of function graft_point() rather than
+    plain iso_tree_radd_dir() from libisofs
+*/
+#define With_graft_poinT 1
+
+
+static int graft_point(struct iso_volume *volume, const char *disk_path,
+                const char *img_path, struct iso_tree_radd_dir_behavior *behav)
+{
+ char path[4096], *apt, *npt;
+ struct iso_tree_node_dir *dir;
+ struct iso_tree_node *node;
+ int done= 0, is_dir= 0;
+ struct stat stbuf;
+
+ strncpy(path, img_path, sizeof(path)-1);
+ path[sizeof(path)-1]= 0;
+ apt= npt= path;
+
+ if(lstat(disk_path, &stbuf) == -1) {
+   fprintf(stderr, "Cannot determine attributes of '%s' : %s (%d)\n",
+           disk_path, (errno > 0 ? strerror(errno) : "unknown error"), errno);
+   return(0);
+ }
+ if(S_ISDIR(stbuf.st_mode)) 
+   is_dir= 1; 
+ else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) {
+   fprintf(stderr, "File object '%s' is of non-supported file type\n",
+           disk_path);
+   return(0);
+ }
+
+ dir= iso_volume_get_root(volume);
+ if(dir==NULL) {
+   fprintf(stderr, "While grafting '%s' : no root node available\n", img_path);
+   return(0);
+ }
+ for(npt= apt; !done; apt= npt+1) {
+   npt= strchr(apt, '/');
+   if(npt==NULL) {
+     npt= apt+strlen(apt);
+     done= 1;
+   } else
+     *npt= 0;
+   if(*apt==0) {
+     *apt= '/';
+     apt++;
+ continue;
+   }
+   node= iso_tree_volume_path_to_node(volume,path);
+   if(node!=NULL) {
+     if(iso_tree_node_get_type(node)!=LIBISO_NODE_DIR) {
+       fprintf(stderr, "While grafting '%s' : '%s' is not a directory\n",
+               img_path, path);
+       return(0);
+     }
+     dir= (struct iso_tree_node_dir *) node;
+   } else {
+     dir= iso_tree_add_dir(dir, apt);
+     if(dir==NULL) {
+       fprintf(stderr, "While grafting '%s' : could not insert '%s'\n",
+               img_path, path);
+       return(0);
+     }
+   }
+   if(done) {
+     if(is_dir) {
+       iso_tree_radd_dir(dir, disk_path, behav);
+     } else {
+       node= iso_tree_add_node(dir, disk_path);
+       if(node == NULL) {
+         fprintf(stderr, "While grafting '%s'='%s' : libisofs_errno = %d\n",
+               img_path, disk_path, libisofs_errno);
+       }
+     }
+   } else
+     *npt= '/';
+ }
+ fprintf(stderr, "NOTE: added %s '%s'='%s'\n", (is_dir ? "directory" : "node"),
+                 img_path, disk_path);
+ return(1);
+}
+
+
+static
+void usage()
+{
+	printf("test [OPTIONS] DRIVE DIRECTORY\n");
+}
+
+static
+void help()
+{
+	printf(
+"Options:\n"
+"  -J       Add Joliet support\n"
+"  -R       Add Rock Ridge support\n"
+"  -h       Print this message\n"
+);
+}
+
+int main(int argc, char **argv)
+{
+	struct burn_drive_info *drives;
+	struct iso_volset *volset;
+	struct burn_drive *drive;
+	struct burn_disc *disc;
+	enum burn_disc_status state;
+	struct isoburn_read_opts ropts;
+	struct isoburn_source_opts sopts;
+	int c;
+	struct iso_tree_radd_dir_behavior behav = {0,0,0};
+	int flags=0;
+	int ret=0, i;
+	int size, free_bytes;
+	char *status_text;
+
+	while ((c = getopt(argc, argv, optstring)) != -1) {
+		switch(c) {
+		case 'h':
+			usage();
+			help();
+			exit(0);
+			break;
+		case 'J':
+			flags |= ECMA119_JOLIET;
+			break;
+		case 'R':
+			flags |= ECMA119_ROCKRIDGE;
+			break;
+		case '?':
+			usage(); 
+			exit(1);
+			break;
+		}
+	}
+
+	if (argc < optind + 1) {
+		fprintf(stderr, "Please supply device name\n");
+		usage();
+		exit(1);
+	}
+	if (argc < optind + 2) {
+		fprintf(stderr, "Please supply directory to add to disc\n");
+		usage();
+		exit(1);
+	}
+	
+	
+	if (!isoburn_initialize()) {
+		fprintf(stderr, "Can't init libisoburn\n");
+		exit(1);
+	}
+	
+	/* TODO change this. maybe we can add wrapp in libisoburn */
+	iso_msgs_set_severities("NEVER", "DEBUG", "libisofs : ");
+	burn_msgs_set_severities("NEVER", "DEBUG", "libburn : ");
+	burn_set_signal_handling("libisoburn/test/test : ", NULL, 0);
+	
+	printf("Growing drive %s\n", argv[optind]);
+	
+	if (isoburn_drive_scan_and_grab(&drives, argv[optind], 1) <= 0) {
+		fprintf(stderr,
+		"Can't open device. Are you sure it is a valid drive?\n");
+		exit(1);
+	}
+	drive = drives[0].drive;
+	
+	/* check for invalid state */
+	state = isoburn_disc_get_status(drive);
+	if (state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) {
+		fprintf(stderr, "Unsuitable disc status\n");
+		goto exit_cleanup;
+	}
+	
+	/* fill read opts */
+        memset(&ropts, sizeof(ropts), 0);
+	ropts.norock = 0;
+	ropts.nojoliet = 0;
+	ropts.preferjoliet = 0;
+	ropts.uid = 0;
+	ropts.gid = 0;
+	ropts.mode = 0555;
+        ropts.pretend_blank= 0;
+	
+	if (isoburn_read_volset(drive, &ropts, &volset) <= 0) {
+		fprintf(stderr, "Can't read volset\n");
+		goto exit_cleanup;
+	}
+
+
+#ifdef With_graft_poinT
+	for (i = optind + 1; i < argc; i++) {
+		if (graft_point(iso_volset_get_volume(volset, 0),
+				argv[i], argv[i], &behav) <= 0) {
+			fprintf(stderr, "Canot graft '%s'\n", argv[optind+1]);
+			goto exit_cleanup;
+		}
+	}
+	
+#else
+	struct iso_tree_node_dir *root;
+	root = iso_volume_get_root(iso_volset_get_volume(volset, 0));
+	/* add a new dir */
+	iso_tree_radd_dir(root, argv[optind+1], &behav);
+#endif /* ! With_graft_poinT */
+
+	
+	sopts.level = 2;
+	sopts.flags = flags;
+	sopts.relaxed_constraints = 0;
+	sopts.copy_eltorito = 1;
+	sopts.no_cache_inodes = 0;
+	sopts.sort_files = 1;
+	sopts.default_mode = 0;
+	sopts.replace_dir_mode = 0;
+	sopts.replace_file_mode = 0;
+	sopts.replace_uid = 0;
+	sopts.replace_gid = 0;
+	sopts.dir_mode = 0555;
+	sopts.file_mode = 0444;
+	sopts.gid = 0;
+	sopts.uid = 0;
+	sopts.input_charset = NULL;
+	sopts.ouput_charset = NULL;
+
+	if (isoburn_prepare_disc(drive, &disc, &sopts) <= 0) {
+		fprintf(stderr, "Can't prepare disc\n");
+		goto volset_cleanup;
+	}
+	
+	/* a. write the new image */
+	printf("Adding new data...\n");
+	{
+		struct burn_write_opts *burn_options;
+		struct burn_progress progress;
+		
+		burn_options = burn_write_opts_new(drive);
+		burn_drive_set_speed(drive, 0, 0);
+		burn_write_opts_set_underrun_proof(burn_options, 1);
+	
+		/* ok, write the new track */
+		isoburn_disc_write(burn_options, disc);
+		burn_write_opts_free(burn_options);
+		
+		while (burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING)
+			usleep(100002);
+		
+		while (burn_drive_get_status(drive, &progress)
+							 != BURN_DRIVE_IDLE) {
+
+			printf("Writing: sector %d of %d",
+				 progress.sector, progress.sectors);
+			ret = isoburn_get_fifo_status(drive, &size,
+					 	&free_bytes, &status_text);
+			if (ret > 0 )
+				printf("  [fifo %s, %2d%% fill]", status_text,
+					(int) (100.0 - 100.0 *
+						((double) free_bytes) /
+						(double) size));
+			printf("\n");
+			sleep(1);
+		}
+	}
+	
+	/* b. write the new vol desc */
+	printf("Writing the new vol desc...\n");
+	if (isoburn_activate_session(drive) <= 0) {
+ 		fprintf(stderr, "Ups, new vol desc write failed\n");
+ 	}
+
+	ret= 0;
+volset_cleanup:;
+/*
+	iso_volset_free(volset);
+*/       
+	
+exit_cleanup:;
+	isoburn_drive_release(drive, 0);
+	isoburn_finish();
+	
+	exit(ret);
+}
+

libisoburn/branches/ZeroOneZero-pl01/version.h.in

@@ -0,0 +1,6 @@
+
+/* <<< this file is on its way out 
+#define ISOBURN_MAJOR_VERSION @ISOBURN_MAJOR_VERSION@
+#define ISOBURN_MINOR_VERSION @ISOBURN_MINOR_VERSION@
+#define ISOBURN_MICRO_VERSION @ISOBURN_MICRO_VERSION@
+*/

libisoburn/branches/ZeroOneZero-pl01/xorriso/README

@@ -0,0 +1,201 @@
+------------------------------------------------------------------------------
+     libburnia-project.org     scdbackup.sourceforge.net/xorriso_eng.html
+------------------------------------------------------------------------------
+xorriso. By Thomas Schmitt <scdbackup@gmx.net>
+Integrated sub project of libburnia-project.org but also published via:
+http://scdbackup.sourceforge.net/xorriso_eng.html
+http://scdbackup.sourceforge.net/xorriso-0.1.0.pl00.tar.gz
+Copyright (C) 2006-2008 Thomas Schmitt, provided under GPL version 2.
+------------------------------------------------------------------------------
+
+
+xorriso is a program which maps file objects from POSIX compliant
+filesystems into Rock Ridge enhanced ISO 9660 filesystems and allows
+session-wise manipulation of such filesystems. It can load the management
+information of existing ISO images and it writes the session results to
+optical media or to filesystem objects.
+
+Currently it is only supported on Linux with kernels >= 2.4.
+
+A special property of xorriso is that it needs neither an external ISO 9660
+formatter program nor an external burn program for CD or DVD but rather
+incorporates the libraries of libburnia-project.org .
+
+By using this software you agree to the disclaimer at the end of this text:
+"... without even the implied warranty ..."
+
+
+                   Compilation, First Glimpse, Installation
+
+The most simple way to get xorriso from source code is the xorriso standalone
+tarball.
+
+Prerequisites:
+The tarball contains anything that is needed except libc and libpthread.
+libreadline and the readline-dev headers will make dialog mode more convenient,
+but are not mandatory.
+
+Obtain xorriso-0.1.0.pl00.tar.gz, take it to a directory of your choice and do:
+
+    tar xzf xorriso-0.1.0.pl00.tar.gz
+    cd xorriso-0.1.0
+
+Within that directory execute:
+
+    ./configure --prefix=/usr
+    make
+
+This will produce a binary named
+    ./xorriso/xorriso
+
+which you may strip to reduce it in size
+    strip ./xorriso/xorriso
+
+You may copy or move it to a directory where it can be found by the shell,
+you may execute xorriso at the place where it was built, or you may execute
+as superuser:
+    make install
+
+For general concepts, options and usage examples see
+    man 1 xorriso
+
+This man page is part of the tarball as
+    xorriso/xorriso.1
+You may get a first glimpse by
+    man ./xorriso/xorriso.1
+
+It gets installed with "make install" but may also be placed manually in the
+./man1 directory below one of the directories mentioned in environment
+variable $MANPATH.
+
+
+                       Drives and Disk File Objects 
+
+The user of xorriso needs rw-permission for the CD burner device.
+A list of rw-accessible drives can be obtained by
+
+    xorriso -devices
+
+CD devices which offer no rw-permission are invisible to normal users.
+The superuser should be able to see any usable drive and then set the
+permissions as needed.
+
+The output of  xorriso -devices  might look like
+
+0  -dev '/dev/sr0' rwrw-- :  'TSSTcorp' 'CDDVDW SH-S203B' 
+1  -dev '/dev/hda' rwrw-- :  'HL-DT-ST' 'DVD-ROM GDR8162B' 
+
+Full and insecure enabling of both for everybody would look like
+    chmod a+rw /dev/sr0 /dev/hda
+This is equivalent to the traditional setup chmod a+x,u+s cdrecord.
+
+I strongly discourage to run xorriso with setuid root or via sudo !
+It is not checked for the necessary degree of hacker safety.
+
+Consider to put all authorized users into group "floppy", to chgrp the
+device file to that group and to disallow w-access to others.
+
+
+A possible source of problems are hald or other automounters. 
+If you can spot a process "hald-addon-storage" with the address of
+your desired drive, then consider to kill it.
+
+If you cannot get rid of the automounter that easily, try whether it helps
+to always load the drive tray manually before starting a write run of
+xorriso. Wait until the drive light is off.
+Better try to unmount an eventually mounted media before a write run.
+
+
+Besides true optical drives, xorriso can also address disk files as input or
+output drives. The addresses of the disk files have to be preceded by "stdio:".
+Like:
+    xorriso -dev stdio:/tmp/pseudo_drive ...more arguments...
+
+
+                              Testing
+
+We are quite sure that libisofs produces accurate representations of the disk
+files. This opinion is founded on a lot of test burns and checks by a little
+test program which compares files from the mounted image with the orignals
+on disk. It uses the normal POSIX filesystem calls, i.e. no libburnia stuff.
+
+This program is not installed systemwide but stays in the installation
+directory of the xorriso tarball as  test/compare_file . Usually it is
+run as -exec payload of a find command. It demands at least three arguments:
+The path of the first file to compare, the prefix1 to be cut off from path
+and the prefix2 which gets prepended afterwards to obtain the path of the
+second file to compare.
+As further argument there can be -no_ctime which suppresses the comparison
+of ctime date stamps.
+The exit value is 0 if no difference was detected, non-0 else.
+
+Example: After
+   xorriso ... -pathspecs on -add /=/original/dir --
+   mount /media/dvd
+   cd test
+compare tree /media/dvd with tree /original/dir :
+   find /original/dir -exec ./compare_file '{}' /original/dir /media/dvd ';' \
+   | less
+and vice versa:
+   find /media/dvd -exec ./compare_file '{}' /media/dvd /original/dir ';' \
+   | less
+
+
+                             libisoburn
+
+xorriso is based on libisofs which does ISO 9600 filesystem aspects and on
+libburn which does the input and output aspects. Parts of this foundation
+are accessed via libisoburn, which is closely related to xorriso.
+
+libisoburn provides two services:
+- Encapsulation of coordination between libisofs and libburn.
+- Emulation of ISO 9660 multi-session on overwriteable media
+  or random access files.
+
+The sourcecode of all three libraries is included in the xorriso standalone
+tarball. It is compiled with xorriso and linked statically.
+But you may as well get and install releases of libburn and libisofs, in order
+to be able to install a release of libisoburn which produces libisoburn.so.1
+and a matching dynamically linked xorriso binary.
+This binary is leaner but depends on properly installed libraries of suitable
+revision.
+
+Dynamic library and compile time header requirements for libisoburn-0.1.0 :
+- libburn.so.4  , version libburn-0.4.2 or higher
+- libisofs.so.6 , version libisofs-0.6.2 or higher
+libisoburn and xorriso will not start with libraries which are older than their
+headers seen at compile time. So compile in the oldest possible installation
+setup unless you have reason to enforce a newer bug fix level.
+
+Standalone xorriso has less runtime dependencies and can be moved more freely.
+
+
+------------------------------------------------------------------------------
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License version 2 as
+    published by the Free Software Foundation.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+------------------------------------------------------------------------------
+Based on and sub project of:
+libburnia-project.org
+By Mario Danic           <mario.danic@gmail.com>,
+   Vreixo Formoso        <metalpain2002@yahoo.es>
+   Thomas Schmitt        <scdbackup@gmx.net>
+Copyright (C) 2006-2008 Mario Danic, Vreixo Formoso, Thomas Schmitt.
+
+libburnia-project.org is inspired by and in other components still containing
+parts of old
+Libburn. By Derek Foreman <derek@signalmarketing.com> and
+            Ben Jansens <xor@orodu.net>
+Copyright (C) 2002-2006  Derek Foreman and Ben Jansens
+

libisoburn/branches/ZeroOneZero-pl01/xorriso/compile_xorriso.sh

@@ -0,0 +1,155 @@
+#!/bin/sh
+
+# compile_xorriso.sh
+# Copyright 2005 - 2008 Thomas Schmitt, scdbackup@gmx.net, GPL
+#
+# Not intended for general use in production installations !
+# Rather use:  ./bootstrap ; ./configure ; make
+#
+# This is a development tool which expects a special setup of directories.
+# It is to be executed in a common parent of the directories given with
+#   $isofs $isoburn $burn $xorr
+
+isofs=./nglibisofs-develop/libisofs
+burn=./libburn-develop/libburn
+isoburn=./libisoburn-develop/libisoburn
+xorr=./libisoburn-develop/xorriso
+
+debug_opts="-O2"
+def_opts=
+largefile_opts="-D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1"
+do_strip=0
+static_opts=
+warn_opts="-Wall"
+nglibisofs=1
+
+for i in "$@"
+do
+  if test "$i" = "-do_diet"
+  then
+    def_opts="$def_opts -DXorriso_no_helP"
+    warn_opts=
+  elif test "$i" = "-do_strip"
+  then
+    do_strip=1
+  elif test "$i" = "-g"
+  then
+    debug_opts="-g -O0"
+  elif test "$i" = "-help" -o "$i" = "--help" -o "$i" = "-h"
+  then
+    echo \
+        "$xorr/compile_xorriso.sh : to be executed above top level directories"
+    echo "Options:"
+    echo "  -do_diet          produce capability reduced lean version."
+    echo "  -do_strip         apply program strip to compiled programs."
+    echo "  -g                produce debuggable programm."
+    echo "  -static           compile with cc option -static."
+    exit 0
+  elif test "$i" = "-static"
+  then
+    static_opts="-static"
+  fi
+done
+
+libisofs=
+libisofs="$libisofs $isofs"/buffer.o
+libisofs="$libisofs $isofs"/builder.o
+libisofs="$libisofs $isofs"/data_source.o
+libisofs="$libisofs $isofs"/ecma119.o
+libisofs="$libisofs $isofs"/ecma119_tree.o
+libisofs="$libisofs $isofs"/eltorito.o
+libisofs="$libisofs $isofs"/filesrc.o
+libisofs="$libisofs $isofs"/fs_image.o
+libisofs="$libisofs $isofs"/fs_local.o
+libisofs="$libisofs $isofs"/fsource.o
+libisofs="$libisofs $isofs"/image.o
+libisofs="$libisofs $isofs"/iso1999.o
+libisofs="$libisofs $isofs"/joliet.o
+libisofs="$libisofs $isofs"/libiso_msgs.o
+libisofs="$libisofs $isofs"/messages.o
+libisofs="$libisofs $isofs"/node.o
+libisofs="$libisofs $isofs"/rockridge.o
+libisofs="$libisofs $isofs"/rockridge_read.o
+libisofs="$libisofs $isofs"/stream.o
+libisofs="$libisofs $isofs"/tree.o
+libisofs="$libisofs $isofs"/util.o
+libisofs="$libisofs $isofs"/util_htable.o
+libisofs="$libisofs $isofs"/util_rbtree.o
+
+timestamp="$(date -u '+%Y.%m.%d.%H%M%S')"
+echo "Version timestamp :  $(sed -e 's/#define Xorriso_timestamP "//' -e 's/"$//' "$xorr"/xorriso_timestamp.h)"
+echo "Build timestamp   :  $timestamp"
+
+echo "compiling program $xorr/xorriso.c $static_opts $debug_opts $def_opts"
+cc -I. -DXorriso_with_maiN -DXorriso_with_regeX -DXorriso_with_readlinE \
+  $warn_opts \
+  $static_opts \
+  $debug_opts \
+  $def_opts \
+  $largefile_opts \
+  \
+  -DXorriso_build_timestamP='"'"$timestamp"'"' \
+  \
+  -o "$xorr"/xorriso \
+  \
+  "$xorr"/xorriso.c \
+  \
+  "$xorr"/xorrisoburn.c \
+  \
+  "$burn"/async.o \
+  "$burn"/debug.o \
+  "$burn"/drive.o \
+  "$burn"/file.o \
+  "$burn"/init.o \
+  "$burn"/options.o \
+  "$burn"/source.o \
+  "$burn"/structure.o \
+  \
+  "$burn"/sg.o \
+  "$burn"/write.o \
+  "$burn"/read.o \
+  "$burn"/libdax_audioxtr.o \
+  "$burn"/libdax_msgs.o \
+  "$burn"/cleanup.o \
+  \
+  "$burn"/mmc.o \
+  "$burn"/sbc.o \
+  "$burn"/spc.o \
+  "$burn"/util.o \
+  \
+  "$burn"/sector.o \
+  "$burn"/toc.o \
+  \
+  "$burn"/crc.o \
+  "$burn"/lec.o \
+  \
+  "$isoburn"/isoburn.o \
+  "$isoburn"/burn_wrap.o \
+  "$isoburn"/data_source.o \
+  "$isoburn"/isofs_wrap.o \
+  \
+  $libisofs \
+  \
+  -lreadline \
+  \
+  -lpthread
+
+  ret=$?
+  if test "$ret" = 0
+  then
+    dummy=dummy
+  else
+    echo >&2
+    echo "+++ FATAL : Compilation of xorriso failed" >&2
+    echo >&2
+    exit 1
+  fi
+
+
+if test "$do_strip" = 1
+then
+  echo "stripping result $xorr/xorriso"
+  strip "$xorr"/xorriso
+fi
+
+echo 'done.'

libisoburn/branches/ZeroOneZero-pl01/xorriso/configure_ac.txt

@@ -0,0 +1,124 @@
+AC_INIT([xorriso], [0.1.0], [http://libburnia-project.org])
+AC_PREREQ([2.50])
+dnl AC_CONFIG_HEADER([config.h])	
+
+AC_CANONICAL_HOST
+AC_CANONICAL_TARGET
+
+AM_INIT_AUTOMAKE([subdir-objects])
+
+BURN_MAJOR_VERSION=0
+BURN_MINOR_VERSION=4
+BURN_MICRO_VERSION=3
+AC_SUBST(BURN_MAJOR_VERSION)
+AC_SUBST(BURN_MINOR_VERSION)
+AC_SUBST(BURN_MICRO_VERSION)
+
+LIBISOFS_MAJOR_VERSION=0
+LIBISOFS_MINOR_VERSION=6
+LIBISOFS_MICRO_VERSION=2
+AC_SUBST(LIBISOFS_MAJOR_VERSION)
+AC_SUBST(LIBISOFS_MINOR_VERSION)
+AC_SUBST(LIBISOFS_MICRO_VERSION)
+
+dnl The API version codes are now defined in libisoburn/libisoburn.h
+dnl #define  isoburn_header_version_*
+dnl configure.ac only rules the libtool revision numbering about
+dnl LT_CURREN, LT_AGE, LT_REVISION where SONAME becomes LT_CURRENT - LT_AGE
+dnl
+dnl These three are only copies to provide libtool with unused LT_RELEASE
+dnl ISOBURN_MAJOR_VERSION=0
+dnl ISOBURN_MINOR_VERSION=1
+dnl ISOBURN_MICRO_VERSION=0
+dnl AC_SUBST(ISOBURN_MAJOR_VERSION)
+dnl AC_SUBST(ISOBURN_MINOR_VERSION)
+dnl AC_SUBST(ISOBURN_MICRO_VERSION)
+
+
+AC_PREFIX_DEFAULT([/usr/local])
+test "$prefix" = "NONE" && prefix=$ac_default_prefix
+
+AM_MAINTAINER_MODE
+
+AM_PROG_CC_C_O
+AC_C_CONST
+AC_C_INLINE
+AC_C_BIGENDIAN
+
+dnl Large file support
+AC_SYS_LARGEFILE
+AC_FUNC_FSEEKO
+AC_CHECK_FUNC([fseeko])
+if test ! $ac_cv_func_fseeko; then
+   AC_ERROR([Libburn requires largefile support.])
+fi
+
+AC_PROG_LIBTOOL
+AC_SUBST(LIBTOOL_DEPS)
+LIBTOOL="$LIBTOOL --silent"
+
+AC_PROG_INSTALL
+
+AC_CHECK_HEADERS()
+
+AC_CHECK_MEMBER([struct tm.tm_gmtoff],
+	[AC_DEFINE(HAVE_TM_GMTOFF, 1,
+		[Define this if tm structure includes a tm_gmtoff entry.])],
+	,
+	[#include <time.h>])
+
+dnl Check if non standard timegm() function is available
+AC_CHECK_DECL([timegm],
+        [AC_DEFINE(HAVE_TIMEGM, 1, [Define this if timegm function is available])],
+        ,
+        [#include <time.h>])
+
+dnl Check if non standard eaccess() function is available
+AC_CHECK_DECL([eaccess],
+        [AC_DEFINE(HAVE_EACCESS, 1, [Define this if eaccess function is available])],
+        ,
+        [#include <unistd.h>])
+
+THREAD_LIBS=-lpthread
+AC_SUBST(THREAD_LIBS)
+
+TARGET_SHIZZLE
+AC_SUBST(ARCH)
+AC_SUBST(LIBBURN_ARCH_LIBS)
+
+dnl Add compiler-specific flags
+
+dnl See if the user wants aggressive optimizations of the code
+AC_ARG_ENABLE(debug,
+[  --enable-debug          Disable aggressive optimizations [default=yes]],
+              , enable_debug=yes)
+if test x$enable_debug != xyes; then
+    if test x$GCC = xyes; then
+        CFLAGS="$CFLAGS -O3"
+        CFLAGS="$CFLAGS -fexpensive-optimizations"
+    fi
+    CFLAGS="$CFLAGS -DNDEBUG"
+else
+    if test x$GCC = xyes; then
+        CFLAGS="$CFLAGS -g -pedantic -Wall"
+    fi
+    CFLAGS="$CFLAGS -DDEBUG"
+fi
+
+
+dnl Check whether there is readline-devel and readline-runtime.
+dnl If not, erase this macro which would enable use of readline(),add_history()
+READLINE_DEF="-DXorriso_with_readlinE"
+dnl The empty yes case obviously causes -lreadline to be linked
+AC_CHECK_HEADER(readline/readline.h, AC_CHECK_LIB(readline, readline, , READLINE_DEF= ), READLINE_DEF= )
+dnl The X= in the yes case prevents that -lreadline gets linked twice
+AC_CHECK_HEADER(readline/history.h, AC_CHECK_LIB(readline, add_history, X= , READLINE_DEF= ), READLINE_DEF= )
+AC_SUBST(READLINE_DEF)
+
+
+AC_CONFIG_FILES([
+	Makefile
+	version.h
+	xorriso.pc
+	])
+AC_OUTPUT

libisoburn/branches/ZeroOneZero-pl01/xorriso/convert_man_to_html.sh

@@ -0,0 +1,107 @@
+#!/bin/sh
+
+#
+# convert_man_to_html.sh - ts A80118
+#
+# Generates a HTML version of man page xorriso.1
+#
+# To be executed in the libisoburn toplevel directory (eg. ./libisoburn-0.1.0)
+#
+
+# set -x
+
+man_dir=$(pwd)"/xorriso"
+export MANPATH="$man_dir"
+manpage="xorriso"
+raw_html=$(pwd)/"xorriso/raw_man_1_xorriso.html"
+htmlpage=$(pwd)/"xorriso/man_1_xorriso.html"
+
+if test -r "$man_dir"/"$manpage".1
+then
+  dummy=dummy
+else
+  echo "Cannot find readable man page source $1" >&2
+  exit 1
+fi
+
+if test -e "$man_dir"/man1
+then
+  dummy=dummy
+else
+  ln -s . "$man_dir"/man1
+fi
+
+if test "$1" = "-work_as_filter"
+then
+
+#  set -x
+
+  sed \
+  -e 's/<meta name="generator" content="groff -Thtml, see www.gnu.org">/<meta name="generator" content="groff -Thtml, via man -H, via xorriso\/convert_man_to_html.sh">/' \
+  -e 's/<meta name="Content-Style" content="text\/css">/<meta name="Content-Style" content="text\/css"><META NAME="description" CONTENT="man page of xorriso"><META NAME="keywords" CONTENT="man xorriso, manual, xorriso, CD, CD-RW, CD-R, burning, cdrecord, compatible"><META NAME="robots" CONTENT="follow">/' \
+  -e 's/<title>XORRISO<\/title>/<title>man 1 xorriso<\/title>/' \
+  -e 's/<h1 align=center>XORRISO<\/h1>/<h1 align=center>man 1 xorriso<\/h1>/' \
+  -e 's/<body>/<body BGCOLOR="#F5DEB3" TEXT=#000000 LINK=#0000A0 VLINK=#800000>/' \
+  -e 's/<b>Overview of features:<\/b>/\&nbsp;<BR><b>Overview of features:<\/b>/' \
+  -e 's/<b>General information paragraphs:<\/b>/\&nbsp;<BR><b>General information paragraphs:<\/b>/' \
+  -e 's/have a look at section EXAMPLES/have a look at section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
+  -e 's/<b>Session model:<\/b>/\&nbsp;<BR><b>Session model:<\/b>/' \
+  -e 's/<b>Media types and states:<\/b>/\&nbsp;<BR><b>Media types and states:<\/b>/' \
+  -e 's/<b>Creating, Growing, Modifying:<\/b>/\&nbsp;<BR><b>Creating, Growing, Modifying:<\/b>/' \
+  -e 's/<b>Libburn drives:<\/b>/\&nbsp;<BR><b>Libburn drives:<\/b>/' \
+  -e 's/^-dev /\&nbsp;\&nbsp;-dev /' \
+  -e 's/^-devices /\&nbsp;\&nbsp;-devices /' \
+  -e 's/<b>Rock Ridge, POSIX, X\/Open:<\/b>/\&nbsp;<BR><b>Rock Ridge, POSIX, X\/Open:<\/b>/' \
+  -e 's/<b>Command processing:<\/b>/\&nbsp;<BR><b>Command processing:<\/b>/' \
+  -e 's/<b>Dialog, Readline, Result pager:<\/b>/\&nbsp;<BR><b>Dialog, Readline, Result pager:<\/b>/' \
+  -e 's/<b>Aquiring source and target drive:<\/b>/\&nbsp;<BR><b>Aquiring source and target drive:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Data manipulations:<\/b>/\&nbsp;<BR><b>Data manipulations:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/^<p><b>&minus;iso_rr_pattern/<p>\&nbsp;<BR><b>\&minus;iso_rr_pattern/' \
+  -e 's/EXAMPLES):<br>/<A HREF="#EXAMPLES">EXAMPLES<\/A>):<br>/' \
+  -e 's/<b>Writing the result:<\/b>/\&nbsp;<BR><b>Writing the result:<\/b><BR>/' \
+  -e 's/^-find \/ /\&nbsp;\&nbsp;-find \/ /' \
+  -e 's/<b>Settings for data insertion:<\/b>/\&nbsp;<BR><b>Settings for data insertion:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/^$<\/b> ln -s/\&nbsp;\&nbsp;$<\/b> ln -s/' \
+  -e 's/<b>Settings for result writing:<\/b>/\&nbsp;<BR><b>Settings for result writing:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/^706k = 706kB/\&nbsp;\&nbsp;706k = 706kB/' \
+  -e 's/^5540k = 5540kB/\&nbsp;\&nbsp;5540k = 5540kB/' \
+  -e 's/<b>Exception processing:<\/b>/\&nbsp;<BR><b>Exception processing:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Dialog mode control:<\/b>/\&nbsp;<BR><b>Dialog mode control:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Drive and media related inquiry actions:<\/b>/\&nbsp;<BR><b>Drive and media related inquiry actions:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Navigation in ISO image/\&nbsp;<BR><b>Navigation in ISO image/' \
+  -e 's/^filesystem:<\/b>/filesystem:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Scripting, dialog and/\&nbsp;<BR><b>Scripting, dialog and/' \
+  -e 's/^features:<\/b>/features:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/<b>Support for frontend/\&nbsp;<BR><b>Support for frontend/' \
+  -e 's/^listening at stdout:<\/b>/listening at stdout:<\/b><BR>\&nbsp;<BR>/' \
+  -e 's/xorriso -outdev \/dev\/sr2 \\ -blank fast \\ -pathspecs on/xorriso -outdev \/dev\/sr2 -blank fast -pathspecs on/' \
+  -e 's/\\ -add \\ \/sounds=\/home\/me\/sounds \\ \/pictures \\ -- \\ -rm_r \\/ -add \/sounds=\/home\/me\/sounds \/pictures -- -rm_r /' \
+  -e 's/\/sounds\/indecent \\ \&rsquo;\/pictures\/\*private\*\&rsquo; \\/\/sounds\/indecent \&rsquo;\/pictures\/*private*\&rsquo; /' \
+  -e 's/\/pictures\/confidential \\ -- \\ -add \\/\/pictures\/confidential -- -add/' \
+  -e 's/xorriso -dev \/dev\/sr2 \\ -rm_r \/sounds -- \\ -mv \\/xorriso -dev \/dev\/sr2 -rm_r \/sounds -- -mv /' \
+  -e 's/\/pictures\/confidential \\ \/pictures\/restricted \\ -- \\ -chmod/\/pictures\/confidential \/pictures\/restricted -- -chmod/' \
+  -e 's/go-rwx \/pictures\/restricted -- \\ -pathsspecs on \\ -add \\/go-rwx \/pictures\/restricted -- -pathsspecs on -add /' \
+  -e 's/\/sounds=\/home\/me\/prepared_for_dvd\/sounds_dummy /\/sounds=\/home\/me\/prepared_for_dvd\/sounds_dummy/' \
+  -e 's/\/movies=\/home\/me\/prepared_for_dvd\/movies \\ -- \\ -commit/\/movies=\/home\/me\/prepared_for_dvd\/movies -- -commit/' \
+  -e 's/xorriso -indev \/dev\/sr2 \\ -rm_r \/sounds -- \\/xorriso -indev \/dev\/sr2 -rm_r \/sounds -- /' \
+  -e 's/-outdev \/dev\/sr0 -blank fast \\ -commit -eject all/-outdev \/dev\/sr0 -blank fast -commit -eject all/' \
+  -e 's/See section FILES/See section <A HREF="#FILES">FILES<\/A>/' \
+  -e 's/See section EXAMPLES/See section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
+  -e 's/<\/body>/<BR><HR><FONT SIZE=-1><CENTER>(HTML generated from '"$manpage"'.1 on '"$(date)"' by '$(basename "$0")' )<\/CENTER><\/FONT><\/body>/' \
+  <"$2" >"$htmlpage"
+
+  set +x
+
+  chmod u+rw,go+r,go-w "$htmlpage"
+  echo "Emerged file:"
+  ls -lL "$htmlpage"
+
+else
+
+  export BROWSER='cp "%s" '"$raw_html"
+  man -H "$manpage"
+  "$0" -work_as_filter "$raw_html"
+  rm "$raw_html"
+  rm "$man_dir"/man1
+
+fi

libisoburn/branches/ZeroOneZero-pl01/xorriso/make_timestamp.sh

@@ -0,0 +1,9 @@
+#!/bin/sh
+
+# Create version timestamp xorriso/xorriso_timestamp.h
+# to be executed within  ./libisoburn-develop
+
+timestamp="$(date -u '+%Y.%m.%d.%H%M%S')"
+echo "Version timestamp :  $timestamp"
+echo '#define Xorriso_timestamP "'"$timestamp"'"' >xorriso/xorriso_timestamp.h
+

libisoburn/branches/ZeroOneZero-pl01/xorriso/make_xorriso_standalone.sh

@@ -0,0 +1,231 @@
+#!/bin/sh
+
+# make_xorriso_standalone.sh
+# Copyright 2008 Thomas Schmitt, scdbackup@gmx.net, GPL
+#
+# Not intended for general use in production installations !
+# 
+# This is a development tool which expects a special setup of directories.
+# It is to be executed in a common parent of the directories 
+#   nglibisofs-develop libburn-develop libisoburn-develop
+#
+# Creates a standalone tree for building xorriso
+# from the contents of a unified libburnia development tree.
+#
+# The ./bootstrap script gets applied and a source tarball
+# is made.
+#
+# From that tree can be build a binary xorriso/xorriso
+# which at runtime depends only on libc and libpthread.
+# Execute in $lone_dir :
+#
+#   ./configure && make
+#
+
+current_dir=$(pwd)
+lone_dir="$current_dir"/"xorriso-standalone"
+
+xorriso_rev=0.1.0
+# For unstable uploads:
+# xorriso_pl=""
+# For stable releases:
+xorriso_pl=".pl00"
+
+with_bootstrap_tarball=1
+
+create_dir() {
+  if mkdir "$1"
+  then
+    dummy=dummy
+  else
+    echo "Failed to create : $r1o" >&2
+    exit 1
+  fi
+}
+
+goto_dir() {
+  if cd "$1"
+  then
+    dummy=dummy
+  else
+    echo "Failed to cd $1" >&2
+    exit 1
+  fi
+}
+
+copy_files() {
+  if cp "$@"
+  then
+    dummy=dummy
+  else
+    echo "Failed to : cp " "$@" >&2
+    exit 1
+  fi
+}
+
+if test -e "$lone_dir"
+then
+  echo "Already existing : $lone_dir" >&2
+  exit 1
+fi
+
+
+# Top level directory 
+
+goto_dir "$current_dir"/libisoburn-develop
+
+create_dir "$lone_dir"
+
+copy_files \
+ AUTHORS \
+ CONTRIBUTORS \
+ COPYRIGHT \
+ COPYING \
+ INSTALL \
+ acinclude.m4 \
+ aclocal.m4 \
+ bootstrap \
+ compile \
+ config.guess \
+ config.status \
+ config.sub \
+ depcomp \
+ install-sh \
+ libtool \
+ ltmain.sh \
+ missing \
+ mkinstalldirs \
+ version.h.in \
+ \
+ "$lone_dir"
+
+copy_files xorriso/configure_ac.txt         "$lone_dir"/configure.ac
+
+copy_files xorriso/xorriso_makefile_am.txt  "$lone_dir"/Makefile.am
+
+copy_files xorriso/xorriso_pc_in.txt        "$lone_dir"/xorriso.pc.in
+
+copy_files xorriso/README                   "$lone_dir"/README
+
+# echo "See end of xorriso/changelog.txt" >"$lone_dir"/TODO
+
+
+# libisoburn
+
+create_dir "$lone_dir"/libisoburn
+copy_files \
+ libisoburn/*.[ch] \
+ "$lone_dir"/libisoburn
+
+xorriso/convert_man_to_html.sh
+
+create_dir "$lone_dir"/xorriso
+copy_files \
+ xorriso/xorrisoburn.[ch] \
+ xorriso/xorriso.[ch1] \
+ xorriso/xorriso_private.h \
+ xorriso/xorriso_timestamp.h \
+ xorriso/changelog.txt \
+ xorriso/xorriso_eng.html \
+ xorriso/man_1_xorriso.html \
+ "$lone_dir"/xorriso
+
+create_dir "$lone_dir"/test
+copy_files \
+ test/compare_file.c \
+ "$lone_dir"/test/compare_file.c
+
+
+# nglibisofs
+
+create_dir "$lone_dir"/libisofs
+goto_dir   "$current_dir"/nglibisofs-develop
+copy_files libisofs/*.[ch] "$lone_dir"/libisofs
+
+# To get a common version.h 
+cat version.h.in >> "$lone_dir"/version.h.in
+
+
+# <<< obsoleted patchings
+
+if test 1 = 0
+then
+
+# Change GNU macro name to POSIX name
+sed -e 's/FNM_FILE_NAME/FNM_PATHNAME/g' \
+  <libisofs/tree.c >"$lone_dir"/libisofs/tree.c
+
+# Filter out the semi-illegal TODO comments 
+( cd "$lone_dir"/libisofs && grep '^[[:space:]]*//' *.[ch] | less )
+echo "Is it ok delete all shown //-lines ?"
+read yesno
+if test "$yesno" = "y" -o "$yesno" = "1"
+then
+  for i in "$lone_dir"/libisofs/*.[ch]
+  do
+    # first copy attributes
+    cp "$i" "$lone_dir"/libisofs/tmpfile
+    # now filter away // lines
+    grep -v '^[[:space:]]*//' <"$i" >"$lone_dir"/libisofs/tmpfile && \
+      mv "$lone_dir"/libisofs/tmpfile "$i"
+  done
+fi
+echo "Remaining // lines:"
+( cd "$lone_dir"/libisofs && grep '//' *.[ch] )
+
+fi
+
+
+
+# libburn
+
+create_dir "$lone_dir"/libburn
+goto_dir   "$current_dir"/libburn-develop
+copy_files libburn/*.[ch] "$lone_dir"/libburn
+
+
+# To get a common version.h 
+cat version.h.in >> "$lone_dir"/version.h.in
+
+
+# tarball
+
+if test "$with_bootstrap_tarball" = 1
+then
+
+tarball_dir="$current_dir"/xorriso-"$xorriso_rev"
+mv "$lone_dir" "$tarball_dir"
+
+goto_dir "$tarball_dir"
+
+./bootstrap
+
+# Remove unneeded temporary data from ./bootstrap
+rm -r ./autom4te.cache
+
+# Repair non-portable shell code output of ./bootstrap
+(
+ cd "$compile_dir" || exit 1
+ sed -e 's/^for ac_header in$/test -z 1 \&\& for ac_header in dummy/' \
+     < ./configure > ./configure-repaired
+ if test "$?" = 0
+ then
+   echo "$0: Empty 'for ac_header in' found in configure." >&2
+ fi
+ mv ./configure-repaired ./configure
+ chmod a+rx,go-w,u+w ./configure
+)
+
+cd "$current_dir"
+tar czf ./xorriso-"$xorriso_rev""$xorriso_pl".tar.gz $(basename "$tarball_dir")
+
+ls -l $(pwd)/xorriso-"$xorriso_rev""$xorriso_pl".tar.gz
+        
+mv "$tarball_dir" "$lone_dir"
+
+fi
+
+echo "Done"
+echo "HINT: Now build xorriso/xorriso by:"
+echo "        cd '$lone_dir' && ./configure && make"
+echo

libisoburn/branches/ZeroOneZero-pl01/xorriso/xorriso.h

@@ -0,0 +1,427 @@
+
+/* Command line oriented batch and dialog tool which creates, loads,
+   manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2008 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2.
+
+   This file contains the public option interface of xorriso.
+*/
+
+#ifndef Xorriso_includeD
+#define Xorriso_includeD yes
+
+/** Opaque handle of the xorriso runtime context */
+struct XorrisO; 
+
+
+/* --------------------- Fundamental Management ------------------- */
+
+/* Create a new xorriso object and tell it the program name to be used
+   with messages.
+*/
+int Xorriso_new(struct XorrisO ** xorriso, char *progname, int flag);
+
+
+/* Make global library initializations.
+   This must be done with the first xorriso object that gets created and
+   with the first xorriso object that gets created after Xorriso_destroy(,1).
+*/ 
+int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
+
+
+/* Destroy xorriso object when it is no longer needed.
+   @param flag bit0= Make global librariy shutdown.
+                     Use only with last xorriso object to be destroyed.
+                     
+*/
+int Xorriso_destroy(struct XorrisO **xorriso, int flag);
+
+
+/* --------------------- Problem Status and Message API ------------------- */
+
+
+/** Submit a problem message to the xorriso problem reporting and handling
+    system. This will eventually increase problem status rank, which may
+    at certain stages in the program be pardoned and reset to 0.
+    The pardon is governed by Xorriso_option_abort_on() and by the anger
+    of the affected program part. If no pardon has been given, then the problem
+    status reaches the caller of option functions.
+    Problem status should be inquired by Xorriso_eval_problem_status() and be
+    reset before next option execution by Xorriso_set_problem_status().
+    The problem status itself does not cause the failure of option functions.
+    But in case of failures for other reasons, a remnant overly severe problem
+    status can cause overly harsh program reactions.
+    @param xorriso    The environment handle
+    @param error_code The unique error code of your message.
+                      Submit 0 if you do not have reserved error codes within
+                      the libburnia project.
+    @param msg_text   Not more than 8196 characters of message text.
+                      A final newline character gets appended automatically.
+    @param os_errno   Eventual errno related to the message. Submit 0 if
+                      the message is not related to a operating system error.
+    @param severity   One of "ABORT", "FATAL", "SORRY", "WARNING", "HINT",
+                      "NOTE", "UPDATE", "DEBUG". Defaults to "FATAL".
+    @param flag       Bitfield for control purposes
+                        bit0= use pager (as with result)
+                        bit1= permission to suppress output
+    @return           1 if message was delivered, <=0 if failure
+*/
+int Xorriso_msgs_submit(struct XorrisO *xorriso,
+                        int error_code, char msg_text[], int os_errno,
+                        char severity[], int flag);
+
+
+/** Evaluate an advise whether to abort or whether to go on with option
+    processing. This should be called after any option function was processed.
+    It updates the problem status by processing the library message queues
+    and then it uses this status and the submitted return value ot the
+    option function to evaluate the situation.
+    @param xorriso    The environment handle
+    @param ret        The return value of the previously called option function
+    @param flag       bit0= do not issue own event messages
+                      bit1= take xorriso->request_to_abort as reason for abort
+    @return           Gives the advice:
+                        2= pardon was given, go on
+                        1= no problem, go on
+                        0= function failed but xorriso would not abort, go on
+                       <0= do abort
+                           -1 = due to xorriso->problem_status
+                                or due to ret<0
+                           -2 = due to xorriso->request_to_abort
+*/
+int Xorriso_eval_problem_status(struct XorrisO *xorriso, int ret, int flag);
+
+
+/** Set the current problem status of the xorriso handle.
+    @param xorriso    The environment handle
+    @param severity   A severity text. Empty text resets to "No Problem". 
+    @param flag       Unused yet. Submit 0.
+    @return           <=0 failure (e.g. wrong severity text), 1 success.
+*/
+int Xorriso_set_problem_status(struct XorrisO *xorriso, char *severity,
+                               int flag);
+
+
+/* The next two functions are part of Xorriso_eval_problem_status().
+   You may use them to build an own advisor function or to drain the
+   library message queues more frequently.
+*/
+
+/** Obtain the current problem status of the xorriso handle.
+    @param xorriso    The environment handle
+    @param severity   The severity text matching the current problem status
+    @param flag       Unused yet. Submit 0.
+    @return           The severity rank number. 0= no problem occured.
+*/
+int Xorriso_get_problem_status(struct XorrisO *xorriso, char severity[80],
+                               int flag);
+
+
+/** Forward any pending messages from the library message queues to the
+    xorriso message system which puts out on info channel. This registers
+    the severity of the library events like the severity of a message submitted
+    via Xorriso_msgs_submit().
+    xorriso sets the message queues of the libraries to queuing "ALL".
+    So it is essential that they get drained regularly.
+    @param xorriso    The environment handle
+    @param flag       Unused yet. Submit 0.
+    @return           1 on success, <=0 if failure
+*/
+int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag);
+
+
+
+/* ---------------------------- Options API ------------------------ */
+/*    See man 1 xorriso for explanation of the particular options    */
+/*
+   Before each call to an option function, there should happen:
+   Xorriso_set_problem_status() with empty severity text.
+
+   After each call to an option function, there should happen:
+   Xorriso_eval_problem_status()
+   One should follow its eventual advice to abort.
+*/
+
+
+/* Option -abort_on */
+int Xorriso_option_abort_on(struct XorrisO *xorriso, char *severity, int flag);
+
+/* Option -add */
+/* @param flag bit0=do not report the added item
+               bit1=do not reset pacifier, no final pacifier message
+*/
+int Xorriso_option_add(struct XorrisO *xorriso, int argc, char **argv,
+                       int *idx, int flag);
+
+/* Option -add_plainly "on"|"off" */
+int Xorriso_option_add_plainly(struct XorrisO *xorriso, char *mode,
+                                   int flag);
+
+
+/* Option -alter_date, alter_date_r */
+/* @param flag bit0=recursive (-alter_date_r)
+*/
+int Xorriso_option_alter_date(struct XorrisO *xorriso, 
+                              char *time_type, char *timestring,
+                              int argc, char **argv, int *idx, int flag);
+
+/* Option -ban_stdio_write */
+int Xorriso_option_ban_stdio_write(struct XorrisO *xorriso, int flag);
+
+/* Option -blank and -format */
+/* @param flag bit0= format rather than blank
+   @return <=0 error , 1 success, 2 revoked by -reassure
+*/
+int Xorriso_option_blank(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -boot_image */
+int Xorriso_option_boot_image(struct XorrisO *xorriso, char *form,
+                              char *treatment, int flag);
+
+/* Option -cd alias -cdi */
+int Xorriso_option_cdi(struct XorrisO *xorriso, char *iso_rr_path, int flag);
+
+/* Option -cdx */
+int Xorriso_option_cdx(struct XorrisO *xorriso, char *disk_path, int flag);
+
+/* Option -chgrp alias -chgrpi , chgrp_r alias chgrpi */
+/* @param flag bit0=recursive (-chgrp_r)
+*/
+int Xorriso_option_chgrpi(struct XorrisO *xorriso, char *gid,
+                          int argc, char **argv, int *idx, int flag);
+
+/* Option -chmod alias -chmodi , -chmod_r alias chmod_ri */
+/* @param flag bit0=recursive (-chmod_r)
+*/
+int Xorriso_option_chmodi(struct XorrisO *xorriso, char *mode,
+                          int argc, char **argv, int *idx, int flag);
+
+/* Option -chown alias -chowni , chown_r alias chown_ri */
+/* @param flag bit0=recursive (-chown_r)
+*/
+int Xorriso_option_chowni(struct XorrisO *xorriso, char *uid,
+                          int argc, char **argv, int *idx, int flag);
+
+/* Option -close "on"|"off" */
+int Xorriso_option_close(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -commit */
+/* @param flag bit0= leave indrive and outdrive aquired as they were,
+                     i.e. do not aquire outdrive as new in-out-drive
+               bit1= do not perform eventual -reassure
+   @return <=0 error , 1 success, 2 revoked by -reassure
+*/
+int Xorriso_option_commit(struct XorrisO *xorriso, int flag);
+
+/* Option -commit_eject  */
+/* @return <=0 error , 1 success, 2 revoked by -reassure
+*/
+int Xorriso_option_commit_eject(struct XorrisO *xorriso, char *which, int flag);
+
+/* Option -cpr alias -cpri */
+int Xorriso_option_cpri( struct XorrisO *xorriso, int argc, char **argv,
+                         int *idx, int flag);
+
+/* >>> not yet implemented
+ / * Option -cut_out * /
+ int Xorriso_option_cut_out(struct XorrisO *xorriso, char *disk_path,
+                off_t startbyte, off_t bytecount, char *iso_rr_path, int flag);
+*/
+
+/* Options -dev , -indev, -outdev */
+/* @param flag bit0=use as indev , bit1= use as outdev
+   @return <=0 error , 1 success, 2 revoked by -reassure
+*/
+int Xorriso_option_dev(struct XorrisO *xorriso, char *adr, int flag);
+
+/* Option -devices */
+/* @return <=0 error , 1 success, 2 revoked by -reassure
+*/
+int Xorriso_option_devices(struct XorrisO *xorriso, int flag);
+
+/* Option -dialog "on"|"off" */
+int Xorriso_option_dialog(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -disk_pattern "on"|"ls"|"off" */
+int Xorriso_option_disk_pattern(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -dummy "on"|"off" */
+int Xorriso_option_dummy(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -eject */
+/* @param flag bit0=do not report toc of eventually remaining drives
+*/
+int Xorriso_option_eject(struct XorrisO *xorriso, char *which, int flag);
+
+/* Options -end , and -rollback_end */
+/* @param flag bit0= discard pending changes 
+   @return <=0 error , 1 success, 2 revoked by -reassure
+*/
+int Xorriso_option_end(struct XorrisO *xorriso, int flag);
+
+/* Option -iso_rr_pattern "on"|"ls"|"off" */
+int Xorriso_option_iso_rr_pattern(struct XorrisO *xorriso, char *mode,
+                                  int flag);
+
+/* Option -follow */
+int Xorriso_option_follow(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -find alias -findi, and -findx */
+/* @param flag bit0= -findx rather than -findi
+*/ 
+int Xorriso_option_find(struct XorrisO *xorriso, int argc, char **argv,
+                       int *idx, int flag);
+
+/* Option -fs */
+int Xorriso_option_fs(struct XorrisO *xorriso, char *size, int flag);
+
+/* Option -gid */
+int Xorriso_option_gid(struct XorrisO *xorriso, char *gid, int flag);
+
+/* Option -help and part of -prog_help */
+int Xorriso_option_help(struct XorrisO *xorriso, int flag);
+
+/* Option -history */
+int Xorriso_option_history(struct XorrisO *xorriso, char *line, int flag);
+
+/* Option -joliet "on"|"off" */
+int Xorriso_option_joliet(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -logfile */
+int Xorriso_option_logfile(struct XorrisO *xorriso, char *channel, 
+                                                      char *fileadr, int flag);
+
+/* Options -ls  alias -lsi   and -lsl  alias -lsli
+       and -lsd alias -lsdi  and -lsdl alias -lsdli
+       and -du  alias -dui   and -dus  alias -dusi
+   @param flag bit0= long format (-lsl , -du)
+               bit1= do not expand patterns but use literally
+               bit2= du rather than ls
+               bit3= list directories as themselves (ls -d)
+*/
+int Xorriso_option_lsi(struct XorrisO *xorriso, int argc, char **argv,
+                      int *idx, int flag);
+
+/* Options -lsx, -lslx, -lsdx , -lsdlx , -dux , -dusx
+   @param flag bit0= long format (-lslx , -dux)
+               bit1= do not expand patterns but use literally
+               bit2= du rather than ls
+               bit3= list directories as themselves (ls -d)
+*/
+int Xorriso_option_lsx(struct XorrisO *xorriso, int argc, char **argv,
+                      int *idx, int flag);
+
+/* Option -mark */
+int Xorriso_option_mark(struct XorrisO *xorriso, char *mark, int flag);
+
+/* Option -mkdir alias -mkdiri */
+int Xorriso_option_mkdiri(struct XorrisO *xorriso, int argc, char **argv,
+                          int *idx, int flag);
+
+/* Option -mv alias -mvi */
+int Xorriso_option_mvi(struct XorrisO *xorriso, int argc, char **argv,
+                      int *idx, int flag);
+
+/* Option -no_rc */
+int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag);
+
+/* Option -options_from_file*/
+/* @return <=0 error , 1 = success , 3 = request to end program run */
+int Xorriso_option_options_from_file(struct XorrisO *xorriso, char *adr,
+                                     int flag);
+
+/* Option -overwrite "on"|"nondir"|"off" */
+int Xorriso_option_overwrite(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -padding */
+int Xorriso_option_padding(struct XorrisO *xorriso, char *size, int flag);
+
+/* Option -page */
+int Xorriso_option_page(struct XorrisO *xorriso, int len, int width, int flag);
+
+/* Option -path-list */
+int Xorriso_option_path_list(struct XorrisO *xorriso, char *adr, int flag);
+
+/* Option -pathspecs */
+int Xorriso_option_pathspecs(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -pkt_output */
+int Xorriso_option_pkt_output(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -print */
+int Xorriso_option_print(struct XorrisO *xorriso, char *text, int flag);
+
+/* Option -print-size */
+int Xorriso_option_print_size(struct XorrisO *xorriso, int flag);
+
+/* Option -prog */
+int Xorriso_option_prog(struct XorrisO *xorriso, char *name, int flag);
+
+/* Option -prog_help */
+int Xorriso_option_prog_help(struct XorrisO *xorriso, char *name, int flag);
+
+/* Option -pwd alias -pwdi */
+int Xorriso_option_pwdi(struct XorrisO *xorriso, int flag);
+
+/* Option -pwdx */
+int Xorriso_option_pwdx(struct XorrisO *xorriso, int flag);
+
+/* Option -report_about */
+int Xorriso_option_report_about(struct XorrisO *xorriso, char *severity, 
+                                int flag);
+
+/* Option -return_with */
+int Xorriso_option_return_with(struct XorrisO *xorriso, char *severity,
+                               int exit_value, int flag);
+
+/* Option -reassure "on"|"tree"|"off" */
+int Xorriso_option_reassure(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Options -rm alias -rmi , -rm_r alias -rm_ri , -rmdir alias -rmdiri */
+/* @param flag bit0=recursive , bit2= remove empty directory: rmdir */
+int Xorriso_option_rmi(struct XorrisO *xorriso, int argc, char **argv,
+                       int *idx, int flag);
+
+/* Option -rollback */
+/* @return <=0 error , 1 success, 2 revoked by -reassure
+*/
+int Xorriso_option_rollback(struct XorrisO *xorriso, int flag);
+
+/* Option -speed */
+int Xorriso_option_speed(struct XorrisO *xorriso, char *speed, int flag);
+
+/* Option -status */
+int Xorriso_option_status(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -status_history_max */
+int Xorriso_option_status_history_max(struct XorrisO *xorriso, int num1, 
+                                      int flag);
+
+/* Option -tell_media_space */
+int Xorriso_option_tell_media_space(struct XorrisO *xorriso, int flag);
+
+/* Option -temp_mem_limit */
+int Xorriso_option_temp_mem_limit(struct XorrisO *xorriso, char *size, 
+                                  int flag);
+
+/* Option -toc */
+int Xorriso_option_toc(struct XorrisO *xorriso, int flag);
+
+/* Option -uid */
+int Xorriso_option_use_readline(struct XorrisO *xorriso, char *uid, int flag);
+
+/* Option -use_readline */
+int Xorriso_option_use_readline(struct XorrisO *xorriso, char *mode, int flag);
+
+/* Option -version */
+int Xorriso_option_version(struct XorrisO *xorriso, int flag);
+
+/* Option -volid */
+int Xorriso_option_volid(struct XorrisO *xorriso, char *volid, int flag);
+
+
+#endif /* Xorriso_includeD */
+
+

libisoburn/branches/ZeroOneZero-pl01/xorriso/xorriso_eng.html

@@ -0,0 +1,424 @@
+<HTML>
+
+<HEAD>
+<META NAME="description" CONTENT="xorriso, creates, loads, manipulates and writes ISO 9660 filesystem images with Rock Ridge extensions">
+<META NAME="keywords" CONTENT="xorriso, libburn, libburnia, burn, CD, DVD, ISO, ISO 9660, RockRidge, Rock Ridge, linux, recording, burning, CD-R, CD-RW, DVD-R, DVD-RW, DVD+RW, DVD+R, scdbackup">
+<META NAME="robots" CONTENT="follow">
+<TITLE>xorriso homepage english</TITLE>
+</HEAD>
+
+<BODY BGCOLOR="#F5DEB3" TEXT=#000000 LINK=#0000A0 VLINK=#800000>
+<FONT SIZE=+1>
+
+<CENTER>
+<P><H2> Homepage of </H2>
+<H1> xorriso </H1>
+
+<H2>ISO 9660 Rock Ridge Filesystem Manipulator for Linux</H2>
+</CENTER>
+
+<P>
+<H2>Purpose:</H2>
+xorriso maps file objects from POSIX compliant filesystems
+into Rock Ridge enhanced ISO 9660 filesystems and allows
+session-wise manipulation of such filesystems. It can load the management
+information of existing ISO images and it writes the session results to
+optical media or to filesystem objects.
+</P>
+<P>
+
+<HR>
+
+<A HREF="#download">Direct hop to download links -></A>
+
+<P>
+<H2>Hardware requirements:</H2>
+A CD/DVD recorder suitable for 
+<A HREF="http://libburnia-project.org">http://libburnia-project.org</A> <BR>
+(SCSI , ATA , USB , or SATA writers compliant to standard MMC-3 for CD
+and to MMC-5 for DVD).
+<BR>
+</P>
+
+<P>
+<H2>Software requirements :</H2>
+<DL>
+<DT>Linux with kernel 2.4 or higher (and libc, of course) :</DT>
+<DD>With kernel 2.4 an ATA drive has to be under ide-scsi emulation.</DD>
+<DD>With kernel 2.6 the drive should not be under ide-scsi.</DD>
+<DT>libpthread</DT>
+<DD>is supposed to be a standard system component.</DD>
+<DT>libreadline and libreadline-dev</DT>
+<DD>are optional and eventually make dialog more convenient.</DD>
+</DL>
+</P>
+
+<P>
+<H2>
+GPL software included:<BR>
+</H2>
+<DL>
+<DT>libburn-0.4.3</DT>
+<DD>reads and writes data from and to CD and DVD.</DD>
+<DD>(founded by Derek Foreman and Ben Jansens,
+furthered by team of libburnia-project.org)</DD>
+<DT>libisofs-0.6.2</DT>
+<DD>operates ISO 9660 images.</DD>
+<DD>(By Vreixo Formoso from team of libburnia-project.org)</DD>
+<DT>libisoburn-0.1.0</DT>
+<DD>coordinates libburn and libisofs, emulates multi-session where needed.</DD>
+<DD>(By Vreixo Formoso and Thomas Schmitt
+from team of libburnia-project.org)</DD>
+</DL>
+<DD>The source code of this software is independent of 
+cdrecord and mkisofs.</A>
+</DD>
+</P>
+
+<P>
+This program system has been tested on Intel/AMD Linux systems only.<BR>
+For ports to other usable systems <A HREF="#contact">contact us</A>.
+</P>
+
+<HR>
+
+<P>
+<H2>Special features:</H2>
+<UL>
+<LI>
+ISO 9660 formatter and burner for CD or DVD are fixely integrated.
+</LI>
+<LI>
+Operates on an existing ISO image or creates a new one.
+<LI>
+</LI>
+Copies files from filesystem into the ISO image.
+<LI>
+</LI>
+Renames or deletes file objects in the ISO image.
+<LI>
+Changes file properties in the ISO image.
+</LI>
+<LI>
+Can write result as completely new image to optical media or
+filesystem objects.
+</LI>
+<LI>
+Can write result as add-on session to appendable multi-session media,
+to overwriteable media, to regular files, and to block devices.
+</LI>
+<LI>
+Scans for optical drives, blanks re-useable optical media.
+</LI>
+<LI>
+Suitable for: CD-R, CD-RW, DVD-R, DVD-RW, DVD+R, DVD+RW, DVD-RAM.
+</LI>
+<LI>
+Reads its instructions from command line arguments, dialog, and batch files.
+</LI>
+<LI>
+Provides navigation commands for interactive ISO image manipulation.
+</LI>
+<LI>
+Adjustable thresholds for abort, exit value, and problem reporting.
+</LI>
+
+</UL>
+</P>
+
+<P>
+<H2>Command Examples:</H2>
+<DL>
+<DT>Get an overview of drives and their addresses</DT>
+<DD>#<KBD>&nbsp;xorriso -devices</KBD></DD>
+<DT>Being superuser avoids permission problems with /dev/srN resp. /dev/hdX .
+</DT>
+<DT>Ordinary users should then get granted rw access to the /dev files
+as listed by option -devices.</DT>
+<DT>&nbsp;</DT>
+
+<DT>Options are either performed as program arguments or as dialog input.
+Some options have a parameter list of variable length. This list has to
+be terminated by word '--' or by the end of the input line. Option -add
+may accept pathspecs of form target=source as known from program mkisofs.</DT>
+
+<HR>
+
+<DT>Get info about a particular drive and loaded media:</DT>
+<DD>$<KBD>&nbsp;xorriso -indev /dev/sr0 -du / -- -toc 2>&amp;1 | less</KBD></DD>
+
+<DT>Make re-usable media writable again, delete any ISO 9660 image:</DT>
+<DD>$<KBD>&nbsp;xorriso -outdev /dev/sr0 -blank fast -eject all</KBD></DD>
+
+<DT>
+<HR>
+</DT>
+
+<DT>Write some directories into a new or existing ISO 9660 image:</DT> 
+<DD>$<KBD>&nbsp;xorriso -dev /dev/sr0 -add /home/me/sounds /home/me/pictures
+</KBD></DD>
+
+<DT>Check the result:</DT>
+<DD>$<KBD>&nbsp;xorriso -indev /dev/sr0 -du / -- -toc 2>&amp;1 | less</KBD></DD>
+
+<DT>
+<HR>
+</DT>
+
+<DT>Create new ISO-9660 filesystem image, compose content,
+adjust permissions to make it publicly read-only,
+write it to media and immediately eject media without
+previously reloading the written image.
+</DT>
+<DD>$<KBD>&nbsp;xorriso -outdev /dev/sr0 -blank fast -pathspecs on \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-add /sounds=/home/me/sounds \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;
+/pictures=/home/me/pictures -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-rm_r /sounds/indecent '/pictures/*private*' -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-add /pictures/private/horses=/home/me/pictures/private/horses -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-chmod_r a+r,a-w / -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-find / -type d -exec chmod a+x -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-volid SOUNDS_PICS_2008_01_16 \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-commit_eject all</KBD></DD>
+
+<DT>
+<HR>
+</DT>
+
+<DT>Load the previous session from media,
+remove (i.e. hide) directory /sounds,
+rename /pictures/private/horses,
+add new directory trees /sounds and /movies,
+disallow any access for group and others.
+Finally write as additional session to media and eject:</DT>
+<DD>$<KBD>&nbsp;xorriso -dev /dev/sr0 -pathspecs on \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-rm_r /sounds -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-mv /pictures/private/horses /horse_show -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-add /sounds=/home/me/prepared_for_dvd/sounds_dummy \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp; /movies=/home/me/prepared_for_dvd/movies -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-chmod_r go-rwx / -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-volid SOUNDS_PICS_2008_01_17 \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-commit_eject all</KBD></DD>
+
+<DT>
+<HR>
+</DT>
+
+<DT>Merge the various sessions from old readable media into a single session
+on new writeable media,
+cleaning out all invalidated files and session overhead.
+Touch / in order to mark the image as worth to be written.
+<BR>
+Important: -indev and -outdev have to be different drives.
+</DT>
+<DD>$<KBD>&nbsp;xorriso -indev /dev/dvd \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-alter_date a +0 / -- \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-outdev /dev/sr0 -blank fast \</KBD></DD>
+<DD><KBD>&nbsp;&nbsp;-commit_eject all</KBD></DD>
+
+<DT>
+<HR>
+</DT>
+
+<DT>Dialog mode accepts one or more options per line. An option and all its
+arguments have to be given in one single line. Command -end stops the program
+run. It will write eventually pending changes to media, if that has not
+already been done by a previous -commit.</DT>
+<DD>$<KBD>&nbsp;xorriso -dialog on</KBD></DD>
+<DD><KBD>enter option and arguments :</KBD></DD>
+<DD><KBD><B>-dev /dev/sr0 -pathspecs on</B></KBD></DD>
+<DD><KBD>enter option and arguments :</KBD></DD>
+<DD><KBD><B>-add /sounds=/home/me/prepared_for_dvd/sounds_dummy /movies=/home/me/prepared_for_dvd/movies</B></KBD></DD>
+<DD>Available navigation commands: -cd, -ls, -du, -find</DD>
+<DD><KBD>enter option and arguments :</KBD></DD>
+<DD><KBD><B>-commit</B></KBD></DD>
+<DD>... perform further commands and finally do:</DD>
+<DD><KBD>enter option and arguments :</KBD></DD>
+<DD><KBD><B>-end</B></KBD></DD>
+
+<DT>
+<HR>
+</DT>
+
+<DT>In batch mode it is possible to operate xorriso in a pipeline
+with an external consumer of the generated ISO image. Any message
+output will be redirected to stderr in this case.</DT>
+<DD>$<KBD>&nbsp;xorriso -outdev - ...other.options... | consumer</KBD></DD>
+
+<DT>
+<HR>
+</DT>
+
+
+<DT>Get overview of the options:</DT>
+<DD>$<KBD>&nbsp;<A HREF="xorriso_help">xorriso -help</A></KBD></DD>
+
+<DT>Read the detailed manual page:</DT>
+<DD>$<KBD>&nbsp;<A HREF="man_1_xorriso.html">man xorriso</A></KBD></DD>
+</DL>
+
+
+Testers wanted who are willing to risk some double layer DVD media.
+
+</P>
+
+<HR>
+<A NAME="download"></A>
+<P>
+<DL>
+<DT>Download as source code (see README):</DT>
+<DD><A HREF="xorriso-0.1.0.pl00.tar.gz">xorriso-0.1.0.pl00.tar.gz</A>
+( KB).
+</DD>
+
+<!--
+<DD>&nbsp;</DD>
+<DT>Download as single x86 binaries (untar and move to /usr/bin/xorriso):</DT>
+<DD><A HREF="xorriso_0.1.0.pl00-x86-suse9_0.tar.gz">
+xorriso_0.1.0.pl00-x86-suse9_0.tar.gz</A>, ( KB),
+<DL>
+<DD>runs on SuSE 9.0 (2.4.21) , SuSE 10.2 (2.6.18.2) and others.</DD>
+</DL>
+<DD><A HREF="xorriso_0.1.0.pl00-x86-suse9_0-static.tar.gz">
+xorriso_0.1.0.pl00-x86-suse9_0-static.tar.gz</A>, ( KB), -static compiled,
+<DL>
+<DD>runs on many other systems.</DD>
+-->
+
+</DL>
+</DD>
+</DL>
+<DL><DT>Documentation:</DT>
+<DD><A HREF="README_xorriso">README</A> about installation and drive setup</DD>
+<DD><A HREF="xorriso_help">xorriso -help</A> gives an overview of options</DD>
+<DD><A HREF="man_1_xorriso.html">man xorriso</A> is the manual page</DD>
+</DL>
+<A NAME="contact"></A>
+<DL><DT>Contact:</DT>
+<DD>Thomas Schmitt, <A HREF="mailto:scdbackup@gmx.net">scdbackup@gmx.net</A></DD>
+<DD>libburn development mailing list,
+<A HREF="mailto:libburn-hackers@pykix.org">libburn-hackers@pykix.org</A></DD>
+</DL>
+<DL><DT>License:</DT>
+<DD><A HREF="COPYING_xorriso">GPL version 2</A>,
+an <A HREF="http://www.opensource.org/">Open Source</A> approved license</DD>
+<DD>&nbsp;</DD>
+</DL>
+</P>
+
+
+<!--
+<HR>
+
+<P>
+Enhancements towards previous stable version xorriso-0.1.0:
+<UL>
+<LI>none yet</LI>
+</UL>
+
+Bug fixes towards xorriso-0.1.0.pl00:
+<UL>
+<LI>none yet</LI>
+</UL>
+
+</P>
+
+<HR>
+
+<P>
+<DL>
+<DT><H3>Development snapshot, version 0.1.0 :</H3></DT>
+<DD>Enhancements towards stable version 0.1.0.pl00:
+<UL>
+<LI>none yet</LI>
+</UL>
+</DD>
+<DD>&nbsp;</DD>
+<DD><A HREF="README_xorriso_devel">README 0.1.1</A>
+<DD><A HREF="xorriso_help_devel">xorriso_0.1.1 -help</A></DD>
+<DD><A HREF="man_1_xorriso_devel.html">man xorriso (as of 0.1.1)</A></DD>
+<DD>&nbsp;</DD>
+<DT>Maintainers of xorriso unstable packages please use SVN of
+<A HREF="http://libburnia-project.org"> libburnia-project.org</A></DT>
+<DD>Download: <KBD><B>svn co http://svn.libburnia-project.org/libburn/trunk libburn</B>
+</KBD></DD>
+<DD>Build: <KBD><B>cd libburn ; ./bootstrap ; ./configure --prefix /usr ; make</B>
+</KBD></DD>
+<DD>Download: <KBD><B>svn co http://svn.libburnia-project.org/libisoburn/trunk libisburn</B>
+</KBD></DD>
+<DD>Build: <KBD><B>cd libisoburn ; ./bootstrap ; ./configure --prefix /usr ; make</B>
+</KBD></DD>
+<DD>Download: - libisofs bzr service not functional yet - </DD>
+<DD>Build: <KBD><B>cd ng-libisofs ; ./autogen.sh ; ./configure --prefix /usr ; make</B>
+</KBD></DD>
+<DD>Build of SVN versions needs <A HREF="http://sources.redhat.com/autobook/">
+autotools</A> of at least version 1.7 installed.
+But after the run of <KBD>./bootstrap</KBD>, only
+vanilla tools like make and gcc are needed.</DD>
+</DD>
+<DD>&nbsp;</DD>
+<DT>The following downloads are intended for adventurous end users or
+admins with full system souvereignty.</DT>
+<DD>Source (./bootstrap is already applied, build tested, for more see
+<A HREF="README_xorriso_devel">upcoming README</A> ):
+</DD>
+<DD>
+<A HREF="xorriso-0.1.1.tar.gz">xorriso-0.1.1.tar.gz</A>
+(680 KB).
+</DD>
+<DD>Binary (untar and move to /usr/bin/xorriso):</DD>
+<DD><A HREF="xorriso_0.1.1-x86-suse9_0.tar.gz">
+xorriso_0.1.1-x86-suse9_0.tar.gz</A>, ( KB).
+</DD>
+<DD><A HREF="xorriso_0.1.1-x86-suse9_0-static.tar.gz">
+xorriso_0.1.1-x86-suse9_0-static.tar.gz</A>, ( KB)
+</DD>
+</DL>
+</P>
+
+-->
+<HR>
+
+<P>
+Many thanks to Derek Foreman and Ben Jansens for starting libburn.
+<BR>
+Very special thanks to Andy Polyakov whose 
+<A HREF="http://fy.chalmers.se/~appro/linux/DVD+RW/tools">dvd+rw-tools</A>
+provide the libburnia project with invaluable examples on how to deal
+with DVD media and how to emulate multi-session on overwriteable media.
+</P>
+
+<HR>
+
+
+<CENTER><FONT SIZE=+0>
+<!-- <A NAME="bottom" HREF="main_ger.html#bottom">deutsch (german)</A>
+<BR><BR>
+ -->
+<BR><BR>
+<FONT SIZE=+0>Enjoying free Open Source hosting by <A HREF="http://www.webframe.org">www.webframe.org</A><BR>
+<A HREF="http://www.webframe.org">
+<IMG SRC="msfree.gif" ALT="100 % Microsoft free" BORDER=0></A><BR>
+and by <A HREF="http://sourceforge.net">sourceforge.net</A><BR>
+<A href="http://sourceforge.net">
+<IMG src="sflogo-88-1.png" BORDER="0" ALT="SourceForge Logo"></A>
+<!-- on sourceforge use : <IMG src="http://sourceforge.net/sflogo.php?group_id=16010" width="88" height="31" border="0" alt="SourceForge Logo"></A> -->
+</FONT></CENTER>
+<HR>
+<DL>
+<DT>Links to my other published software projects :</DT>
+<DD><A HREF=http://scdbackup.webframe.org/cdrskin_eng.html>
+cdrskin, a cdrecord emulator</A></DD>
+<DD><A HREF=http://scdbackup.webframe.org/main_eng.html>
+scdbackup, multi volume CD backup</A></DD>
+<DL><DD><A HREF=http://scdbackup.sourceforge.net/main_eng.html> 
+(a second source of above)</A></DD></DL>
+<DD><A HREF=http://stic.sourceforge.net>Some Tools for Image Collectors</A></DD>
+<DD><A HREF=http://scdbackup.webframe.org/pppoem>
+pppoem, a DSL throughput monitor (mainly for Linux kernel 2.4)</A></DD>
+</DL>
+<BR><BR>
+Legal statement: This website does not serve any commercial purpose.<BR>
+</FONT>
+</BODY>
+</HTML>

libisoburn/branches/ZeroOneZero-pl01/xorriso/xorriso_makefile_am.txt

@@ -0,0 +1,187 @@
+pkgconfigdir=$(libdir)/pkgconfig
+libincludedir=
+
+lib_LTLIBRARIES =
+
+## ========================================================================= ##
+
+libinclude_HEADERS =
+
+## ========================================================================= ##
+
+bin_PROGRAMS = \
+	xorriso/xorriso
+
+xorriso_xorriso_CPPFLAGS = -I./libburn -I./libisofs -I./libisoburn -I./xorriso
+
+# No readline in the vanilla version because the necessary headers
+# are in a separate readline-development package.
+xorriso_xorriso_CFLAGS = -DXorriso_standalonE -DXorriso_with_maiN -DXorriso_with_regeX $(READLINE_DEF)
+
+xorriso_xorriso_LDADD = $(THREAD_LIBS)
+
+xorriso_xorriso_SOURCES = \
+	\
+	xorriso/xorriso.h \
+	xorriso/xorriso_private.h \
+	xorriso/xorriso.c \
+	xorriso/xorrisoburn.h \
+	xorriso/xorrisoburn.c \
+	xorriso/xorriso_timestamp.h \
+	\
+	libisoburn/libisoburn.h \
+	libisoburn/isoburn.h \
+	libisoburn/isoburn.c \
+	libisoburn/isofs_wrap.c \
+	libisoburn/burn_wrap.c \
+	libisoburn/data_source.c \
+	\
+	libisofs/builder.h \
+	libisofs/builder.c \
+	libisofs/error.h \
+	libisofs/node.h \
+	libisofs/node.c \
+	libisofs/tree.h \
+	libisofs/tree.c \
+	libisofs/image.h \
+	libisofs/image.c \
+	libisofs/iso1999.h \
+	libisofs/iso1999.c \
+	libisofs/fsource.h \
+	libisofs/fsource.c \
+	libisofs/fs_local.c \
+	libisofs/fs_image.h \
+	libisofs/fs_image.c \
+	libisofs/messages.h \
+	libisofs/messages.c \
+	libisofs/libiso_msgs.h \
+	libisofs/libiso_msgs.c \
+	libisofs/stream.h \
+	libisofs/stream.c \
+	libisofs/util.h \
+	libisofs/util.c \
+	libisofs/util_rbtree.c \
+	libisofs/util_htable.c \
+	libisofs/filesrc.h \
+	libisofs/filesrc.c \
+	libisofs/ecma119.h \
+	libisofs/ecma119.c \
+	libisofs/ecma119_tree.h \
+	libisofs/ecma119_tree.c \
+	libisofs/writer.h \
+	libisofs/buffer.c \
+	libisofs/rockridge.h \
+	libisofs/rockridge.c \
+	libisofs/rockridge_read.c \
+	libisofs/joliet.h \
+	libisofs/joliet.c \
+	libisofs/eltorito.h \
+	libisofs/eltorito.c \
+	libisofs/data_source.c \
+	\
+	libburn/async.c \
+	libburn/async.h \
+	libburn/back_hacks.h \
+	libburn/cleanup.c \
+	libburn/cleanup.h \
+	libburn/crc.c \
+	libburn/crc.h \
+	libburn/debug.c \
+	libburn/debug.h \
+	libburn/drive.c \
+	libburn/drive.h \
+	libburn/error.h \
+	libburn/file.c \
+	libburn/file.h \
+	libburn/init.c \
+	libburn/init.h \
+	libburn/lec.c \
+	libburn/lec.h \
+	libburn/libburn.h \
+	libburn/libdax_audioxtr.h \
+	libburn/libdax_audioxtr.c \
+	libburn/libdax_msgs.h \
+	libburn/libdax_msgs.c \
+	libburn/mmc.c \
+	libburn/mmc.h \
+	libburn/null.c \
+	libburn/null.h \
+	libburn/options.c \
+	libburn/options.h \
+	libburn/os.h \
+	libburn/read.c \
+	libburn/read.h \
+	libburn/sbc.c \
+	libburn/sbc.h \
+	libburn/sector.c \
+	libburn/sector.h \
+	libburn/sg.c \
+	libburn/sg.h \
+	libburn/source.h \
+	libburn/source.c \
+	libburn/spc.c \
+	libburn/spc.h \
+	libburn/structure.c \
+	libburn/structure.h \
+	libburn/toc.c \
+	libburn/toc.h \
+	libburn/transport.h \
+	libburn/util.c \
+	libburn/util.h \
+	libburn/write.c \
+	libburn/write.h \
+	\
+	version.h
+
+
+noinst_PROGRAMS = \
+	test/compare_file
+
+# A program to compare two trees of files in mounted filesystems
+# To compare tree /media/dvd and /original/dir :
+#   find /media/dvd -exec test/compare_file '{}' /media/dvd /original/dir ';'
+#
+test_compare_file_CPPFLAGS =
+test_compare_file_CFLAGS =
+test_compare_file_LDADD =
+test_compare_file_SOURCES = test/compare_file.c
+
+
+## ========================================================================= ##
+
+# Indent source files
+indent_files = 
+	
+
+indent: $(indent_files)
+	indent -bad -bap -nbbb -nbbo -nbc -bli0 -br -bls   \
+		-cdw -ce -cli0 -ncs -nbfda -i8 -l79 -lc79   \
+		-lp -saf -sai -nprs -npsl -saw -sob -ss -ut \
+		-sbi0 -nsc -ts8 -npcs -ncdb -fca            \
+		$^
+
+.PHONY: indent
+
+## ========================================================================= ##
+
+# Extra things
+nodist_pkgconfig_DATA = \
+	xorriso.pc
+
+man_MANS = xorriso/xorriso.1
+
+EXTRA_DIST = \
+	xorriso.pc.in \
+	version.h.in \
+	README \
+	AUTHORS \
+	CONTRIBUTORS \
+	COPYRIGHT \
+	COPYING \
+	NEWS \
+	ChangeLog \
+	INSTALL \
+	xorriso/compile_xorriso.sh \
+	$(man_MANS)
+	
+

libisoburn/branches/ZeroOneZero-pl01/xorriso/xorriso_pc_in.txt

@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: xorriso
+Description: ISO 9660 filesystem image manipulator
+Version: @VERSION@
+Requires: 
+Libs: -L${libdir} -lpthread
+Cflags:
+

libisoburn/branches/ZeroOneZero-pl01/xorriso/xorriso_private.h

@@ -0,0 +1,393 @@
+
+/* Command line oriented batch and dialog tool which creates, loads,
+   manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2008 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2.
+
+   This file contains inner declarations of xorriso.
+   The public interface is in xorriso.h
+*/
+
+
+/* For now, #ifdef Xorriso_is_xorriso_selF  has no meaning.
+   But it is already now to be set only by the xorriso.c module.
+*/
+
+#ifndef Xorriso_private_includeD
+#define Xorriso_private_includeD yes
+
+#define Xorriso_program_versioN "0.1.0"
+
+/** The source code release timestamp */
+#include "xorriso_timestamp.h"
+#ifndef Xorriso_timestamP
+#define Xorriso_timestamP "-none-given-"
+#endif
+
+/** The binary build timestamp is to be set externally by the compiler */
+#ifndef Xorriso_build_timestamP
+#define Xorriso_build_timestamP "-none-given-"
+#endif
+
+
+/* Because regex_t is mentioned in struct XorrisO */
+#ifdef Xorriso_with_regeX
+#include <regex.h>
+#endif /* Xorriso_with_regeX */
+
+
+#define Smem_malloC malloc
+#define Smem_freE free
+#define SfileadrL 4096
+
+/* <<< ??? */
+typedef int (*Cleanup_app_handler_T)();
+
+struct LinkiteM;
+
+/* maximum number of history lines to be reported with -status:long_history */
+#define Xorriso_status_history_maX 100
+
+/* <<< ??? */
+/* try to catch signals and ignore them during abort handling */
+#define Xorriso_abort_handler_defaulT (1|(2<<4))
+
+
+/** The list of startup file names */
+#define Xorriso_rc_nuM 4
+
+
+struct XorrisO { /* the global context of xorriso */
+
+ int libs_are_started;
+
+ /* source */
+ char progname[SfileadrL];
+ char initial_wdx[SfileadrL];
+ int no_rc;
+
+ /** List of startupfiles */
+ char rc_filenames[Xorriso_rc_nuM][SfileadrL];
+ int rc_filename_count;
+
+ char wdi[SfileadrL];
+ char wdx[SfileadrL];
+ int did_something_useful;
+
+ int add_plainly;
+
+ /* >>> put libisofs aspects here <<< */
+
+ int do_joliet;
+ int do_follow_pattern;
+ int do_follow_param;
+ int do_follow_links;
+ int follow_link_limit;
+ int do_follow_mount;
+ int do_global_uid;
+ uid_t global_uid;
+ int do_global_gid;
+ gid_t global_gid;
+ int do_global_mode;
+ mode_t global_dir_mode;
+ mode_t global_file_mode;
+
+ int do_overwrite; /* 0=off, 1=on, 2=nondir */
+ int do_reassure;  /* 0=off, 1=on, 2=tree */
+
+ char volid[33];
+ int volid_default;
+ char loaded_volid[33];
+
+ /* >>> put libburn/isoburn aspects here */
+
+ char indev[SfileadrL];
+ void *in_drive_handle;  /* interpreted only by xorrisoburn.c */
+ void *in_volset_handle; /* interpreted only by xorrisoburn.c */
+
+ int volset_change_pending; /* whether -commit would make sense */
+
+ char outdev[SfileadrL];
+ void *out_drive_handle; /* interpreted only by xorrisoburn.c */
+ int dev_fd_1; /* The fd which substitutes for /dev/fd/1 and is
+                     connected to externaly perveived stdout.
+                  */
+
+ int ban_stdio_write;
+ int do_dummy;
+ int do_close;
+ int speed;     /* in libburn units : 1000 bytes/second , 0 = Max, -1 = Min */
+ int fs;        /* fifo size in 2048 byte chunks : at most 1 GB */
+ int padding;   /* number of bytes to add after ISO 9660 image */
+
+ int keep_boot_image;
+ int patch_isolinux_image;
+
+
+ /* XORRISO options */
+ int allow_graft_points;
+
+ int dialog;
+
+
+ /* Pattern matching facility. It still carries legacy from scdbackup/askme.c
+    but is fully functional for xorriso.
+ */
+ int search_mode;
+ /* 0= start text
+    1= fgrep , 
+    2= regular expression
+    3= (eventually structured) shell parser expression
+    4= shell parser expression for leaf name
+ */
+
+ int structured_search;
+ /* 0= flat text search
+    1= '/' is a significant separator that cannot be matched by wildcards
+    ( 2= like 1 : but report only occurence in tree, no payload, no location )
+    ( 3= like 2 : but report first content level of matching directories )
+    4= actually not structured but unique find mode (with search_mode 4)
+ */
+
+ int do_iso_rr_pattern; /* 0=off, 1=on, 2=ls */
+ int do_disk_pattern;   /* 0=off, 1=on, 2=ls */
+
+ int temp_mem_limit;
+
+ int use_stdin; /* use raw stdin even if readline support is compiled */
+ int result_page_length;
+ int result_page_width;
+ char mark_text[SfileadrL]; /* ( stdout+stderr, M: ) */
+ int packet_output;
+ char logfile[4][SfileadrL];
+ int status_history_max; /* for -status long_history */
+
+ char report_about_text[20];
+ int report_about_severity;
+ int library_msg_direct_print;
+ char abort_on_text[20];
+ int abort_on_severity; /* A severity rank number as threshold */
+ int problem_status; /* Severity rank number. 0= no abort condition present */
+ char problem_status_text[20];
+
+ char return_with_text[20];
+ int return_with_severity;
+ int return_with_value;
+ int eternal_problem_status;
+ char eternal_problem_status_text[20];
+
+ /* temporary search facilities */
+#ifdef Xorriso_with_regeX
+ regex_t *re;
+ regmatch_t match[1]; 
+#endif /* Xorriso_with_regeX */
+ char **re_constants;
+ int re_count;
+ int re_fill;
+ char reg_expr[2*SfileadrL];
+
+ /* run state */
+ int run_state; /* 0=preparing , 1=writing image */
+ int is_dialog;
+ int bar_is_fresh;
+ char pending_option[SfileadrL]; /* eventual option entered at page prompt */
+ int request_to_abort; /* abort a single operation like -ls, not the program */
+ int request_not_to_ask; /* suppress reassure and pager */
+ double idle_time;
+ int re_failed_at; /* mismatch position with structured_search */
+ int prepended_wd;
+ double insert_count;
+ double insert_bytes;
+ double error_count; /* double will not roll over */
+
+ /* pacifiers */
+ double pacifier_interval;
+ double start_time;
+ double last_update_time;
+ /* optional global counters for brain reduced callback functions */
+ off_t pacifier_count;
+ off_t pacifier_total;
+
+ /* result (stdout, R: ) */
+ char result_line[5*SfileadrL];
+ int result_line_counter;
+ int result_page_counter;
+ int result_open_line_len;
+
+
+ /* info (stderr, I:) */
+ char info_text[10*SfileadrL];
+
+};
+
+
+int Xorriso_prepare_regex(struct XorrisO *xorriso, char *adr, int flag);
+
+int Xorriso_result(struct XorrisO *xorriso, int flag);
+
+int Xorriso_info(struct XorrisO *xorriso, int flag);
+
+int Xorriso_request_confirmation(struct XorrisO *xorriso, int flag);
+
+int Xorriso_prescan_args(struct XorrisO *xorriso, int argc, char **argv,
+                         int flag);
+
+int Xorriso_execute_option(struct XorrisO *xorriso, char *line, int flag);
+
+/* @return 0=match , else no match
+*/
+int Xorriso_regexec(struct XorrisO *xorriso, char *to_match, int *failed_at,
+                    int flag);
+
+int Xorriso_prepare_expansion_pattern(struct XorrisO *xorriso, char *pattern,
+                                      int flag);
+
+int Xorriso__mode_to_perms(mode_t st_mode, char perms[10], int flag);
+
+int Xorriso_much_too_long(struct XorrisO *xorriso, int len, int flag);
+
+int Xorriso_check_temp_mem_limit(struct XorrisO *xorriso, off_t mem, int flag);
+
+int Xorriso_eval_nonmatch(struct XorrisO *xorriso, char *pattern,
+                          int *nonconst_mismatches, off_t *mem, int flag);
+
+/* @param flag bit0= a match count !=1 is a SORRY event
+*/
+int Xorriso_check_matchcount(struct XorrisO *xorriso,
+                int count, int nonconst_mismatches, int num_patterns,
+                char **patterns, int flag);
+
+int Xorriso_no_pattern_memory(struct XorrisO *xorriso, off_t mem, int flag);
+
+int Xorriso_alloc_pattern_mem(struct XorrisO *xorriso, off_t mem,
+                              int count, char ***filev, int flag);
+
+/* @param flag bit0= count results rather than storing them
+   @return <=0 error , 1 is root (end processing) ,
+                       2 is not root (go on processing)
+*/
+int Xorriso_check_for_root_pattern(struct XorrisO *xorriso,
+              int *filec, char **filev, int count_limit, off_t *mem, int flag);
+
+/* @param flag bit0= prepend wd only if name does not begin by '/'
+               bit2= prepend wd (automatically done if wd[0]!=0)
+*/
+int Xorriso_make_abs_adr(struct XorrisO *xorriso, char *wd, char *name,
+                             char adr[], int flag);
+
+/* @param flag bit0= count result rather than storing it
+               bit1= unexpected change of number is a FATAL event
+*/
+int Xorriso_register_matched_adr(struct XorrisO *xorriso,
+                               char *adr, int count_limit,
+                               int *filec, char **filev, off_t *mem, int flag);
+
+int Xorriso_format_ls_l(struct XorrisO *xorriso, struct stat *stbuf, int flag);
+
+/* @param flag bit0= simple readlink(): no normalization, no multi-hop
+*/
+int Xorriso_resolve_link(struct XorrisO *xorriso,
+                     char *link_path, char result_path[SfileadrL], int flag);
+
+/* @param flag bit0= for Xorriso_msgs_submit: use pager
+*/
+int Xorriso_hop_link(struct XorrisO *xorriso, char *link_path,
+                   struct LinkiteM **link_stack, struct stat *stbuf, int flag);
+
+/* reg_expr should be twice as large as bourne_expr ( + 2 to be exact) */
+/* return: 2= bourne_expr is surely a constant */
+int Xorriso__bourne_to_reg(char bourne_expr[], char reg_expr[], int flag);
+
+int Xorriso_no_malloc_memory(struct XorrisO *xorriso, char **to_free,
+                             int flag);
+
+int Xorriso_pacifier_reset(struct XorrisO *xorriso, int flag);
+
+/* This call is to be issued by long running workers in short intervals.
+   It will check whether enough time has elapsed since the last pacifier
+   message and eventually issue an update message.
+   @param what_done  A sparse description of the action, preferrably in past 
+                     tense. E.g. "done" , "files added".
+   @param count The number of objects processed so far.
+                Is ignored if <=0.
+   @param todo  The number of objects to be done in total.
+                Is ignored if <=0.
+   @param current_object A string telling the object currently processed.
+                         Ignored if "".
+   @param flag  bit0= report unconditionally, no time check
+*/
+int Xorriso_pacifier_callback(struct XorrisO *xorriso, char *what_done,
+                              off_t count, off_t todo, char *current_object,
+                              int flag);
+
+int Sfile_str(char target[SfileadrL], char *source, int flag);
+
+double Sfile_microtime(int flag);
+
+int Sfile_add_to_path(char path[SfileadrL], char *addon, int flag);
+
+int Sfile_scale(double value, char *result, int siz, double thresh, int flag);
+
+int Sfile_destroy_argv(int *argc, char ***argv, int flag);
+
+char *Text_shellsafe(char *in_text, char *out_text, int flag);
+
+int Sort_argv(int argc, char **argv, int flag);
+
+struct DirseQ;
+
+int Dirseq_new(struct DirseQ **o, char *adr, int flag);
+
+int Dirseq_destroy(struct DirseQ **o, int flag);
+
+int Dirseq_next_adr(struct DirseQ *o, char reply[SfileadrL], int flag);
+
+
+int Linkitem_reset_stack(struct LinkiteM **o, struct LinkiteM *to, int flag);
+
+
+struct FindjoB;
+
+/* @return 0=no match , 1=match , <0 = error
+*/
+int Findjob_test(struct FindjoB *job, char *name, 
+                 struct stat *boss_stbuf, struct stat *stbuf,
+                 int depth, int flag);
+
+/* @return <0 error, >=0 see xorriso.c struct FindjoB.action
+*/
+int Findjob_get_action(struct FindjoB *o, int flag);
+
+/* @return <0 error, >=0 see xorriso.c struct FindjoB.action
+*/ 
+int Findjob_get_action_parms(struct FindjoB *o, char **target,
+                             uid_t *user, gid_t *group,
+                             mode_t *mode_and, mode_t *mode_or,
+                             int *type, time_t *date, struct FindjoB **subjob,
+                             int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_target(struct FindjoB *o, int action, char *target,
+                              int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_chgrp(struct FindjoB *o, gid_t group, int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_chmod(struct FindjoB *o,
+                             mode_t mode_and, mode_t mode_or, int flag);
+
+/* @param flag bit0= recursive
+*/
+int Findjob_set_action_ad(struct FindjoB *o, int type, time_t date, int flag);
+
+int Findjob_set_start_path(struct FindjoB *o, char *start_path, int flag);
+
+
+#endif /* Xorriso_private_includeD */
+

libisoburn/branches/ZeroOneZero-pl01/xorriso/xorriso_timestamp.h

@@ -0,0 +1 @@
+#define Xorriso_timestamP "2008.02.15.100001"

libisoburn/branches/ZeroOneZero-pl01/xorriso/xorrisoburn.h

@@ -0,0 +1,153 @@
+
+
+/* Adapter to libisoburn, libisofs and libburn for xorriso,
+   a command line oriented batch and dialog tool which creates, loads,
+   manipulates and burns ISO 9660 filesystem images.
+
+   Copyright 2007-2008 Thomas Schmitt, <scdbackup@gmx.net>
+
+   Provided under GPL version 2.
+
+   This file contains the inner isofs- and burn-library interface of xorriso.
+*/
+
+#ifndef Xorrisoburn_includeD
+#define Xorrisoburn_includeD yes
+
+struct XorrisO;
+struct FindjoB;
+
+/* The minimum version of libisoburn to be used with this version of xorriso
+*/
+#define xorriso_libisoburn_req_major  0
+#define xorriso_libisoburn_req_minor  1
+#define xorriso_libisoburn_req_micro  0
+
+int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
+
+/* @param flag bit0= global shutdown of libraries */
+int Xorriso_detach_libraries(struct XorrisO *xorriso, int flag);
+
+int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag);
+
+/* @param flag bit0=aquire as isoburn input drive
+               bit1=aquire as libburn output drive (as isoburn drive if bit0)
+   @return <=0 failure , 1=success , 2=neither readable or writeable
+*/
+int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag);
+
+int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag);
+
+int Xorriso_write_session(struct XorrisO *xorriso, int flag);
+
+/* @param flag bit0=graft in as empty directory, not as copy from disk
+   @return <=0 = error , 1 = added simple node , 2 = added directory
+*/
+int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path,
+                     int flag);
+
+int Xorriso__text_to_sev(char *severity_name, int *severity_number,int flag);
+
+/* @param flag bit0=report about output drive 
+               bit1=short report form
+*/
+int Xorriso_toc(struct XorrisO *xorriso, int flag);
+
+int Xorriso_show_devices(struct XorrisO *xorriso, int flag);
+
+int Xorriso_tell_media_space(struct XorrisO *xorriso,
+                             int *media_space, int *free_space, int flag);
+
+int Xorriso_blank_media(struct XorrisO *xorriso, int flag);
+
+int Xorriso_format_media(struct XorrisO *xorriso, int flag);
+
+/* @param boss_iter  Opaque internal handle. Use NULL outside xorrisoburn.c :
+               If not NULL then this is an iterator suitable for
+               iso_dir_iter_remove() which is then to be used instead
+               of iso_node_remove().
+   @param flag bit0= remove whole sub tree: rm -r
+               bit1= remove empty directory: rmdir
+               bit2= recursion: do not reassure in mode 2 "tree"
+               bit3= this is for overwriting and not for plain removal
+   @return   <=0 = error
+               1 = removed simple node
+               2 = removed directory or tree
+               3 = did not remove on user revocation
+*/
+int Xorriso_rmi(struct XorrisO *xorriso, void *boss_iter,
+                char *path, int flag);
+
+/* @param flag bit0= long format
+               bit1= do not print count of nodes
+               bit2= du format
+               bit3= print directories as themselves (ls -d)
+*/
+int Xorriso_ls_filev(struct XorrisO *xorriso, char *wd, 
+                     int filec, char **filev, off_t boss_mem, int flag);
+
+/* This function needs less buffer memory than Xorriso_ls_filev() but cannot
+   perform structured pattern matching.
+   @param flag bit0= long format
+               bit1= only check for directory existence
+               bit2= do not apply search pattern but accept any file
+*/
+int Xorriso_ls(struct XorrisO *xorriso, int flag);
+
+/* @param wd        Path to prepend in case img_path is not absolute
+   @param img_path  Absolute or relative path to be normalized
+   @param eff_path  returns resulting effective path.
+                    Must provide at least SfileadrL bytes of storage.
+   @param flag bit0= do not produce problem events (unless faulty path format)
+               bit1= work purely literally, do not use libisofs
+               bit2= (with bit1) this is an address in the disk world
+   @return -1 = faulty path format, 0 = not found ,
+            1 = found simple node , 2 = found directory
+*/
+int Xorriso_normalize_img_path(struct XorrisO *xorriso, char *wd,
+                               char *img_path, char eff_path[], int flag);
+
+int Xorriso_rename(struct XorrisO *xorriso, char *origin, char *dest,int flag);
+
+/* @param flag bit0= do not produce info message on success
+   @return 1=success, 0=was already directory, -1=was other type, -2=bad path
+*/
+int Xorriso_mkdir(struct XorrisO *xorriso, char *img_path, int flag);
+
+/* @param flag bit0= a match count !=1 is a SORRY event */
+int Xorriso_expand_pattern(struct XorrisO *xorriso,
+                           int num_patterns, char **patterns, int extra_filec,
+                           int *filec, char ***filev, off_t *mem, int flag);
+
+int Xorriso_set_st_mode(struct XorrisO *xorriso, char *path,
+                        mode_t mode_and, mode_t mode_or, int flag);
+
+int Xorriso_set_uid(struct XorrisO *xorriso, char *in_path, uid_t uid,
+                    int flag);
+
+int Xorriso_set_gid(struct XorrisO *xorriso, char *in_path, gid_t gid,
+                    int flag);
+
+/* @parm flag  bit0= atime, bit1= ctime, bit2= mtime, bit8=no auto ctime */
+int Xorriso_set_time(struct XorrisO *xorriso, char *in_path, time_t t,
+                    int flag);
+
+int Xorriso_findi(struct XorrisO *xorriso, struct FindjoB *job,
+                  void *dir_node_generic, char *dir_path,
+                  struct stat *dir_stbuf, int depth, int flag);
+
+/* @param flag bit0= do not mark image as changed */
+int Xorriso_set_volid(struct XorrisO *xorriso, char *volid, int flag);
+
+int Xorriso_get_volid(struct XorrisO *xorriso, char volid[33], int flag);
+
+int Xorriso_set_abort_severity(struct XorrisO *xorriso, int flag);
+
+int Xorriso_report_lib_versions(struct XorrisO *xorriso, int flag);
+
+/* @return 0= stbuf content is valid , -1 = path not found */
+int Xorriso_iso_lstat(struct XorrisO *xorriso, char *path, struct stat *stbuf,
+                      int flag);
+
+#endif /* Xorrisoburn_includeD */
+