libburnia/legacy
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Gave up adapter to old libisofs. Renaming libisoburn and xorriso dirs.

Browse Source
This commit is contained in:
Thomas Schmitt
2008-01-26 00:26:57 +00:00
parent 06f9faea54
commit 7229e2949c
35 changed files with 598 additions and 5585 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
libisoburn/trunk/xorriso/README Normal file
View File

@ -0,0 +1,143 @@
------------------------------------------------------------------------------
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.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 is the xorriso standalone tarball.
Prerequisites:
The tarball contains anything that is needed except libc and libpthread.
libreadline and the libreadline-dev headers will make dialog mode
more convenient, but are not mandatory.
Obtain xorriso-0.1.0.tar.gz, take it to a directory of your choice and do:
tar xzf xorriso-0.1.0.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...
------------------------------------------------------------------------------
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

1144
libisoburn/trunk/xorriso/changelog.txt Normal file
View File

File diff suppressed because it is too large Load Diff

211
libisoburn/trunk/xorriso/compare_file.c Normal file
View File

@ -0,0 +1,211 @@
/*
Compare two copies of a file object in as many aspects as i can imagine.
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, fd2, i;
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 */
while(1) {
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 %d bytes\n", adr1, 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 %d bytes\n", adr2, r2count);
differs= 1;
}
if(r2>r1) {
if(s1.st_size > r1count + r1)
printf("- %s : early EOF after %d bytes\n", adr1, r1count);
differs= 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_size==s2.st_size || s1.st_mtime==s2.st_mtime ?
"CONTENT":"content"),
(double) (diffcount + abs(r1count-r2count)), (double) first_diff);
differs= 1;
}
}
close(fd1);
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);
}

150
libisoburn/trunk/xorriso/compile_xorriso.sh Executable file
View File

@ -0,0 +1,150 @@
#!/bin/sh
# compile_xorriso.sh
# Copyright 2005 - 2007 Thomas Schmitt, scdbackup@gmx.net, GPL
# to be executed in a common parent of the directories given with
# $isofs $isoburn $burn
isofs=./nglibisofs-develop/src
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.'

93
libisoburn/trunk/xorriso/configure_ac.txt Normal file
View File

@ -0,0 +1,93 @@
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])
dnl A dummy demanded by libburn sources, but unused by xorriso
BURN_MAJOR_VERSION=0
BURN_MINOR_VERSION=0
BURN_MICRO_VERSION=0
AC_SUBST(BURN_MAJOR_VERSION)
AC_SUBST(BURN_MINOR_VERSION)
AC_SUBST(BURN_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>])
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

107
libisoburn/trunk/xorriso/convert_man_to_html.sh Executable file
View File

@ -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

9
libisoburn/trunk/xorriso/make_timestamp.sh Executable file
View File

@ -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

208
libisoburn/trunk/xorriso/make_xorriso_standalone.sh Executable file
View File

@ -0,0 +1,208 @@
#!/bin/sh
#
# Copyright 2008 Thomas Schmitt, scdbackup@gmx.net, GPL
#
# 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.
#
# To be executed in the parent of the *-develop directories.
#
# 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
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 \
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 compile_xorriso.sh for standalone
# nglibisofs
create_dir "$lone_dir"/libisofs
goto_dir "$current_dir"/nglibisofs-develop
copy_files src/*.[ch] "$lone_dir"/libisofs
# <<< obsoleted
if test 1 = 0
then
# 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
copy_files COPYING "$lone_dir"/COPYING
# 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

1396
libisoburn/trunk/xorriso/xorriso.1 Normal file
View File

File diff suppressed because it is too large Load Diff

9052
libisoburn/trunk/xorriso/xorriso.c Normal file
View File

File diff suppressed because it is too large Load Diff

394
libisoburn/trunk/xorriso/xorriso.h Normal file
View File

@ -0,0 +1,394 @@
/* 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 */
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 */
int Xorriso_option_blank(struct XorrisO *xorriso, char *mode, 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= do not aquire outdrive as new indrive */
int Xorriso_option_commit(struct XorrisO *xorriso, int flag);
/* Option -commit_eject */
int Xorriso_option_commit_eject(struct XorrisO *xorriso, int flag);
/* Option -cpr alias -cpri */
int Xorriso_option_cpri( struct XorrisO *xorriso, int argc, char **argv,
int *idx, int flag);
/* 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 */
int Xorriso_option_dev(struct XorrisO *xorriso, char *adr, int flag);
/* Option -devices */
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 */
int Xorriso_option_eject(struct XorrisO *xorriso, char *which, int flag);
/* Options -end , and -rollback_end */
/* @param flag bit0= discard pending changes */
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 -pathspecs */
int Xorriso_option_pathspecs(struct XorrisO *xorriso, char *mode, 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 -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 -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 -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 */
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 */

407
libisoburn/trunk/xorriso/xorriso_eng.html Normal file
View File

@ -0,0 +1,407 @@
<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.1</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-1.0.0</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>
</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 -dev /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 -dev /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 -dev /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, eject media.
</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 a program
run. It would write eventually pending changes to media, if that had not
already been done by -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 -eject all -end</B></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.1 :</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>

176
libisoburn/trunk/xorriso/xorriso_makefile_am.txt Normal file
View File

@ -0,0 +1,176 @@
pkgconfigdir=$(libdir)/pkgconfig
libincludedir=
lib_LTLIBRARIES =
## ========================================================================= ##
libinclude_HEADERS =
## ========================================================================= ##
noinst_PROGRAMS =
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.h \
xorriso_private.h \
xorriso/xorriso.c \
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
## ========================================================================= ##
# 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)

12
libisoburn/trunk/xorriso/xorriso_pc_in.txt Normal file
View File

@ -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:

341
libisoburn/trunk/xorriso/xorriso_private.h Normal file
View File

@ -0,0 +1,341 @@
/* 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
/* 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];
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 */
/* 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];
/* 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 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 */
/* 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 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 */

1
libisoburn/trunk/xorriso/xorriso_timestamp.h Normal file
View File

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

3247
libisoburn/trunk/xorriso/xorrisoburn.c Normal file
View File

File diff suppressed because it is too large Load Diff

139
libisoburn/trunk/xorriso/xorrisoburn.h Normal file
View File

@ -0,0 +1,139 @@
/* 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;
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);
#endif /* Xorrisoburn_includeD */