Compare commits
4 Commits
ZeroTwoEig
...
ZeroOneEig
| Author | SHA1 | Date | |
|---|---|---|---|
| ba767eb4bf | |||
| 442bc1c49d | |||
| b5292e6ade | |||
| cc38321820 |
52
Makefile.am
52
Makefile.am
@ -16,11 +16,9 @@ libisoburn_libisoburn_la_SOURCES = \
|
||||
libisoburn/isofs_wrap.c \
|
||||
libisoburn/libisoburn.h \
|
||||
version.h
|
||||
|
||||
libisoburn_libisoburn_la_LIBADD = \
|
||||
-lisofs \
|
||||
-lburn
|
||||
|
||||
-lburn
|
||||
libinclude_HEADERS = \
|
||||
libisoburn/libisoburn.h
|
||||
|
||||
@ -32,19 +30,6 @@ libinclude_HEADERS = \
|
||||
bin_PROGRAMS = \
|
||||
xorriso/xorriso
|
||||
|
||||
# This looks quite ugly with make install: xorriso.c is compiled twice again
|
||||
#
|
||||
# Trying to create a build timestamp file
|
||||
#
|
||||
# BUILT_SOURCES = xorriso/xorriso_buildstamp.h
|
||||
#
|
||||
# phony targets get rebuilt every time
|
||||
#
|
||||
# .PHONY: xorriso/xorriso_buildstamp.h
|
||||
# xorriso/xorriso_buildstamp.h:
|
||||
# date -u '+#define Xorriso_build_timestamP "%Y.%m.%d.%H%M%S"' >xorriso/xorriso_buildstamp.h
|
||||
# cat xorriso/xorriso_buildstamp.h
|
||||
|
||||
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)
|
||||
@ -54,32 +39,7 @@ xorriso_xorriso_SOURCES = \
|
||||
xorriso/xorriso.c \
|
||||
xorriso/xorrisoburn.h \
|
||||
xorriso/xorrisoburn.c \
|
||||
xorriso/xorriso_timestamp.h \
|
||||
xorriso/xorriso_buildstamp.h
|
||||
|
||||
|
||||
# Install symbolic links to the xorriso binary
|
||||
#
|
||||
install-exec-hook:
|
||||
if test -e "$(DESTDIR)$(bindir)"/xorrisofs ; then rm "$(DESTDIR)$(bindir)"/xorrisofs ; else echo ; fi
|
||||
ln -s xorriso "$(DESTDIR)$(bindir)"/xorrisofs
|
||||
if test -e "$(DESTDIR)$(bindir)"/osirrox ; then rm "$(DESTDIR)$(bindir)"/osirrox ; else echo ; fi
|
||||
ln -s xorriso "$(DESTDIR)$(bindir)"/osirrox
|
||||
if test -e "$(DESTDIR)$(bindir)"/xorrecord ; then rm "$(DESTDIR)$(bindir)"/xorrecord ; else echo ; fi
|
||||
ln -s xorriso "$(DESTDIR)$(bindir)"/xorrecord
|
||||
|
||||
|
||||
# Alternative to the disabled .PHONY above.
|
||||
# Trying to create a build timestamp file semi-manually: make buildstamped
|
||||
#
|
||||
buildstamp:
|
||||
date -u '+#define Xorriso_build_timestamP "%Y.%m.%d.%H%M%S"' >xorriso/xorriso_buildstamp.h
|
||||
cat xorriso/xorriso_buildstamp.h
|
||||
|
||||
# For now make buildstamped has to be performed explicitely.
|
||||
buildstamped: buildstamp
|
||||
make
|
||||
|
||||
xorriso/xorriso_timestamp.h
|
||||
|
||||
|
||||
## Build test applications
|
||||
@ -95,6 +55,13 @@ 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
|
||||
|
||||
|
||||
## ========================================================================= ##
|
||||
|
||||
@ -159,7 +126,6 @@ EXTRA_DIST = \
|
||||
COPYING \
|
||||
INSTALL \
|
||||
xorriso/changelog.txt \
|
||||
xorriso/xorriso_buildstamp_none.h \
|
||||
xorriso/README \
|
||||
$(man_MANS)
|
||||
|
||||
|
||||
29
README
29
README
@ -4,13 +4,13 @@
|
||||
libisoburn. By Vreixo Formoso <metalpain2002@yahoo.es>
|
||||
and Thomas Schmitt <scdbackup@gmx.net>
|
||||
Integrated sub project of libburnia-project.org.
|
||||
http://files.libburnia-project.org/releases/libisoburn-0.2.8.pl00.tar.gz
|
||||
http://files.libburnia-project.org/releases/libisoburn-0.1.8.pl00.tar.gz
|
||||
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/BD media supported
|
||||
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.
|
||||
|
||||
@ -26,18 +26,18 @@ By using this software you agree to the disclaimer at the end of this text:
|
||||
|
||||
Compilation, First Glimpse, Installation
|
||||
|
||||
Dynamic library and compile time header requirements for libisoburn-0.2.8 :
|
||||
- libburn.so.4 , version libburn-0.5.4 or higher
|
||||
- libisofs.so.6 , version libisofs-0.6.10 or higher
|
||||
Dynamic library and compile time header requirements for libisoburn-0.1.8 :
|
||||
- libburn.so.4 , version libburn-0.4.8 or higher
|
||||
- libisofs.so.6 , version libisofs-0.6.6 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.2.8.pl00.tar.gz, take it to a directory of your choice
|
||||
Obtain libisoburn-0.1.8.pl00.tar.gz, take it to a directory of your choice
|
||||
and do:
|
||||
|
||||
tar xzf libisoburn-0.2.8.pl00.tar.gz
|
||||
cd libisoburn-0.2.8
|
||||
tar xzf libisoburn-0.1.8.pl00.tar.gz
|
||||
cd libisoburn-0.1.8
|
||||
|
||||
Within that directory execute:
|
||||
|
||||
@ -57,7 +57,7 @@ as well as
|
||||
|
||||
xorriso
|
||||
|
||||
libisoburn comes with a command line and dialog application named 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 standalone tarball as first
|
||||
preference for statically linked xorriso installation.
|
||||
@ -67,17 +67,6 @@ xorriso binary depending on libburn.so, libisofs.so, libisoburn.so.
|
||||
After installation documentation is available via
|
||||
man xorriso
|
||||
|
||||
Several alias links point to the xorriso binary:
|
||||
xorrisofs starts xorriso with -as mkisofs emulation already enabled
|
||||
xorrecord starts xorriso with -as cdrecord emulation already enabled
|
||||
osirrox starts with -osirrox image-to-disk copying already enabled
|
||||
|
||||
By default xorriso will depend on libreadline if the readline-dev headers
|
||||
are present. This dependcy can be avoided by running
|
||||
./configure --prefix=/usr --disable-libreadline
|
||||
make clean ; make
|
||||
Never omit the "make clean" command after switching libreadline enabling.
|
||||
|
||||
|
||||
Drives and Disk File Objects
|
||||
|
||||
|
||||
37
configure.ac
37
configure.ac
@ -1,4 +1,4 @@
|
||||
AC_INIT([libisoburn], [0.2.8], [http://libburnia-project.org])
|
||||
AC_INIT([libisoburn], [0.1.8], [http://libburnia-project.org])
|
||||
AC_PREREQ([2.50])
|
||||
dnl AC_CONFIG_HEADER([config.h])
|
||||
|
||||
@ -20,7 +20,7 @@ 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=2
|
||||
ISOBURN_MINOR_VERSION=1
|
||||
ISOBURN_MICRO_VERSION=8
|
||||
dnl ISOBURN_VERSION=$ISOBURN_MAJOR_VERSION.$ISOBURN_MINOR_VERSION.$ISOBURN_MICRO_VERSION
|
||||
|
||||
@ -33,16 +33,15 @@ dnl Libtool versioning
|
||||
dnl Generate libisoburn.so.1.x.y
|
||||
dnl SONAME will become LT_CURRENT - LT_AGE
|
||||
dnl
|
||||
dnl ts A80920
|
||||
dnl This is the release version 0.2.8 = libisoburn.so.1.17.0
|
||||
dnl ### This is the development version after above stable release
|
||||
dnl LT_CURRENT++, LT_AGE++ have not happened happened yet.
|
||||
dnl ### LT_CURRENT++, LT_AGE++ has happened meanwhile.
|
||||
dnl ts A80602
|
||||
dnl This is the release version 0.1.8 = libisoburn.so.1.7.0
|
||||
dnl ## This is the development version after above stable release
|
||||
dnl ## LT_CURRENT++, LT_AGE++ have not happened happened yet.
|
||||
dnl
|
||||
dnl SONAME = 18 - 17 = 1 . Library name = libisoburn.so.1.17.0
|
||||
dnl SONAME = 8 - 7 = 1 . Library name = libburn.so.1.7.0
|
||||
LT_RELEASE=$ISOBURN_MAJOR_VERSION.$ISOBURN_MINOR_VERSION
|
||||
LT_CURRENT=18
|
||||
LT_AGE=17
|
||||
LT_CURRENT=8
|
||||
LT_AGE=7
|
||||
LT_REVISION=0
|
||||
LT_CURRENT_MINUS_AGE=`expr $LT_CURRENT - $LT_AGE`
|
||||
|
||||
@ -86,28 +85,22 @@ AC_SUBST(ARCH)
|
||||
AC_SUBST(LIBBURN_ARCH_LIBS)
|
||||
|
||||
|
||||
AC_ARG_ENABLE(libreadline,
|
||||
[ --enable-libreadline Enable use of libreadline by xorriso, default=yes],
|
||||
, enable_libreadline=yes)
|
||||
if test x$enable_libreadline = xyes; then
|
||||
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"
|
||||
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= )
|
||||
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= )
|
||||
else
|
||||
READLINE_DEF=
|
||||
fi
|
||||
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.5.4
|
||||
LIBISOFS_REQUIRED=0.6.10
|
||||
LIBBURN_REQUIRED=0.4.8
|
||||
LIBISOFS_REQUIRED=0.6.6
|
||||
PKG_CHECK_MODULES(LIBBURN, libburn-1 >= $LIBBURN_REQUIRED)
|
||||
PKG_CHECK_MODULES(LIBISOFS, libisofs-1 >= $LIBISOFS_REQUIRED)
|
||||
|
||||
|
||||
@ -477,7 +477,7 @@ WARN_LOGFILE =
|
||||
# directories like "/usr/src/myproject". Separate the files or directories
|
||||
# with spaces.
|
||||
|
||||
INPUT = libisoburn \
|
||||
INPUT = libburn \
|
||||
doc \
|
||||
test
|
||||
|
||||
@ -495,7 +495,9 @@ INPUT_ENCODING = UTF-8
|
||||
# *.c *.cc *.cxx *.cpp *.c++ *.java *.ii *.ixx *.ipp *.i++ *.inl *.h *.hh *.hxx
|
||||
# *.hpp *.h++ *.idl *.odl *.cs *.php *.php3 *.inc *.m *.mm *.py
|
||||
|
||||
FILE_PATTERNS =
|
||||
FILE_PATTERNS = libburn.h \
|
||||
comments \
|
||||
libburner.c
|
||||
|
||||
# The RECURSIVE tag can be used to turn specify whether or not subdirectories
|
||||
# should be searched for input files as well. Possible values are YES and NO.
|
||||
|
||||
@ -23,7 +23,6 @@
|
||||
#include <stdlib.h>
|
||||
#include <sys/stat.h>
|
||||
#include <fcntl.h>
|
||||
#include <time.h>
|
||||
|
||||
|
||||
#ifndef Xorriso_standalonE
|
||||
@ -39,6 +38,9 @@
|
||||
|
||||
#endif /* Xorriso_standalonE */
|
||||
|
||||
/* <<< remove macro and alternative outdated code */
|
||||
#define Libisoburn_on__libburn_after_0_4_2 yes
|
||||
|
||||
|
||||
#include "libisoburn.h"
|
||||
#include "isoburn.h"
|
||||
@ -47,18 +49,8 @@
|
||||
/* The global list of isoburn objects. Usually there is only one. */
|
||||
extern struct isoburn *isoburn_list_start; /* in isoburn.c */
|
||||
|
||||
/* Default values for application provided msgs_submit methods.
|
||||
To be attached to newly aquired drives.
|
||||
Storage location is isoburn.c
|
||||
*/
|
||||
extern int (*libisoburn_default_msgs_submit)
|
||||
(void *handle, int error_code, char msg_text[],
|
||||
int os_errno, char severity[], int flag);
|
||||
extern void *libisoburn_default_msgs_submit_handle;
|
||||
extern int libisoburn_default_msgs_submit_flag;
|
||||
|
||||
|
||||
static int isoburn_emulate_toc(struct burn_drive *d, int flag);
|
||||
int isoburn_emulate_toc(struct burn_drive *d, int flag);
|
||||
|
||||
|
||||
int isoburn_initialize(char msg[1024], int flag)
|
||||
@ -227,18 +219,6 @@ int isoburn_libburn_req(int *major, int *minor, int *micro)
|
||||
}
|
||||
|
||||
|
||||
int isoburn_set_msgs_submit(int (*msgs_submit)(void *handle, int error_code,
|
||||
char msg_text[], int os_errno,
|
||||
char severity[], int flag),
|
||||
void *submit_handle, int submit_flag, int flag)
|
||||
{
|
||||
libisoburn_default_msgs_submit= msgs_submit;
|
||||
libisoburn_default_msgs_submit_handle= submit_handle;
|
||||
libisoburn_default_msgs_submit_flag= submit_flag;
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
int isoburn_is_intermediate_dvd_rw(struct burn_drive *d, int flag)
|
||||
{
|
||||
int profile, ret= 0, format_status, num_formats;
|
||||
@ -263,7 +243,6 @@ int isoburn_is_intermediate_dvd_rw(struct burn_drive *d, int flag)
|
||||
@param flag bit0= pretent blank on overwriteable media
|
||||
bit3= if the drive reports a -ROM profile then try to read
|
||||
table of content by scanning for ISO image headers.
|
||||
bit4= do not emulate TOC on overwriteable media
|
||||
*/
|
||||
static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
|
||||
int flag)
|
||||
@ -286,9 +265,6 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
|
||||
if(ret<=0)
|
||||
goto ex;
|
||||
(*o)->drive= d;
|
||||
(*o)->msgs_submit= libisoburn_default_msgs_submit;
|
||||
(*o)->msgs_submit_handle= libisoburn_default_msgs_submit_handle;
|
||||
(*o)->msgs_submit_flag= libisoburn_default_msgs_submit_flag;
|
||||
|
||||
#ifdef Hardcoded_cd_rW
|
||||
/* <<< A70929 : hardcoded CD-RW with fabricated -msinfo */
|
||||
@ -313,13 +289,11 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
|
||||
(*o)->emulation_mode= -1;
|
||||
goto ex;
|
||||
}
|
||||
if(!(flag & 16)) {
|
||||
/* try to read emulated toc */
|
||||
ret= isoburn_emulate_toc(d, 0);
|
||||
if(ret<0) {
|
||||
(*o)->emulation_mode= -1;
|
||||
goto ex;
|
||||
}
|
||||
/* try to read emulated toc */
|
||||
ret= isoburn_emulate_toc(d, 0);
|
||||
if(ret<0) {
|
||||
(*o)->emulation_mode= -1;
|
||||
goto ex;
|
||||
}
|
||||
}
|
||||
|
||||
@ -329,13 +303,9 @@ static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
|
||||
|
||||
if(readonly) {
|
||||
/* This might be overwriteable media in a -ROM drive */
|
||||
if((flag & 16)) {
|
||||
ret= 0;
|
||||
} else {
|
||||
ret= isoburn_emulate_toc(d, 1);
|
||||
if(ret<0)
|
||||
goto ex;
|
||||
}
|
||||
ret= isoburn_emulate_toc(d, 1);
|
||||
if(ret<0)
|
||||
goto ex;
|
||||
if(ret==0 && profile !=0x08 && (flag&8)) {
|
||||
/* This might also be multi-session media which do not
|
||||
get shown with a decent TOC.
|
||||
@ -380,38 +350,29 @@ ex:
|
||||
table of content by scanning for ISO image headers.
|
||||
(depending on media type and drive state this might
|
||||
help or it might make the resulting toc even worse)
|
||||
bit4= do not emulate TOC on overwriteable media
|
||||
*/
|
||||
int isoburn_drive_aquire(struct burn_drive_info *drive_infos[],
|
||||
char *adr, int flag)
|
||||
{
|
||||
int ret, drive_grabbed= 0;
|
||||
struct isoburn *o= NULL;
|
||||
|
||||
#ifndef NIX
|
||||
|
||||
/* <<< should be obsolete by new drive addressing of libburn-0.5.2 */
|
||||
/* >>> but helps with kernel 2.4 to use /dev/sr */
|
||||
|
||||
int conv_ret;
|
||||
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)
|
||||
strcpy(libburn_drive_adr, 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, flag&1);
|
||||
|
||||
#else
|
||||
|
||||
ret= burn_drive_scan_and_grab(drive_infos, adr, flag & 1);
|
||||
|
||||
#endif /* ! NIX */
|
||||
|
||||
if(ret<=0)
|
||||
goto ex;
|
||||
drive_grabbed= 1;
|
||||
ret= isoburn_welcome_media(&o, (*drive_infos)[0].drive,
|
||||
(flag & 24) | !!(flag&2));
|
||||
(flag&8) | !!(flag&2));
|
||||
if(ret<=0)
|
||||
goto ex;
|
||||
|
||||
@ -474,8 +435,8 @@ int isoburn_find_emulator(struct isoburn **pt,
|
||||
if(ret<=0)
|
||||
return(0);
|
||||
if((*pt)->emulation_mode==-1) {
|
||||
isoburn_msgs_submit(*pt, 0x00060000,
|
||||
"Unsuitable drive and media state", 0, "FAILURE", 0);
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Unsuitable drive and media state", 0, "FAILURE", NULL);
|
||||
return(-1);
|
||||
}
|
||||
if((*pt)->emulation_mode==0)
|
||||
@ -593,8 +554,8 @@ int isoburn_disc_get_msc1(struct burn_drive *d, int *start_lba)
|
||||
|
||||
if(isoburn_disc_get_status(d)!=BURN_DISC_APPENDABLE &&
|
||||
isoburn_disc_get_status(d)!=BURN_DISC_FULL) {
|
||||
isoburn_msgs_submit(NULL, 0x00060000,
|
||||
"Media contains no recognizable data", 0, "SORRY", 0);
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Media contains no recognizable data", 0, "SORRY",NULL);
|
||||
return(0);
|
||||
}
|
||||
ret= isoburn_find_emulator(&o, d, 0);
|
||||
@ -641,23 +602,6 @@ int isoburn_disc_track_lba_nwa(struct burn_drive *d,
|
||||
}
|
||||
|
||||
|
||||
int isoburn_get_msc2(struct isoburn *o,
|
||||
struct burn_write_opts *opts, int *msc2, int flag)
|
||||
{
|
||||
int ret, lba, nwa;
|
||||
|
||||
if(o->fabricated_msc2>=0)
|
||||
*msc2= o->fabricated_msc2;
|
||||
else {
|
||||
ret= isoburn_disc_track_lba_nwa(o->drive, opts, 0, &lba, &nwa);
|
||||
if(ret<=0)
|
||||
return(ret);
|
||||
*msc2= nwa;
|
||||
}
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
|
||||
{
|
||||
int ret;
|
||||
@ -697,10 +641,10 @@ void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
|
||||
*/
|
||||
sprintf(msg,
|
||||
"DVD-RW insufficiently formatted. (Intermediate State, size unknown)");
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "FAILURE", 0);
|
||||
burn_msgs_submit(0x00060000, msg, 0, "FAILURE", NULL);
|
||||
sprintf(msg,
|
||||
"It might help to first deformat it and then format it again");
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "HINT", 0);
|
||||
burn_msgs_submit(0x00060000, msg, 0, "HINT", NULL);
|
||||
burn_drive_cancel(drive); /* mark run as failure */
|
||||
return;
|
||||
}
|
||||
@ -714,7 +658,7 @@ void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
|
||||
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);
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "FAILURE", 0);
|
||||
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() */
|
||||
@ -726,7 +670,7 @@ void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
|
||||
sprintf(msg, "Write_type = %s\n",
|
||||
(write_type == BURN_WRITE_SAO ? "SAO" :
|
||||
(write_type == BURN_WRITE_TAO ? "TAO" : reasons)));
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "DEBUG", 0);
|
||||
burn_msgs_submit(0x00060000, msg, 0, "DEBUG", NULL);
|
||||
|
||||
#ifdef Hardcoded_cd_rW
|
||||
/* <<< A70929 : hardcoded CD-RW with fabricated -msinfo */
|
||||
@ -804,9 +748,9 @@ int isoburn_set_start_byte(struct isoburn *o, off_t value, int flag)
|
||||
if(ret<=0)
|
||||
goto ex;
|
||||
if(!caps->start_adr) {
|
||||
isoburn_msgs_submit(o, 0x00060000,
|
||||
"Cannot set start byte address with this type of media",
|
||||
0, "FAILURE", 0);
|
||||
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;
|
||||
@ -904,6 +848,34 @@ int isoburn_get_fifo_status(struct burn_drive *d, int *size, int *free_bytes,
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* >>> todo: throw out the copies of libdax_msgs entrails */
|
||||
|
||||
#ifndef Libisoburn_on__libburn_after_0_4_2
|
||||
|
||||
/* <<< 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_ERRFILE 0x08000000
|
||||
#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
|
||||
|
||||
#endif /* ! Libisoburn_on__libburn_after_0_4_2 */
|
||||
|
||||
|
||||
/* @param flag bit0= -reserved-
|
||||
bit1= this is a libburn severity
|
||||
*/
|
||||
@ -912,11 +884,53 @@ int isoburn__sev_to_text(int severity, char **severity_name,
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret= iso_sev_to_text(severity, severity_name);
|
||||
if(ret>0)
|
||||
return(ret);
|
||||
ret= burn_sev_to_text(severity, severity_name, 0);
|
||||
return(ret);
|
||||
ret= iso_sev_to_text(severity, severity_name);
|
||||
if(ret>0)
|
||||
return(ret);
|
||||
#ifdef Libisoburn_on__libburn_after_0_4_2
|
||||
ret= burn_sev_to_text(severity, severity_name, 0);
|
||||
return(ret);
|
||||
#else
|
||||
|
||||
if(flag&1) {
|
||||
*severity_name= "NEVER\nABORT\nFATAL\nFAILURE\nSORRY\nWARNING\nHINT\nNOTE\nUPDATE\nDEBUG\nERRFILE\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_ERRFILE)
|
||||
*severity_name= "ERRFILE";
|
||||
else if(severity>=LIBDAX_MSGS_SEV_ALL)
|
||||
*severity_name= "ALL";
|
||||
else {
|
||||
*severity_name= "";
|
||||
return(0);
|
||||
}
|
||||
return(1);
|
||||
|
||||
#endif /* ! Libisoburn_on__libburn_after_0_4_2 */
|
||||
|
||||
}
|
||||
|
||||
|
||||
@ -924,10 +938,21 @@ int isoburn__text_to_sev(char *severity_name, int *severity_number, int flag)
|
||||
{
|
||||
int ret= 1;
|
||||
|
||||
ret= iso_text_to_sev(severity_name, severity_number);
|
||||
if(ret>0)
|
||||
return(ret);
|
||||
ret= burn_text_to_sev(severity_name, severity_number, 0);
|
||||
ret= iso_text_to_sev(severity_name, severity_number);
|
||||
if(ret>0)
|
||||
return(ret);
|
||||
|
||||
#ifndef Libisoburn_on__libburn_after_0_4_2
|
||||
if(severity_name[0]==0)
|
||||
*severity_number= 0;
|
||||
else if(strcmp(severity_name, "MISHAP")==0)
|
||||
*severity_number= LIBDAX_MSGS_SEV_MISHAP;
|
||||
else if(strcmp(severity_name, "ERRFILE")==0)
|
||||
*severity_number= LIBDAX_MSGS_SEV_ERRFILE;
|
||||
else
|
||||
#endif /* ! Libisoburn_on__libburn_after_0_4_2 */
|
||||
|
||||
ret= burn_text_to_sev(severity_name, severity_number, 0);
|
||||
return(ret);
|
||||
}
|
||||
|
||||
@ -958,8 +983,7 @@ int isoburn_report_iso_error(int iso_error_code, char msg_text[], int os_errno,
|
||||
|
||||
/* @param flag bit0-7: info return mode
|
||||
0= do not return anything in info (do not even touch it)
|
||||
1= copy volume id to info (info needs 33 bytes)
|
||||
2= do not touch info (caller will copy 64 kB header to it)
|
||||
1= return volume id
|
||||
bit14= -reserved -
|
||||
bit15= -reserved-
|
||||
@return 1 seems to be a valid ISO image , 0 format not recognized, <0 error
|
||||
@ -988,12 +1012,10 @@ int isoburn_read_iso_head_parse(struct burn_drive *d, unsigned char *data,
|
||||
break;
|
||||
else
|
||||
info[i]= 0;
|
||||
} else if(info_mode==2) {
|
||||
;
|
||||
} else {
|
||||
isoburn_msgs_submit(NULL, 0x00060000,
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Program error: Unknown info mode with isoburn_read_iso_head()",
|
||||
0, "FATAL", 0);
|
||||
0, "FATAL", NULL);
|
||||
return(-1);
|
||||
}
|
||||
return(1);
|
||||
@ -1003,9 +1025,7 @@ int isoburn_read_iso_head_parse(struct burn_drive *d, unsigned char *data,
|
||||
/* API
|
||||
@param flag bit0-7: info return mode
|
||||
0= do not return anything in info (do not even touch it)
|
||||
1= copy volume id to info (info needs 33 bytes)
|
||||
2= copy 64 kB header to info (needs 65536 bytes)
|
||||
bit13= do not read head from media but use first 64 kB from info
|
||||
1= return volume id
|
||||
bit14= check both half buffers (not only second)
|
||||
return 2 if found in first block
|
||||
bit15= return-1 on read error
|
||||
@ -1016,59 +1036,29 @@ int isoburn_read_iso_head(struct burn_drive *d, int lba,
|
||||
int *image_blocks, char *info, int flag)
|
||||
{
|
||||
unsigned char buffer[64*1024];
|
||||
int ret, info_mode;
|
||||
int ret;
|
||||
off_t data_count;
|
||||
|
||||
info_mode= flag&255;
|
||||
*image_blocks= 0;
|
||||
if(flag&(1<<13)) {
|
||||
memcpy(buffer, info, 64*1024);
|
||||
} else {
|
||||
ret = burn_read_data(d, ((off_t) lba) * (off_t) 2048, (char *) buffer,
|
||||
ret = burn_read_data(d, ((off_t) lba) * (off_t) 2048, (char *) buffer,
|
||||
(off_t) 64*1024, &data_count, 2); /* no error messages */
|
||||
if(ret<=0)
|
||||
return(-1*!!(flag&(1<<15)));
|
||||
if(info_mode==2)
|
||||
memcpy(info, buffer, 64*1024);
|
||||
}
|
||||
if(ret<=0)
|
||||
return(-1*!!(flag&(1<<15)));
|
||||
|
||||
if(flag&(1<<14)) {
|
||||
ret= isoburn_read_iso_head_parse(d, buffer, image_blocks, info, info_mode);
|
||||
ret= isoburn_read_iso_head_parse(d, buffer, image_blocks, info,
|
||||
flag&255);
|
||||
if(ret<0)
|
||||
return(ret);
|
||||
if(ret>0)
|
||||
return(2);
|
||||
}
|
||||
ret= isoburn_read_iso_head_parse(d, buffer+32*1024, image_blocks, info,
|
||||
info_mode);
|
||||
flag&255);
|
||||
return(ret);
|
||||
}
|
||||
|
||||
|
||||
int isoburn_make_toc_entry(struct isoburn *o, int *session_count, int lba,
|
||||
int track_blocks, int flag)
|
||||
{
|
||||
int ret;
|
||||
struct isoburn_toc_entry *item;
|
||||
|
||||
ret= isoburn_toc_entry_new(&item, o->toc, 0);
|
||||
if(ret<=0) {
|
||||
isoburn_msgs_submit(o, 0x00060000,
|
||||
"Not enough memory for emulated TOC entry object",
|
||||
0, "FATAL", 0);
|
||||
return(-1);
|
||||
}
|
||||
if(o->toc==NULL)
|
||||
o->toc= item;
|
||||
(*session_count)++;
|
||||
item->session= *session_count;
|
||||
item->track_no= *session_count;
|
||||
item->start_lba= lba;
|
||||
item->track_blocks= track_blocks;
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
/* @param flag bit0= allow unemulated media
|
||||
bit1= free scanning without enclosing LBA-0-header
|
||||
@return -1 severe error, 0= no neat header chain, 1= credible chain read
|
||||
@ -1076,11 +1066,10 @@ int isoburn_make_toc_entry(struct isoburn *o, int *session_count, int lba,
|
||||
int isoburn_emulate_toc(struct burn_drive *d, int flag)
|
||||
{
|
||||
int ret, image_size= 0, lba, track_blocks, session_count= 0, read_flag= 0;
|
||||
int scan_start= 0, scan_count= 0, probe_minus_16= 0, growisofs_nwa;
|
||||
int with_enclosure= 0;
|
||||
int scan_start= 0;
|
||||
struct isoburn *o;
|
||||
char msg[160], size_text[80], *sev;
|
||||
time_t start_time, last_pacifier, now;
|
||||
struct isoburn_toc_entry *item;
|
||||
char msg[160];
|
||||
|
||||
/* is the media emulated multi-session ? */
|
||||
ret= isoburn_find_emulator(&o, d, 0);
|
||||
@ -1091,45 +1080,17 @@ int isoburn_emulate_toc(struct burn_drive *d, int flag)
|
||||
if(o->emulation_mode<=0 && !(flag&1))
|
||||
return(0);
|
||||
|
||||
start_time= last_pacifier= time(NULL);
|
||||
lba= 0;
|
||||
if(!(flag&2)) {
|
||||
ret= isoburn_read_iso_head(d, lba, &image_size, NULL, 0);
|
||||
if(ret<=0)
|
||||
{ret= 0; goto failure;}
|
||||
lba= Libisoburn_overwriteable_starT;
|
||||
with_enclosure= 1;
|
||||
}
|
||||
while(lba<image_size || (flag&2)) {
|
||||
now= time(NULL);
|
||||
if(now - last_pacifier >= 5) {
|
||||
last_pacifier= now;
|
||||
if(scan_count>=10*512)
|
||||
sprintf(size_text, "%.f MB", ((double) scan_count) / 512.0);
|
||||
else
|
||||
sprintf(size_text, "%.f kB", 2 * (double) scan_count);
|
||||
sprintf(msg, "Found %d ISO sessions by scanning %s in %.f seconds",
|
||||
session_count, size_text, (double) (now - start_time));
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "UPDATE", 0);
|
||||
}
|
||||
read_flag= 0;
|
||||
if(flag&2)
|
||||
read_flag|= (1<<15)|((session_count>0)<<14);
|
||||
else {
|
||||
|
||||
/* growisofs aligns to 16 rather than 32. Overwriteable TOC emulation
|
||||
relies on not accidentially seeing inter-session trash data.
|
||||
But one can safely access 16 blocks earlier because a xorriso header
|
||||
would have overwritten with the unused 16 blocks at its start.
|
||||
If libisoburn alignment would increase, then this would not be
|
||||
possible any more.
|
||||
*/
|
||||
|
||||
if(probe_minus_16)
|
||||
read_flag|= (1<<14);
|
||||
probe_minus_16= 0;
|
||||
}
|
||||
|
||||
read_flag= (1<<15)|((session_count>0)<<14);
|
||||
ret= isoburn_read_iso_head(d, lba, &track_blocks, NULL, read_flag);
|
||||
if(ret<=0) {
|
||||
if(session_count>0) {
|
||||
@ -1137,7 +1098,6 @@ int isoburn_emulate_toc(struct burn_drive *d, int flag)
|
||||
if(ret==0) {
|
||||
/* try at next 64 k block (check both 32 k halves) */
|
||||
lba+= 32;
|
||||
scan_count+= 32;
|
||||
if(lba-scan_start <= Libisoburn_toc_scan_max_gaP)
|
||||
continue;
|
||||
}
|
||||
@ -1146,56 +1106,38 @@ int isoburn_emulate_toc(struct burn_drive *d, int flag)
|
||||
sprintf(msg,
|
||||
"Chain of ISO session headers broken at #%d, LBA %ds",
|
||||
session_count+1, lba);
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "WARNING", 0);
|
||||
|
||||
if(with_enclosure) {
|
||||
ret= isoburn_make_toc_entry(o, &session_count, 0, image_size, 0);
|
||||
if(ret<=0)
|
||||
goto failure;
|
||||
}
|
||||
break; /* do not return failure */
|
||||
|
||||
burn_msgs_submit(0x00060000, msg, 0, "WARNING", NULL);
|
||||
}
|
||||
{ret= 0; goto failure;}
|
||||
}
|
||||
if(ret==2) /* ISO header was found in first half block */
|
||||
lba-= 16;
|
||||
ret= isoburn_toc_entry_new(&item, o->toc, 0);
|
||||
if(ret<=0) {
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Not enough memory for emulated TOC entry object",
|
||||
0, "FATAL", NULL);
|
||||
ret= -1; goto failure;
|
||||
}
|
||||
if(o->toc==NULL)
|
||||
o->toc= item;
|
||||
session_count++;
|
||||
item->session= session_count;
|
||||
item->track_no= session_count;
|
||||
item->start_lba= lba;
|
||||
item->track_blocks= track_blocks;
|
||||
|
||||
ret= isoburn_make_toc_entry(o, &session_count, lba, track_blocks, 0);
|
||||
if(ret<=0)
|
||||
goto failure;
|
||||
lba+= track_blocks;
|
||||
scan_count+= 32;
|
||||
|
||||
/* growisofs aligns to 16 rather than 32 */
|
||||
growisofs_nwa= lba;
|
||||
if(growisofs_nwa % 16)
|
||||
growisofs_nwa+= 16 - (growisofs_nwa % 16);
|
||||
if(lba % Libisoburn_nwa_alignemenT)
|
||||
lba+= Libisoburn_nwa_alignemenT - (lba % Libisoburn_nwa_alignemenT);
|
||||
scan_start= lba;
|
||||
if(lba - growisofs_nwa == 16)
|
||||
probe_minus_16= 1;
|
||||
}
|
||||
if(last_pacifier != start_time)
|
||||
sev= "UPDATE";
|
||||
else
|
||||
sev= "DEBUG";
|
||||
now= time(NULL);
|
||||
if(scan_count>=10*512)
|
||||
sprintf(size_text, "%.f MB", ((double) scan_count) / 512.0);
|
||||
else
|
||||
sprintf(size_text, "%.f kB", 2 * (double) scan_count);
|
||||
sprintf(msg, "Found %d ISO sessions by scanning %s in %.f seconds",
|
||||
session_count, size_text, (double) (now - start_time));
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, sev, 0);
|
||||
sprintf(msg,
|
||||
"Chain of ISO session headers yielded %d sessions", session_count);
|
||||
burn_msgs_submit(0x00060000, msg, 0, "DEBUG", NULL);
|
||||
return(1);
|
||||
failure:;
|
||||
isoburn_toc_entry_destroy(&(o->toc), 1);
|
||||
if(with_enclosure && o->emulation_mode == 1) {
|
||||
session_count= 0;
|
||||
ret= isoburn_make_toc_entry(o, &session_count, 0, image_size, 0);
|
||||
}
|
||||
return(ret);
|
||||
}
|
||||
|
||||
@ -1340,31 +1282,15 @@ failure:;
|
||||
int isoburn_toc_disc_get_sectors(struct isoburn_toc_disc *disc)
|
||||
{
|
||||
struct isoburn_toc_entry *t;
|
||||
int ret= 0, num_sessions, num_tracks;
|
||||
struct burn_session **sessions;
|
||||
struct burn_track **tracks;
|
||||
struct burn_toc_entry entry;
|
||||
int ret= 0;
|
||||
|
||||
if(disc==NULL)
|
||||
return(0);
|
||||
if(disc->toc!=NULL) {
|
||||
for(t= disc->toc; t!=NULL; t= t->next)
|
||||
ret= t->start_lba + t->track_blocks;
|
||||
} else if(disc->disc!=NULL) {
|
||||
sessions= burn_disc_get_sessions(disc->disc, &num_sessions);
|
||||
if(num_sessions > 0) {
|
||||
tracks = burn_session_get_tracks(sessions[num_sessions - 1],
|
||||
&num_tracks);
|
||||
if(num_tracks > 0) {
|
||||
burn_track_get_entry(tracks[num_tracks - 1], &entry);
|
||||
if(entry.extensions_valid & 1)
|
||||
ret= entry.start_lba + entry.track_blocks;
|
||||
}
|
||||
}
|
||||
/*
|
||||
} else if(disc->disc!=NULL)
|
||||
ret= burn_disc_get_sectors(disc->disc);
|
||||
*/
|
||||
}
|
||||
return(ret);
|
||||
}
|
||||
|
||||
@ -1489,27 +1415,6 @@ int isoburn_get_track_lba(struct isoburn_toc_track *track, int *lba, int flag)
|
||||
}
|
||||
|
||||
|
||||
int isoburn_drive_set_msgs_submit(struct burn_drive *d,
|
||||
int (*msgs_submit)(void *handle, int error_code,
|
||||
char msg_text[], int os_errno,
|
||||
char severity[], int flag),
|
||||
void *submit_handle, int submit_flag, int flag)
|
||||
{
|
||||
struct isoburn *o;
|
||||
int ret;
|
||||
|
||||
ret= isoburn_find_emulator(&o, d, 0);
|
||||
if(ret<0 || o==NULL)
|
||||
return(-1);
|
||||
o->msgs_submit= msgs_submit;
|
||||
o->msgs_submit_handle= submit_handle;
|
||||
o->msgs_submit_flag= submit_flag;
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
/* @param flag bit0= with adr_mode 3: adr_value might be 16 blocks too high
|
||||
*/
|
||||
int isoburn_set_msc1(struct burn_drive *d, int adr_mode, char *adr_value,
|
||||
int flag)
|
||||
{
|
||||
@ -1538,7 +1443,7 @@ not_found:;
|
||||
goto unknown_mode;
|
||||
sprintf(msg, "Failed to find %s %s", mode_names[adr_mode],
|
||||
strlen(adr_value)<=80 ? adr_value : "-oversized-string-");
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "FAILURE", 0);
|
||||
burn_msgs_submit(0x00060000, msg, 0, "FAILURE", NULL);
|
||||
ret= 0; goto ex;
|
||||
}
|
||||
sessions= isoburn_toc_disc_get_sessions(disc, &num_sessions);
|
||||
@ -1581,12 +1486,7 @@ not_found:;
|
||||
|
||||
} else if(adr_mode==3) {
|
||||
o->fabricated_msc1= adr_num;
|
||||
if((flag & 1) && o->fabricated_msc1 >= 16) {
|
||||
/* adr_num is possibly 16 blocks too high */
|
||||
ret= isoburn_read_iso_head(d, o->fabricated_msc1, &size,volid, 1|(1<<14));
|
||||
if(ret==2)
|
||||
o->fabricated_msc1-= 16;
|
||||
}
|
||||
|
||||
} else if(adr_mode==4) {
|
||||
/* search for volume id that is equal to adr_value */
|
||||
best_lba= -1;
|
||||
@ -1611,7 +1511,7 @@ not_found:;
|
||||
} else {
|
||||
unknown_mode:;
|
||||
sprintf(msg, "Program error: Unknown msc1 address mode %d", adr_mode);
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "FATAL", 0);
|
||||
burn_msgs_submit(0x00060000, msg, 0, "FATAL", NULL);
|
||||
ret= 0; goto ex;
|
||||
}
|
||||
ret= 1;
|
||||
|
||||
@ -1,8 +1,7 @@
|
||||
/*
|
||||
data source for libisoburn.
|
||||
|
||||
Copyright 2007 - 2008 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
|
||||
and Thomas Schmitt <scdbackup@gmx.net>
|
||||
Copyright 2007 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
@ -85,19 +84,6 @@ int ds_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
|
||||
|
||||
icd = (struct isoburn_cached_drive *) src->data;
|
||||
d = (struct burn_drive*) icd->drive;
|
||||
|
||||
if(d == NULL) {
|
||||
/* This would happen if libisoburn saw output data in the fifo and
|
||||
performed early drive release and afterwards libisofs still tries
|
||||
to read data.
|
||||
That would constitute a bad conceptual problem in libisoburn.
|
||||
*/
|
||||
isoburn_msgs_submit(NULL, 0x00060000,
|
||||
"Programming error: Drive released while libisofs still attempts to read",
|
||||
0, "FATAL", 0);
|
||||
return ISO_ASSERT_FAILURE;
|
||||
}
|
||||
|
||||
tiles = (struct isoburn_cache_tile *) icd->tiles;
|
||||
|
||||
aligned_lba= lba & ~(Libisoburn_tile_blockS - 1);
|
||||
@ -147,10 +133,6 @@ int ds_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
|
||||
return 1;
|
||||
tiles[oldest].last_error_lba = lba;
|
||||
|
||||
#ifdef ISO_DATA_SOURCE_MISHAP
|
||||
ret= ISO_DATA_SOURCE_MISHAP;
|
||||
#else
|
||||
/* <<< pre libisofs-0.6.7 */
|
||||
/* It is not required by the specs of libisofs but implicitely assumed
|
||||
...
|
||||
But it is not possible to ignore FAILURE.
|
||||
@ -163,12 +145,10 @@ int ds_read_block(IsoDataSource *src, uint32_t lba, uint8_t *buffer)
|
||||
enough to make it appear plausible.
|
||||
*/
|
||||
ret= ISO_FILE_CANT_WRITE;
|
||||
#endif
|
||||
|
||||
if(ret >= 0)
|
||||
ret = -1;
|
||||
sprintf(msg, "ds_read_block(%lu) returns %d", (unsigned long) lba, ret);
|
||||
isoburn_msgs_submit(NULL, 0x00060000, msg, 0, "DEBUG", 0);
|
||||
burn_msgs_submit(0x00060000, msg, 0, "DEBUG", NULL);
|
||||
return ret;
|
||||
}
|
||||
|
||||
@ -208,19 +188,6 @@ static void ds_free_data(IsoDataSource *src)
|
||||
src->data= NULL;
|
||||
}
|
||||
|
||||
|
||||
int isoburn_data_source_shutdown(IsoDataSource *src, int flag)
|
||||
{
|
||||
struct isoburn_cached_drive *icd;
|
||||
|
||||
if(src==NULL)
|
||||
return(0);
|
||||
icd= (struct isoburn_cached_drive *) src->data;
|
||||
icd->drive= NULL;
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
IsoDataSource *isoburn_data_source_new(struct burn_drive *d)
|
||||
{
|
||||
IsoDataSource *ret;
|
||||
|
||||
@ -37,16 +37,10 @@
|
||||
|
||||
#include "isoburn.h"
|
||||
|
||||
|
||||
/* Default values for application provided msgs_submit methods.
|
||||
To be attached to newly aquired drives.
|
||||
/* No more: version numbers out of configure.ac
|
||||
major.minor.micro now comes from libisoburn.h
|
||||
#include "../version.h"
|
||||
*/
|
||||
int (*libisoburn_default_msgs_submit)
|
||||
(void *handle, int error_code, char msg_text[],
|
||||
int os_errno, char severity[], int flag)= NULL;
|
||||
void *libisoburn_default_msgs_submit_handle= NULL;
|
||||
int libisoburn_default_msgs_submit_flag= 0;
|
||||
|
||||
|
||||
/* ----------------------- isoburn_toc_entry ---------------------- */
|
||||
|
||||
@ -59,9 +53,9 @@ int isoburn_toc_entry_new(struct isoburn_toc_entry **objpt,
|
||||
*objpt= o= (struct isoburn_toc_entry *)
|
||||
malloc(sizeof(struct isoburn_toc_entry));
|
||||
if(o==NULL) {
|
||||
isoburn_msgs_submit(NULL, 0x00060000,
|
||||
"Cannot allocate memory for isoburn toc entry",
|
||||
0, "FATAL", 0);
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Cannot allocate memory for isoburn toc entry",
|
||||
0, "FATAL", NULL);
|
||||
return(-1);
|
||||
}
|
||||
o->session= 0;
|
||||
@ -110,16 +104,15 @@ int isoburn_new(struct isoburn **objpt, int flag)
|
||||
|
||||
*objpt= o= (struct isoburn *) malloc(sizeof(struct isoburn));
|
||||
if(o==NULL) {
|
||||
isoburn_msgs_submit(NULL, 0x00060000,
|
||||
"Cannot allocate memory for isoburn control object",
|
||||
0, "FATAL", 0);
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Cannot allocate memory for isoburn control object",
|
||||
0, "FATAL", NULL);
|
||||
return(-1);
|
||||
}
|
||||
|
||||
o->drive= NULL;
|
||||
o->emulation_mode= 0;
|
||||
o->fabricated_msc1= -1;
|
||||
o->fabricated_msc2= -1;
|
||||
o->zero_nwa= Libisoburn_overwriteable_starT;
|
||||
o->min_start_byte= o->zero_nwa * 2048;
|
||||
o->nwa= o->zero_nwa;
|
||||
@ -131,12 +124,8 @@ int isoburn_new(struct isoburn **objpt, int flag)
|
||||
for(i=0;i<Libisoburn_target_head_sizE;i++)
|
||||
o->target_iso_head[i]= 0;
|
||||
o->image= NULL;
|
||||
o->iso_data_source= NULL;
|
||||
o->read_pacifier= NULL;
|
||||
o->read_pacifier_handle= NULL;
|
||||
o->msgs_submit= NULL;
|
||||
o->msgs_submit_handle= NULL;
|
||||
o->msgs_submit_flag= 0;
|
||||
o->prev= NULL;
|
||||
o->next= NULL;
|
||||
ret= iso_image_new("ISOIMAGE", &o->image);
|
||||
@ -177,8 +166,7 @@ int isoburn_destroy(struct isoburn **objpt, int flag)
|
||||
isoburn_toc_entry_destroy(&(o->toc), 1); /* all */
|
||||
if(o->iso_source!=NULL)
|
||||
burn_source_free(o->iso_source);
|
||||
if(o->iso_data_source!=NULL)
|
||||
iso_data_source_unref(o->iso_data_source);
|
||||
|
||||
free((char *) o);
|
||||
*objpt= NULL;
|
||||
return(1);
|
||||
@ -312,39 +300,10 @@ int isoburn_find_by_drive(struct isoburn **pt, struct burn_drive *d, int flag)
|
||||
}
|
||||
|
||||
|
||||
int isoburn_msgs_submit(struct isoburn *o, int error_code, char msg_text[],
|
||||
int os_errno, char severity[], int flag)
|
||||
{
|
||||
int ret, use_drive_method= 0;
|
||||
|
||||
if(o!=NULL)
|
||||
if(o->msgs_submit!=NULL)
|
||||
use_drive_method= 1;
|
||||
if(use_drive_method) {
|
||||
ret= o->msgs_submit(o->msgs_submit_handle, error_code, msg_text, os_errno,
|
||||
severity, o->msgs_submit_flag);
|
||||
return(ret);
|
||||
}
|
||||
if(libisoburn_default_msgs_submit != NULL) {
|
||||
ret= libisoburn_default_msgs_submit(libisoburn_default_msgs_submit_handle,
|
||||
error_code, msg_text, os_errno, severity,
|
||||
libisoburn_default_msgs_submit_flag);
|
||||
return(ret);
|
||||
}
|
||||
/* Fallback: use message queue of libburn */
|
||||
burn_msgs_submit(error_code, msg_text, os_errno, severity, NULL);
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
/* @param flag bit0= modifying rather than growing
|
||||
bit1= prepare for early release of input drive:
|
||||
wait until input and then disable image data source
|
||||
*/
|
||||
static
|
||||
int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
|
||||
struct burn_disc **disc,
|
||||
struct isoburn_imgen_opts *opts, int flag)
|
||||
struct isoburn_imgen_opts *opts, int new_img)
|
||||
{
|
||||
struct burn_source *wsrc;
|
||||
struct burn_session *session;
|
||||
@ -352,18 +311,7 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
|
||||
struct isoburn *in_o, *out_o;
|
||||
IsoWriteOpts *wopts= NULL;
|
||||
enum burn_disc_status state;
|
||||
int ret, fifo_chunks, lba, nwa, i, new_img, early_indev_release;
|
||||
size_t buffer_size= 0, buffer_free= 0;
|
||||
char msg[160];
|
||||
|
||||
new_img= flag&1;
|
||||
early_indev_release= flag&2;
|
||||
if(new_img && early_indev_release) {
|
||||
isoburn_msgs_submit(in_o, 0x00060000,
|
||||
"Programming error: Wrong session setup: new_img && early_indev_release",
|
||||
0, "FATAL", 0);
|
||||
{ret= -4; goto ex;}
|
||||
}
|
||||
int ret, fifo_chunks, lba, nwa;
|
||||
|
||||
ret= isoburn_find_emulator(&in_o, in_d, 0);
|
||||
if(ret<0 || in_o==NULL)
|
||||
@ -377,14 +325,14 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
|
||||
state = isoburn_disc_get_status(in_d);
|
||||
if (state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE &&
|
||||
state != BURN_DISC_FULL) {
|
||||
isoburn_msgs_submit(in_o, 0x00060000, "Unsuitable source media state",
|
||||
0, "FAILURE", 0);
|
||||
burn_msgs_submit(0x00060000, "Unsuitable source media state",
|
||||
0, "FAILURE", NULL);
|
||||
{ret= -2; goto ex;}
|
||||
}
|
||||
state = isoburn_disc_get_status(out_d);
|
||||
if (state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) {
|
||||
isoburn_msgs_submit(out_o, 0x00060000, "Unsuitable target media state",
|
||||
0, "FAILURE", 0);
|
||||
burn_msgs_submit(0x00060000, "Unsuitable target media state",
|
||||
0, "FAILURE", NULL);
|
||||
{ret= -2; goto ex;}
|
||||
}
|
||||
|
||||
@ -422,16 +370,22 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
|
||||
iso_write_opts_set_default_gid(wopts, opts->gid);
|
||||
iso_write_opts_set_output_charset(wopts, opts->output_charset);
|
||||
iso_write_opts_set_fifo_size(wopts, fifo_chunks);
|
||||
|
||||
|
||||
ret = isoburn_disc_track_lba_nwa(out_d, NULL, 0, &lba, &nwa);
|
||||
opts->effective_lba= nwa;
|
||||
ret= isoburn_get_msc2(out_o, NULL, &nwa, 0);
|
||||
if (ret != 1) {
|
||||
isoburn_msgs_submit(out_o, 0x00060000,
|
||||
"Cannot determine next writeable address", 0, "FAILURE", 0);
|
||||
burn_msgs_submit(0x00060000, "Cannot determine next writeable address", 0,
|
||||
"FAILURE", NULL);
|
||||
{ret= -3; goto ex;}
|
||||
}
|
||||
if (nwa == 0 && state == BURN_DISC_APPENDABLE) {
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Encountered 0 as next writeable address of appendable",
|
||||
0, "FAILURE", NULL);
|
||||
{ret= -4; goto ex;}
|
||||
}
|
||||
iso_write_opts_set_ms_block(wopts, nwa);
|
||||
opts->effective_lba= nwa;
|
||||
iso_write_opts_set_appendable(wopts, !new_img);
|
||||
iso_write_opts_set_overwrite_buf(wopts,
|
||||
nwa>0 ? out_o->target_iso_head : NULL);
|
||||
@ -441,30 +395,6 @@ int isoburn_prepare_disc_aux(struct burn_drive *in_d, struct burn_drive *out_d,
|
||||
isoburn_report_iso_error(ret, "Cannot create burn source", 0, "FAILURE", 0);
|
||||
{ret= -1; goto ex;}
|
||||
}
|
||||
if (early_indev_release) {
|
||||
for(i= 0; i<300; i++) {
|
||||
|
||||
/* <<< ??? */
|
||||
if((i%30) == 0) {
|
||||
sprintf(msg, "Waiting for data in fifo since %d seconds", i/30);
|
||||
isoburn_msgs_submit(in_o, 0x00060000, msg, 0, "DEBUG", 0);
|
||||
}
|
||||
|
||||
usleep(100000);
|
||||
ret= iso_ring_buffer_get_status(wsrc, &buffer_size, &buffer_free);
|
||||
if(ret >0 && buffer_size != buffer_free)
|
||||
break;
|
||||
}
|
||||
|
||||
/* <<< ??? */
|
||||
sprintf(msg,
|
||||
"After %.1f seconds: %d bytes of output available (fifo state=%d)",
|
||||
((double) i+1) / 10.0, (int) (buffer_size - buffer_free), ret);
|
||||
isoburn_msgs_submit(in_o, 0x00060000, msg, 0, "DEBUG", 0);
|
||||
|
||||
if(in_o->iso_data_source!=NULL)
|
||||
isoburn_data_source_shutdown(in_o->iso_data_source, 0);
|
||||
}
|
||||
|
||||
/* TODO check return values for failure. propertly clean-up on error */
|
||||
|
||||
@ -506,34 +436,29 @@ int isoburn_prepare_new_image(struct burn_drive *d, struct burn_disc **disc,
|
||||
ret= isoburn_prepare_disc_aux(d, out_drive, disc, opts, 1);
|
||||
if (ret<=0)
|
||||
return ret;
|
||||
|
||||
#ifdef NIX
|
||||
struct isoburn *in_o, *out_o;
|
||||
|
||||
/* 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 /* NIX */
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
/* API since 0.2.2 */
|
||||
int isoburn_prepare_blind_grow(struct burn_drive *d, struct burn_disc **disc,
|
||||
struct isoburn_imgen_opts *opts,
|
||||
struct burn_drive *out_drive, int nwa)
|
||||
{
|
||||
int ret;
|
||||
struct isoburn *o= NULL;
|
||||
|
||||
ret= isoburn_find_emulator(&o, out_drive, 0);
|
||||
if(ret<0 || o==NULL)
|
||||
return(-1);
|
||||
if(nwa >= 0)
|
||||
o->fabricated_msc2= nwa;
|
||||
if(o->nwa == o->zero_nwa)
|
||||
o->nwa= o->zero_nwa= 0;
|
||||
else
|
||||
o->zero_nwa= 0;
|
||||
ret= isoburn_prepare_disc_aux(d, out_drive, disc, opts, 2);
|
||||
if (ret<=0)
|
||||
return ret;
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
/* API @since 0.1.0
|
||||
@param flag bit0= this is a regular end, not an abort
|
||||
give up source reference
|
||||
@ -619,8 +544,8 @@ int isoburn_ropt_new(struct isoburn_read_opts **new_o, int flag)
|
||||
|
||||
o= (*new_o)= calloc(1, sizeof(struct isoburn_read_opts));
|
||||
if(o==NULL) {
|
||||
isoburn_msgs_submit(NULL, 0x00060000,
|
||||
"Cannot allocate memory for read options", 0, "FATAL", 0);
|
||||
burn_msgs_submit(0x00060000, "Cannot allocate memory for read options",
|
||||
0, "FATAL", NULL);
|
||||
return(-1);
|
||||
}
|
||||
o->norock= 0;
|
||||
@ -756,9 +681,9 @@ int isoburn_igopt_new(struct isoburn_imgen_opts **new_o, int flag)
|
||||
|
||||
o= (*new_o)= calloc(1, sizeof(struct isoburn_imgen_opts));
|
||||
if(o==NULL) {
|
||||
isoburn_msgs_submit(NULL, 0x00060000,
|
||||
"Cannot allocate memory for image generation options",
|
||||
0, "FATAL", 0);
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Cannot allocate memory for image generation options",
|
||||
0, "FATAL", NULL);
|
||||
return(-1);
|
||||
}
|
||||
o->level= 2;
|
||||
|
||||
@ -60,17 +60,9 @@ struct isoburn {
|
||||
*/
|
||||
int fabricated_msc1;
|
||||
|
||||
/* If >= 0, this address is used in isoburn_disc_track_lba_nwa()
|
||||
as reply parameter nwa.
|
||||
(The other nwa parameters below apply only to the effective write address
|
||||
on random access media. msc2 is handed to libisofs but not to libburn.)
|
||||
*/
|
||||
int fabricated_msc2;
|
||||
|
||||
|
||||
/* The nwa to be used for a first session on the present kind of overwriteable
|
||||
media (usually Libisoburn_overwriteable_starT, but might be forced to 0)
|
||||
*/
|
||||
*/
|
||||
int zero_nwa;
|
||||
|
||||
/* Start address as given by image examination (bytes, not blocks) */
|
||||
@ -79,7 +71,6 @@ struct isoburn {
|
||||
/* Aligned start address to be used for processing (counted in blocks) */
|
||||
int nwa;
|
||||
|
||||
|
||||
/* Truncate to .nwa an eventual regular file serving as output drive */
|
||||
int truncate;
|
||||
|
||||
@ -108,10 +99,6 @@ struct isoburn {
|
||||
/* Libisofs image context */
|
||||
IsoImage *image;
|
||||
|
||||
/* The block data source from which the existing image is read.
|
||||
*/
|
||||
IsoDataSource *iso_data_source;
|
||||
|
||||
/* The burn source which transfers data from libisofs to libburn.
|
||||
It has its own fifo.
|
||||
*/
|
||||
@ -123,12 +110,6 @@ struct isoburn {
|
||||
/* For iso_image_attach_data() */
|
||||
void *read_pacifier_handle;
|
||||
|
||||
/* An application provided method to immediately deliver messages */
|
||||
int (*msgs_submit)(void *handle, int error_code, char msg_text[],
|
||||
int os_errno, char severity[], int flag);
|
||||
void *msgs_submit_handle; /* specific to application method */
|
||||
int msgs_submit_flag; /* specific to application method */
|
||||
|
||||
};
|
||||
|
||||
|
||||
@ -187,11 +168,6 @@ int isoburn_invalidate_iso(struct isoburn *o, int flag);
|
||||
int isoburn_find_emulator(struct isoburn **pt,
|
||||
struct burn_drive *drive, int flag);
|
||||
|
||||
/* Deliver an event message. Either via a non-NULL o->msgs_submit() method
|
||||
or via burn_msgs_submit() of libburn.
|
||||
*/
|
||||
int isoburn_msgs_submit(struct isoburn *o, int error_code, char msg_text[],
|
||||
int os_errno, char severity[], 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
|
||||
@ -203,19 +179,6 @@ int isoburn_msgs_submit(struct isoburn *o, int error_code, char msg_text[],
|
||||
*/
|
||||
int isoburn_set_start_byte(struct isoburn *o, off_t value, int flag);
|
||||
|
||||
/** Obtains the image address offset to be used with image generation.
|
||||
This is either the (emulated) drive nwa or a value set by
|
||||
isoburn_prepare_blind_grow().
|
||||
In any case this is the address to tell to iso_write_opts_set_ms_block().
|
||||
@param o The isoburn object to be inquired
|
||||
@param opts If not NULL: write parameters to be set on drive before query
|
||||
@param msc2 The value to be used with iso_write_opts_set_ms_block()
|
||||
@param flag unused yet
|
||||
@return <=0 is failure , >0 success
|
||||
*/
|
||||
int isoburn_get_msc2(struct isoburn *o,
|
||||
struct burn_write_opts *opts, int *msc2, 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.
|
||||
@ -226,19 +189,6 @@ int isoburn_get_msc2(struct isoburn *o,
|
||||
IsoDataSource *
|
||||
isoburn_data_source_new(struct burn_drive *d);
|
||||
|
||||
/** Disable read capabilities of a data source which was originally created
|
||||
by isoburn_data_source_new(). After this any attempt to read will yield
|
||||
a FATAL programming error event.
|
||||
This is usually done to allow libburn to release the drive while libisofs
|
||||
still holds a reference to the data source object. libisofs is not supposed
|
||||
to use this object for reading any more, nevertheless. The disabled state
|
||||
of the data source is a safety fence around this daring situation.
|
||||
@param src The data source to be disabled
|
||||
@param flag unused yet
|
||||
@return <=0 is failure , >0 success
|
||||
*/
|
||||
int isoburn_data_source_shutdown(IsoDataSource *src, int flag);
|
||||
|
||||
|
||||
/**
|
||||
* Options for image reading.
|
||||
@ -419,10 +369,8 @@ struct isoburn_imgen_opts {
|
||||
|
||||
/* Maximum gap to be bridged during a outer TOC scan. Gaps appear between the
|
||||
end of a session and the start of the next session.
|
||||
The longest gap found so far was about 38100 after the first session of a
|
||||
DVD-R.
|
||||
*/
|
||||
#define Libisoburn_toc_scan_max_gaP 65536
|
||||
#define Libisoburn_toc_scan_max_gaP 8192
|
||||
|
||||
|
||||
/* Creating a chain of image headers which form a TOC:
|
||||
|
||||
@ -121,18 +121,18 @@ int isoburn_read_image(struct burn_drive *d,
|
||||
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(read_opts==NULL) {
|
||||
isoburn_msgs_submit(o, 0x00060000,
|
||||
"Program error: isoburn_read_image: read_opts==NULL",
|
||||
0, "FATAL", 0);
|
||||
return(-1);
|
||||
}
|
||||
if (d == NULL || status == BURN_DISC_BLANK || read_opts->pretend_blank) {
|
||||
create_blank_image:;
|
||||
/*
|
||||
@ -142,9 +142,9 @@ create_blank_image:;
|
||||
if (d == NULL) {
|
||||
/* New empty image without relation to a drive */
|
||||
if (image==NULL) {
|
||||
isoburn_msgs_submit(o, 0x00060000,
|
||||
"Program error: isoburn_read_image: image==NULL",
|
||||
0, "FATAL", 0);
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Program error: isoburn_read_image: image==NULL",
|
||||
0, "FATAL", NULL);
|
||||
return -1;
|
||||
}
|
||||
/* create a new image */
|
||||
@ -170,9 +170,9 @@ create_blank_image:;
|
||||
}
|
||||
|
||||
if (status != BURN_DISC_APPENDABLE && status != BURN_DISC_FULL) {
|
||||
isoburn_msgs_submit(o, 0x00060000,
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Program error: isoburn_read_image: incorrect disc status",
|
||||
0, "FATAL", 0);
|
||||
0, "FATAL", NULL);
|
||||
return -4;
|
||||
}
|
||||
|
||||
@ -185,7 +185,7 @@ create_blank_image:;
|
||||
ret = isoburn_read_iso_head(d, int_num, &dummy, NULL, 0);
|
||||
if (ret <= 0) {
|
||||
sprintf(msg, "No ISO 9660 image at LBA %d. Creating blank image.", int_num);
|
||||
isoburn_msgs_submit(o, 0x00060000, msg, 0, "WARNING", 0);
|
||||
burn_msgs_submit(0x00060000, msg, 0, "WARNING", NULL);
|
||||
goto create_blank_image;
|
||||
}
|
||||
|
||||
@ -212,9 +212,6 @@ create_blank_image:;
|
||||
*/
|
||||
|
||||
ds = isoburn_data_source_new(d);
|
||||
if(o->iso_data_source!=NULL)
|
||||
iso_data_source_unref(o->iso_data_source);
|
||||
o->iso_data_source= ds;
|
||||
iso_image_attach_data(o->image, o->read_pacifier_handle,
|
||||
isoburn_idle_free_function);
|
||||
if(o->read_pacifier_handle==NULL)
|
||||
@ -224,7 +221,7 @@ create_blank_image:;
|
||||
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;
|
||||
@ -251,15 +248,15 @@ 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 (image == NULL) {
|
||||
isoburn_msgs_submit(o, 0x00060000,
|
||||
"Program error: isoburn_attach_image: image==NULL",
|
||||
0, "FATAL", 0);
|
||||
return -1;
|
||||
}
|
||||
if(o->image != NULL)
|
||||
iso_image_unref(o->image);
|
||||
o->image = image;
|
||||
@ -280,8 +277,6 @@ int isoburn_activate_session(struct burn_drive *drive)
|
||||
|
||||
if (o->emulation_mode != 1)
|
||||
return 1; /* don't need to activate session */
|
||||
if (o->fabricated_msc2 >= 0)
|
||||
return 1; /* blind growing: do not alter anything outside the session */
|
||||
|
||||
if (!(o->fabricated_disc_status == BURN_DISC_APPENDABLE ||
|
||||
(o->fabricated_disc_status == BURN_DISC_BLANK &&
|
||||
@ -309,9 +304,9 @@ int isoburn_start_emulation(struct isoburn *o, int flag)
|
||||
struct ecma119_pri_vol_desc *pvm;
|
||||
|
||||
if(o==NULL) {
|
||||
isoburn_msgs_submit(NULL, 0x00060000,
|
||||
"Program error: isoburn_start_emulation: o==NULL",
|
||||
0, "FATAL", 0);
|
||||
burn_msgs_submit(0x00060000,
|
||||
"Program error: isoburn_start_emulation: o==NULL",
|
||||
0, "FATAL", NULL);
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
@ -75,35 +75,23 @@ job parameters. It rather states its desires which libisoburn tries to
|
||||
fulfill, or else will refuse to start the write run.
|
||||
|
||||
|
||||
Setup for Growing, Modifying or Blind Growing
|
||||
Setup for Growing or Modifying
|
||||
|
||||
The connector function family offers alternative API calls for performing
|
||||
the setup for several alternative image generation strategies.
|
||||
The connector function family offers two alternative API calls for performing
|
||||
the setup for two alternative image generation strategies.
|
||||
|
||||
Growing:
|
||||
If input and output drive are the same, then isoburn_prepare_disc() is to
|
||||
If input and output drive is the same, then isoburn_prepare_disc() is to
|
||||
be used. It will lead to an add-on session on appendable or overwriteable
|
||||
media with existing ISO image. With blank media it will produce a first
|
||||
session.
|
||||
|
||||
Modifying:
|
||||
If the output drive is not the input drive, and if it bears blank media
|
||||
or overwriteable without a valid ISO image, then one may produce a consolidated
|
||||
image with old and new data. This will copy file data from an eventual input
|
||||
drive with valid image, add any newly introduced data from the local
|
||||
filesystem, and produce a first session on output media.
|
||||
To prepare for such an image generation run, use isoburn_prepare_new_image().
|
||||
|
||||
Blind Growing:
|
||||
This method reads the old image from one drive and writes the add-on session
|
||||
to a different drive. That output drive is nevertheless supposed to
|
||||
finally lead to the same media from where the session was loaded. Usually it
|
||||
will be stdio:/dev/fd/1 (i.e. stdout) being piped into some burn program
|
||||
like with this classic gesture:
|
||||
mkisofs -M $dev -C $msc1,$nwa | cdrecord -waiti dev=$dev
|
||||
Blind growing is prepared by the call isoburn_prepare_blind_grow().
|
||||
The input drive should be released immediately after this call in order
|
||||
to allow the consumer of the output stream to access that drive for writing.
|
||||
If the output drive is not the input drive, then it has to bear blank media
|
||||
or overwriteable without a valid ISO image. To prepare for such an image
|
||||
generation run, use isoburn_prepare_new_image(). The run will copy file data
|
||||
from an eventual input drive with valid image, add any newly introduced data
|
||||
from the local filesystem, and produce a first session on output media.
|
||||
|
||||
After either of these setups, some peripheral libburn drive parameter settings
|
||||
like burn_write_opts_set_simulate(), burn_write_opts_set_multi(),
|
||||
@ -200,15 +188,15 @@ void isoburn_version(int *major, int *minor, int *micro);
|
||||
*/
|
||||
#define isoburn_libisofs_req_major 0
|
||||
#define isoburn_libisofs_req_minor 6
|
||||
#define isoburn_libisofs_req_micro 10
|
||||
#define isoburn_libisofs_req_micro 6
|
||||
|
||||
/** The minimum version of libburn to be used with this version of libisoburn
|
||||
at compile time.
|
||||
@since 0.1.0
|
||||
*/
|
||||
#define isoburn_libburn_req_major 0
|
||||
#define isoburn_libburn_req_minor 5
|
||||
#define isoburn_libburn_req_micro 4
|
||||
#define isoburn_libburn_req_minor 4
|
||||
#define isoburn_libburn_req_micro 8
|
||||
|
||||
|
||||
/** The minimum version of libisofs to be used with this version of libisoburn
|
||||
@ -243,7 +231,7 @@ int isoburn_libburn_req(int *major, int *minor, int *micro);
|
||||
@since 0.1.0
|
||||
*/
|
||||
#define isoburn_header_version_major 0
|
||||
#define isoburn_header_version_minor 2
|
||||
#define isoburn_header_version_minor 1
|
||||
#define isoburn_header_version_micro 8
|
||||
/** Note:
|
||||
Above version numbers are also recorded in configure.ac because libtool
|
||||
@ -310,24 +298,6 @@ and would leave out the ugly compile time traps.
|
||||
*/
|
||||
|
||||
|
||||
/** Announce to the library an application provided method for immediate
|
||||
delivery of messages. It is used when no drive is affected directly or
|
||||
if the drive has no own msgs_submit() method attached by
|
||||
isoburn_drive_set_msgs_submit.
|
||||
If no method is preset or if the method is set to NULL then libisoburn
|
||||
delivers its messages through the message queue of libburn.
|
||||
@param msgs_submit The function call which implements the method
|
||||
@param submit_handle Handle to be used as first argument of msgs_submit
|
||||
@param submit_flag Flag to be used as last argument of msgs_submit
|
||||
@param flag Unused yet, submit 0
|
||||
@since 0.2.0
|
||||
*/
|
||||
int isoburn_set_msgs_submit(int (*msgs_submit)(void *handle, int error_code,
|
||||
char msg_text[], int os_errno,
|
||||
char severity[], int flag),
|
||||
void *submit_handle, int submit_flag, int flag);
|
||||
|
||||
|
||||
/** Aquire a target drive by its filesystem path resp. libburn persistent
|
||||
address.
|
||||
Wrapper for: burn_drive_scan_and_grab()
|
||||
@ -364,12 +334,12 @@ int isoburn_drive_scan_and_grab(struct burn_drive_info *drive_infos[],
|
||||
table of content by scanning for ISO image headers.
|
||||
(depending on media type and drive this might
|
||||
help or it might make the resulting toc even worse)
|
||||
bit4= do not emulate table of content on overwriteable media
|
||||
@return 1 = success , 0 = drive not found , <0 = other error
|
||||
*/
|
||||
int isoburn_drive_aquire(struct burn_drive_info *drive_infos[],
|
||||
char* adr, int flag);
|
||||
|
||||
|
||||
/** Aquire a drive from the burn_drive_info[] array which was obtained by
|
||||
a previous call of burn_drive_scan().
|
||||
Wrapper for: burn_drive_grab()
|
||||
@ -381,25 +351,6 @@ int isoburn_drive_aquire(struct burn_drive_info *drive_infos[],
|
||||
int isoburn_drive_grab(struct burn_drive *drive, int load);
|
||||
|
||||
|
||||
/** Attach to a drive an application provided method for immediate
|
||||
delivery of messages.
|
||||
If no method is set or if the method is set to NULL then libisoburn
|
||||
delivers messages of the drive through the global msgs_submit() method
|
||||
set by isoburn_set_msgs_submiti() or by the message queue of libburn.
|
||||
@since 0.2.0
|
||||
@param d The drive to which this function, handle and flag shall apply
|
||||
@param msgs_submit The function call which implements the method
|
||||
@param submit_handle Handle to be used as first argument of msgs_submit
|
||||
@param submit_flag Flag to be used as last argument of msgs_submit
|
||||
@param flag Unused yet, submit 0
|
||||
*/
|
||||
int isoburn_drive_set_msgs_submit(struct burn_drive *d,
|
||||
int (*msgs_submit)(void *handle, int error_code,
|
||||
char msg_text[], int os_errno,
|
||||
char severity[], int flag),
|
||||
void *submit_handle, int submit_flag, int flag);
|
||||
|
||||
|
||||
/** Inquire the media status. Expect the whole spectrum of libburn BURN_DISC_*
|
||||
with multi-session media. Emulated states with random access media are
|
||||
BURN_DISC_BLANK and BURN_DISC_APPENDABLE.
|
||||
@ -434,7 +385,7 @@ int isoburn_disc_erasable(struct burn_drive *d);
|
||||
void isoburn_disc_erase(struct burn_drive *drive, int fast);
|
||||
|
||||
|
||||
/** Set up isoburn_disc_get_msc1() to return a fabricated value.
|
||||
/** Program isoburn_disc_get_msc1() to return a fabricated value.
|
||||
This makes only sense between aquiring the drive and reading the
|
||||
image. After isoburn_read_image() it will confuse the coordination
|
||||
of libisoburn and libisofs.
|
||||
@ -451,11 +402,7 @@ void isoburn_disc_erase(struct burn_drive *drive, int fast);
|
||||
4= start lba of last session with volume id
|
||||
given by adr_value
|
||||
@parm adr_value A string describing the value to be eventually used.
|
||||
@param flag Bitfield for control purposes.
|
||||
bit0= @since 0.2.2
|
||||
with adr_mode 3: adr_value might be 16 blocks too high
|
||||
(e.g. -C stemming from growisofs). Probe for ISO head
|
||||
at adr_value-16 and eventually adjust setting.
|
||||
@param flag Bitfield for control purposes. Unused yet. Submit 0.
|
||||
*/
|
||||
int isoburn_set_msc1(struct burn_drive *d, int adr_mode, char *adr_value,
|
||||
int flag);
|
||||
@ -503,8 +450,7 @@ struct isoburn_toc_disc *isoburn_toc_drive_get_disc(struct burn_drive *d);
|
||||
|
||||
|
||||
/** Tell the number of 2048 byte blocks covered by the table of content.
|
||||
This number includes the eventual gaps between sessions and tracks.
|
||||
So this call is not really a wrapper for burn_disc_get_sectors().
|
||||
Wrapper for: burn_disc_get_sectors()
|
||||
@since 0.1.6
|
||||
@param disc The master handle of the media
|
||||
@return number of blocks, <=0 indicates unknown or unreadable state
|
||||
@ -555,7 +501,7 @@ struct isoburn_toc_track **isoburn_toc_session_get_tracks(
|
||||
struct isoburn_toc_session *s, int *num);
|
||||
|
||||
|
||||
/** Obtain a copy of the entry which describes a particular track.
|
||||
/** Obtain a copy of the entry which describes a particular itrack.
|
||||
Wrapper for: burn_track_get_entry()
|
||||
@since 0.1.6
|
||||
@param s The track handle
|
||||
@ -576,7 +522,7 @@ void isoburn_toc_track_get_entry(struct isoburn_toc_track *t,
|
||||
void isoburn_toc_disc_free(struct isoburn_toc_disc *disc);
|
||||
|
||||
|
||||
/** Try whether the data at the given address look like a ISO 9660
|
||||
/** Try whether at the data at the given address look like a ISO 9660
|
||||
image header and obtain its alleged size. Depending on the info mode
|
||||
one other string of text information can be retrieved too.
|
||||
@since 0.1.6
|
||||
@ -585,16 +531,9 @@ void isoburn_toc_disc_free(struct isoburn_toc_disc *disc);
|
||||
@param image_blocks The number of 2048 bytes blocks
|
||||
@param info Caller provided memory, enough to take eventual info reply
|
||||
@param flag bit0-7: info return mode
|
||||
0= do not return anything in info (do not even touch it)
|
||||
1= copy volume id to info (info needs 33 bytes)
|
||||
2= @since 0.2.2 :
|
||||
copy 64 kB header to info (needs 65536 bytes)
|
||||
bit13= @since 0.2.2:
|
||||
do not read head from media but use first 64 kB from info
|
||||
bit14= check both half buffers (not only second)
|
||||
return 2 if found in first block
|
||||
bit15= return-1 on read error
|
||||
@return >0 seems to be a valid ISO image, 0 format not recognized, <0 error
|
||||
0= do not return anything in info (do not even touch it)
|
||||
1= return volume id (info needs 33 bytes)
|
||||
@return 1 seems to be a valid ISO image , 0 format not recognized, <0 error
|
||||
*/
|
||||
int isoburn_read_iso_head(struct burn_drive *d, int lba,
|
||||
int *image_blocks, char *info, int flag);
|
||||
@ -1053,13 +992,9 @@ off_t isoburn_disc_available_space(struct burn_drive *d,
|
||||
|
||||
|
||||
/** Obtain the start block number of the most recent session on media. In
|
||||
case of random access media this will normally be 0. Successfull return is
|
||||
case of random access media this will always be 0. Succesfull return is
|
||||
not a guarantee that there is a ISO-9660 image at all. The call will fail,
|
||||
nevertheless,if isoburn_disc_get_status() returns not BURN_DISC_APPENDABLE
|
||||
or BURN_DISC_FULL.
|
||||
Note: The result of this call may be fabricated by a previous call of
|
||||
isoburn_set_msc1() which can override the rule to load the most recent
|
||||
session.
|
||||
nevertheless,if isoburn_disc_get_status() returns not BURN_DISC_APPENDABLE.
|
||||
Wrapper for: burn_disc_get_msc1()
|
||||
@since 0.1.0
|
||||
@param d The drive to inquire
|
||||
@ -1097,8 +1032,7 @@ int isoburn_get_min_start_byte(struct burn_drive *d, off_t *start_byte,
|
||||
int flag);
|
||||
|
||||
|
||||
/** To choose the expansion method of Growing:
|
||||
Create a disc object for writing the new session from the created or loaded
|
||||
/** Create a disc object for writing the new session from the created or loaded
|
||||
iso_volset which has been manipulated via libisofs, to the same media from
|
||||
where the image was eventually loaded. This struct burn_disc is ready for
|
||||
use by a subsequent call to isoburn_disc_write().
|
||||
@ -1115,10 +1049,9 @@ int isoburn_prepare_disc(struct burn_drive *drive, struct burn_disc **disc,
|
||||
struct isoburn_imgen_opts *opts);
|
||||
|
||||
|
||||
/** To choose the expansion method of Modifying:
|
||||
Create a disc object for producing a new image from a previous image
|
||||
/** Create a disc object for producing a new image from a previous image
|
||||
plus the changes made by user. The generated burn_disc is suitable
|
||||
to be written to a grabbed drive with blank writeable media.
|
||||
to be written to any grabbed libburn drive with blank writeable media.
|
||||
But you must not use the same drive for input and output, because data
|
||||
will be read from the source drive while at the same time the target
|
||||
drive is already writing.
|
||||
@ -1126,11 +1059,15 @@ int isoburn_prepare_disc(struct burn_drive *drive, struct burn_disc **disc,
|
||||
is done and the drive is BURN_DRIVE_IDLE again after asynchronous
|
||||
burn_disc_write().
|
||||
@since 0.1.0
|
||||
@param in_drive The input drive, grabbed with isoburn_drive_aquire() or
|
||||
one of its alternatives.
|
||||
@param in_drive The input drive,grabbed with isoburn_drive_scan_and_grab().
|
||||
@param disc Returns the newly created burn_disc object.
|
||||
@param opts Options for image generation and data transport to media.
|
||||
@param out_drive The output drive, from isoburn_drive_aquire() et.al..
|
||||
@param out_drive The libburn drive which shall be write target.
|
||||
If the drive was grabbed via libisoburn then it can later
|
||||
access the libisofs source fifo via
|
||||
isoburn_get_fifo_status().
|
||||
Mere libburn drives cannot obtain this info.
|
||||
In that case out_drive may be NULL, as well.
|
||||
@return <=0 error , 1 = success
|
||||
*/
|
||||
int isoburn_prepare_new_image(struct burn_drive *in_drive,
|
||||
@ -1138,55 +1075,11 @@ int isoburn_prepare_new_image(struct burn_drive *in_drive,
|
||||
struct isoburn_imgen_opts *opts,
|
||||
struct burn_drive *out_drive);
|
||||
|
||||
|
||||
/** To choose the expansion method of Blind Growing:
|
||||
Create a disc object for writing an add-on session from the created or
|
||||
loaded IsoImage which has been manipulated via libisofs, to a different
|
||||
drive than the one from where it was loaded.
|
||||
Usually output will be stdio:/dev/fd/1 (i.e. stdout) being piped
|
||||
into some burn program like with this classic gesture:
|
||||
mkisofs -M $dev -C $msc1,$nwa | cdrecord -waiti dev=$dev
|
||||
Parameter translation into libisoburn:
|
||||
$dev is the address by which parameter in_drive of this call was aquired
|
||||
$msc1 was set by isoburn_set_msc1() before image reading
|
||||
or was detected from the in_drive media
|
||||
$nwa is a parameter of this call
|
||||
or can be used as detected from the in_drive media
|
||||
|
||||
This call waits for libisofs output to become available and then detaches
|
||||
the input drive object from the data source object by which libisofs was
|
||||
reading from the input drive.
|
||||
So, as far as libisofs is concerned, that drive may be released immediately
|
||||
after this call in order to allow the consumer to access the drive for
|
||||
writing.
|
||||
The consumer should wait for input to become available and only then open
|
||||
its burn drive. With cdrecord this is caused by option -waiti.
|
||||
|
||||
The resulting burn_disc object has to be disposed when all its writing
|
||||
is done and the drive is BURN_DRIVE_IDLE again after asynchronous
|
||||
burn_disc_write().
|
||||
@since 0.2.2
|
||||
@param in_drive The input drive,grabbed with isoburn_drive_scan_and_grab().
|
||||
@param disc Returns the newly created burn_disc object.
|
||||
@param opts Options for image generation and data transport to media.
|
||||
@param out_drive The output drive, from isoburn_drive_aquire() et.al..
|
||||
typically stdio:/dev/fd/1 .
|
||||
@param nwa The address (2048 byte block count) where the add-on
|
||||
session will be finally stored on a mountable media
|
||||
or in a mountable file.
|
||||
If nwa is -1 then the address is used as determined from
|
||||
the in_drive media.
|
||||
@return <=0 error , 1 = success
|
||||
*/
|
||||
int isoburn_prepare_blind_grow(struct burn_drive *d, struct burn_disc **disc,
|
||||
struct isoburn_imgen_opts *opts,
|
||||
struct burn_drive *out_drive, int nwa);
|
||||
|
||||
|
||||
/**
|
||||
Revoke isoburn_prepare_*() instead of running isoburn_disc_write().
|
||||
/** @since 0.1.0
|
||||
Revoke isoburn_prepare_new_image() or isoburn_prepare_disc() instead of
|
||||
running isoburn_disc_write().
|
||||
libisofs reserves resources and maybe already starts generating the
|
||||
image stream when one of above three calls is performed. It is mandatory to
|
||||
image stream when one of above two calls is performed. It is mandatory to
|
||||
either run isoburn_disc_write() or to revoke the preparations by the
|
||||
call described here.
|
||||
@since 0.1.0
|
||||
@ -1264,7 +1157,8 @@ int isoburn_drive_wrote_well(struct burn_drive *d);
|
||||
int isoburn_activate_session(struct burn_drive *drive);
|
||||
|
||||
|
||||
/** Wait after normal end of operations until libisofs ended all write
|
||||
/** @since 0.1.0
|
||||
Wait after normal end of operations until libisofs ended all write
|
||||
threads and freed resource reservations.
|
||||
This call is not mandatory. But without it, messages from the ending
|
||||
threads might appear after the application ended its write procedure.
|
||||
@ -1280,6 +1174,21 @@ int isoburn_sync_after_write(struct burn_drive *input_drive,
|
||||
struct burn_drive *output_drive, int flag);
|
||||
|
||||
|
||||
#if 0
|
||||
/* >>> NOT YET IMPLEMENTED <<< */
|
||||
/** Write a new session to a disc.
|
||||
This is a synchronous call equivalent to isoburn_prepare_disc +
|
||||
isoburn_disc_write + isoburn_activate_session
|
||||
@param pacifier_func If not NULL: a function to produce appeasing messages.
|
||||
See burn_abort_pacifier() in libburn.h for an example.
|
||||
*/
|
||||
/* TODO implement this */
|
||||
int isoburn_perform_write(struct burn_write_opts *o,
|
||||
int (*pacifier_func)(void *handle, int patience,
|
||||
int elapsed));
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
/** Release an aquired drive.
|
||||
Wrapper for: burn_drive_release()
|
||||
@since 0.1.0
|
||||
|
||||
@ -4,7 +4,7 @@
|
||||
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.2.8.pl00.tar.gz
|
||||
http://scdbackup.sourceforge.net/xorriso-0.1.8.pl00.tar.gz
|
||||
Copyright (C) 2006-2008 Thomas Schmitt, provided under GPL version 2.
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
@ -14,7 +14,6 @@ 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.
|
||||
Vice versa xorriso is able to restore file objects from ISO 9660 filesystems.
|
||||
|
||||
Currently it is only supported on Linux with kernels >= 2.4.
|
||||
|
||||
@ -36,10 +35,10 @@ 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.2.8.pl00.tar.gz, take it to a directory of your choice and do:
|
||||
Obtain xorriso-0.1.8.pl00.tar.gz, take it to a directory of your choice and do:
|
||||
|
||||
tar xzf xorriso-0.2.8.pl00.tar.gz
|
||||
cd xorriso-0.2.8
|
||||
tar xzf xorriso-0.1.8.pl00.tar.gz
|
||||
cd xorriso-0.1.8
|
||||
|
||||
Within that directory execute:
|
||||
|
||||
@ -69,17 +68,6 @@ 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.
|
||||
|
||||
The installation creates several alias links pointing to the xorriso binary:
|
||||
xorrisofs starts xorriso with -as mkisofs emulation already enabled
|
||||
xorrecord starts xorriso with -as cdrecord emulation already enabled
|
||||
osirrox starts with -osirrox image-to-disk copying already enabled
|
||||
|
||||
If you want to avoid dependecy on libreadline although the libreadline
|
||||
development package is installed, then rather build xorriso by:
|
||||
./configure --prefix=/usr --disable-libreadline
|
||||
make clean ; make
|
||||
Never omit the "make clean" command after switching libreadline enabling.
|
||||
|
||||
|
||||
Drives and Disk File Objects
|
||||
|
||||
@ -153,26 +141,6 @@ and vice versa:
|
||||
| less
|
||||
|
||||
|
||||
File Formats
|
||||
|
||||
Currently there is only one file format peculiar to xorriso : sector maps
|
||||
which describe the valid and invalid blocks on a media or a disk copy of
|
||||
a media. xorriso creates and reads these file with its option -check_media.
|
||||
|
||||
The file begins with 32 bytes of cleartext of which the last one is a
|
||||
newline character. The first 25 say "xorriso sector bitmap v2 ", the
|
||||
remaining six characters give the size of the info text as decimal number.
|
||||
This number of bytes follows the first 32 and will not be interpreted
|
||||
by xorriso. They are rather to inform a human reader about the media type
|
||||
and its track layout.
|
||||
After the info text there are two 4 byte signed integers, most significant
|
||||
byte first. The first one, N, gives the number of bits in the following bitmap
|
||||
and the second number S gives the number of 2 KiB blocks governed by a single
|
||||
bit in the map. Then come the bits in form of 8-bit bytes.
|
||||
Data block M is covered by bit B=M/S in the map, bit number B is stored in
|
||||
byte B/8 as bit B%8. A valid readable data block has its bit set to 1.
|
||||
|
||||
|
||||
libisoburn
|
||||
|
||||
xorriso is based on libisofs which does ISO 9600 filesystem aspects and on
|
||||
@ -192,9 +160,9 @@ 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.2.8 :
|
||||
- libburn.so.4 , version libburn-0.5.4 or higher
|
||||
- libisofs.so.6 , version libisofs-0.6.10 or higher
|
||||
Dynamic library and compile time header requirements for libisoburn-0.1.8 :
|
||||
- libburn.so.4 , version libburn-0.4.8 or higher
|
||||
- libisofs.so.6 , version libisofs-0.6.6 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.
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -22,8 +22,6 @@ do_strip=0
|
||||
static_opts=
|
||||
warn_opts="-Wall"
|
||||
nglibisofs=1
|
||||
def_libreadline="-DXorriso_with_readlinE"
|
||||
link_libreadline="-lreadline"
|
||||
|
||||
for i in "$@"
|
||||
do
|
||||
@ -37,16 +35,11 @@ do
|
||||
elif test "$i" = "-g"
|
||||
then
|
||||
debug_opts="-g -O0"
|
||||
elif test "$i" = "-no_libreadline"
|
||||
then
|
||||
def_libreadline=""
|
||||
link_libreadline=""
|
||||
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 " -no_libreadline do not compile for and link with libreadline."
|
||||
echo " -do_diet produce capability reduced lean version."
|
||||
echo " -do_strip apply program strip to compiled programs."
|
||||
echo " -g produce debuggable programm."
|
||||
@ -83,20 +76,20 @@ 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)"
|
||||
|
||||
date -u '+#define Xorriso_build_timestamP "%Y.%m.%d.%H%M%S"' >"$xorr"/xorriso_buildstamp.h
|
||||
echo "Build timestamp : $(sed -e 's/#define Xorriso_build_timestamP "//' -e 's/"$//' "$xorr"/xorriso_buildstamp.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 $def_libreadline \
|
||||
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 \
|
||||
@ -137,7 +130,7 @@ cc -I. -DXorriso_with_maiN -DXorriso_with_regeX $def_libreadline \
|
||||
\
|
||||
$libisofs \
|
||||
\
|
||||
$link_libreadline \
|
||||
-lreadline \
|
||||
\
|
||||
-lpthread
|
||||
|
||||
|
||||
@ -1,4 +1,4 @@
|
||||
AC_INIT([xorriso], [0.2.8], [http://libburnia-project.org])
|
||||
AC_INIT([xorriso], [0.1.8], [http://libburnia-project.org])
|
||||
AC_PREREQ([2.50])
|
||||
dnl AC_CONFIG_HEADER([config.h])
|
||||
|
||||
@ -8,15 +8,15 @@ AC_CANONICAL_TARGET
|
||||
AM_INIT_AUTOMAKE([subdir-objects])
|
||||
|
||||
BURN_MAJOR_VERSION=0
|
||||
BURN_MINOR_VERSION=5
|
||||
BURN_MICRO_VERSION=5
|
||||
BURN_MINOR_VERSION=4
|
||||
BURN_MICRO_VERSION=9
|
||||
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=10
|
||||
LIBISOFS_MICRO_VERSION=6
|
||||
AC_SUBST(LIBISOFS_MAJOR_VERSION)
|
||||
AC_SUBST(LIBISOFS_MINOR_VERSION)
|
||||
AC_SUBST(LIBISOFS_MICRO_VERSION)
|
||||
@ -95,20 +95,14 @@ else
|
||||
CFLAGS="$CFLAGS -DDEBUG"
|
||||
fi
|
||||
|
||||
AC_ARG_ENABLE(libreadline,
|
||||
[ --enable-libreadline Enable use of libreadline by xorriso, default=yes],
|
||||
, enable_libreadline=yes)
|
||||
if test x$enable_libreadline = xyes; then
|
||||
|
||||
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"
|
||||
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= )
|
||||
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= )
|
||||
else
|
||||
READLINE_DEF=
|
||||
fi
|
||||
AC_CHECK_HEADER(readline/history.h, AC_CHECK_LIB(readline, add_history, X= , READLINE_DEF= ), READLINE_DEF= )
|
||||
AC_SUBST(READLINE_DEF)
|
||||
|
||||
|
||||
|
||||
@ -47,11 +47,11 @@ then
|
||||
-e 's/have a look at section EXAMPLES/have a look at section <A HREF="#EXAMPLES">EXAMPLES<\/A>/' \
|
||||
-e 's/<b>Session model:<\/b>/\ <BR><b>Session model:<\/b>/' \
|
||||
-e 's/<b>Media types and states:<\/b>/\ <BR><b>Media types and states:<\/b>/' \
|
||||
-e 's/<b>Creating, Growing, Modifying, Blind/\ <BR><b>Creating, Growing, Modifying, Blind/' \
|
||||
-e 's/<b>Creating, Growing, Modifying:<\/b>/\ <BR><b>Creating, Growing, Modifying:<\/b>/' \
|
||||
-e 's/<b>Libburn drives:<\/b>/\ <BR><b>Libburn drives:<\/b>/' \
|
||||
-e 's/^-dev /\ \ -dev /' \
|
||||
-e 's/^-devices /\ \ -devices /' \
|
||||
-e 's/<b>Rock Ridge, POSIX, X\/Open, and El Torito:<\/b>/\ <BR><b>Rock Ridge, POSIX, X\/Open, and El Torito:<\/b>/' \
|
||||
-e 's/<b>Rock Ridge, POSIX, X\/Open:<\/b>/\ <BR><b>Rock Ridge, POSIX, X\/Open:<\/b>/' \
|
||||
-e 's/<b>Command processing:<\/b>/\ <BR><b>Command processing:<\/b>/' \
|
||||
-e 's/<b>Dialog, Readline, Result pager:<\/b>/\ <BR><b>Dialog, Readline, Result pager:<\/b>/' \
|
||||
-e 's/<b>Aquiring source and target drive:<\/b>/\ <BR><b>Aquiring source and target drive:<\/b><BR>\ <BR>/' \
|
||||
@ -66,13 +66,10 @@ then
|
||||
-e 's/^706k = 706kB/\ \ 706k = 706kB/' \
|
||||
-e 's/^5540k = 5540kB/\ \ 5540k = 5540kB/' \
|
||||
-e 's/<b>Exception processing:<\/b>/\ <BR><b>Exception processing:<\/b><BR>\ <BR>/' \
|
||||
-e 's/<b>El Torito bootable ISO images:<\/b>/\ <BR><b>El Torito bootable ISO images:<\/b><BR>\ <BR>/' \
|
||||
-e 's/<b>Dialog mode control:<\/b>/\ <BR><b>Dialog mode control:<\/b><BR>\ <BR>/' \
|
||||
-e 's/<b>Drive and media related inquiry actions:<\/b>/\ <BR><b>Drive and media related inquiry actions:<\/b><BR>\ <BR>/' \
|
||||
-e 's/<b>Navigation in ISO image/\ <BR><b>Navigation in ISO image/' \
|
||||
-e 's/^filesystem:<\/b>/filesystem:<\/b><BR>\ <BR>/' \
|
||||
-e 's/<b>Evaluation of readability and recovery:<\/b>/\ <BR><b>Evaluation of readability and recovery:<\/b><BR>\ <BR>/' \
|
||||
-e 's/<b>osirrox restore options:<\/b>/\ <BR><b>osirrox restore options:<\/b><BR>\ <BR>/' \
|
||||
-e 's/<b>Command compatibility emulations:<\/b>/\ <BR><b>Command compatibility emulations:<\/b><BR>\ <BR>/' \
|
||||
-e 's/^<p><b>−as</<p>\ <BR><b>\−as</' \
|
||||
-e 's/<b>Scripting, dialog and/\ <BR><b>Scripting, dialog and/' \
|
||||
|
||||
@ -25,7 +25,7 @@
|
||||
current_dir=$(pwd)
|
||||
lone_dir="$current_dir"/"xorriso-standalone"
|
||||
|
||||
xorriso_rev=0.2.8
|
||||
xorriso_rev=0.1.8
|
||||
# For unstable uploads:
|
||||
# xorriso_pl=""
|
||||
# For stable releases:
|
||||
@ -124,17 +124,12 @@ 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
|
||||
|
||||
copy_files xorriso/xorriso_buildstamp_none.h \
|
||||
"$lone_dir"/xorriso/xorriso_buildstamp.h
|
||||
|
||||
create_dir "$lone_dir"/test
|
||||
copy_files \
|
||||
test/compare_file.c \
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
3824
xorriso/xorriso.c
3824
xorriso/xorriso.c
File diff suppressed because it is too large
Load Diff
@ -19,17 +19,7 @@ struct XorrisO;
|
||||
/* --------------------- Fundamental Management ------------------- */
|
||||
|
||||
/* Create a new xorriso object and tell it the program name to be used
|
||||
with messages and for decision of special behavior.
|
||||
@param xorriso returns the newly created XorrisO object
|
||||
@param progname typically argv[0] of main(). Some leafnames of the progname
|
||||
path have special meaning and trigger special behavior:
|
||||
"osirrox" allows image-to-disk copying: -osirrox "on"
|
||||
"xorrisofs" activates permanent mkisofs emulation
|
||||
"genisofs" alias of "xorrisofs"
|
||||
"mkisofs" alias of "xorrisofs"
|
||||
"genisoimage" alias of "xorrisofs"
|
||||
@parm flag unused yet, submit 0
|
||||
@return >0 success , <=0 failure, no object created
|
||||
with messages.
|
||||
*/
|
||||
int Xorriso_new(struct XorrisO ** xorriso, char *progname, int flag);
|
||||
|
||||
@ -82,13 +72,6 @@ int Xorriso_msgs_submit(struct XorrisO *xorriso,
|
||||
int error_code, char msg_text[], int os_errno,
|
||||
char severity[], int flag);
|
||||
|
||||
/** Alternative call interface of Xorriso_msgs_submit with void* instead
|
||||
of struct XorrisO*
|
||||
*/
|
||||
int Xorriso_msgs_submit_void(void *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.
|
||||
@ -150,104 +133,6 @@ int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag);
|
||||
|
||||
|
||||
|
||||
/* The outlist stack allows to redirect the info and result messages from
|
||||
their normal channels into a pair of string lists which can at some
|
||||
later time be retrieved by the application.
|
||||
These redirection caches can be stacked to allow stacked applications.
|
||||
xorriso itself uses them for internal purposes.
|
||||
*/
|
||||
|
||||
/* A list item able of forming double chained lists */
|
||||
struct Xorriso_lsT;
|
||||
|
||||
/** Maximum number of stacked redirections */
|
||||
#define Xorriso_max_outlist_stacK 32
|
||||
|
||||
/** Enable a new redirection of info and/or result channel. The normal message
|
||||
output and eventual older redirections will not see new messages until
|
||||
the redirection is ended by a call to Xorriso_pull_outlists() with the
|
||||
stack_handle value returned by this call.
|
||||
Redirected output is not written to the files of Xorriso_option_logfile()
|
||||
and the Xorriso_option_pkt_output() protocol will not be applied.
|
||||
@param xorriso The environment handle
|
||||
@param stack_handle returns an id number which is unique as long as
|
||||
its redirection is stacked. It may be re-used after
|
||||
its redirection was pulled from the stack.
|
||||
@param flag Bitfield for control purposes
|
||||
bit0= redirect result channel
|
||||
bit1= redirect info channel
|
||||
If bit0 and bit1 are 0, both channels get redirected.
|
||||
@return 1 on success, <=0 if failure
|
||||
*/
|
||||
int Xorriso_push_outlists(struct XorrisO *xorriso, int *stack_handle,
|
||||
int flag);
|
||||
|
||||
|
||||
/** Disable the redirection given by stack_handle. If it was the current
|
||||
receiver of messages then switch output to the next older redirection
|
||||
resp. to the normal channels if no redirections are stacked any more.
|
||||
The messages collected by the disabled redirection are handed out as
|
||||
two lists. Both lists have to be disposed via Xorriso_lst_destroy_all()
|
||||
when they are no longer needed.
|
||||
The message lists are either NULL or represented by their first
|
||||
Xorriso_lsT item.
|
||||
@param xorriso The environment handle
|
||||
@param stack_handle The id number returned by Xorriso_push_outlists()
|
||||
@param result_list Result and mark messages (usually directed to stdout)
|
||||
@param info_list Info and mark messages (usually directed to stderr)
|
||||
@param flag unused yet, submit 0
|
||||
@return 1 on success, <=0 if failure
|
||||
*/
|
||||
int Xorriso_pull_outlists(struct XorrisO *xorriso, int stack_handle,
|
||||
struct Xorriso_lsT **result_list,
|
||||
struct Xorriso_lsT **info_list, int flag);
|
||||
|
||||
|
||||
/** Obtain the text message from the current list item.
|
||||
@param entry The current list item
|
||||
@param flag unused yet, submit 0
|
||||
@return Pointer to the text content of the list item.
|
||||
This pointer does not have to be freed.
|
||||
*/
|
||||
char *Xorriso_lst_get_text(struct Xorriso_lsT *entry, int flag);
|
||||
|
||||
|
||||
/** Obtain the address of the next item in the chain of messages.
|
||||
An iteration over the output of Xorriso_pull_outlists() starts at the
|
||||
returned result_list resp. info_list and ends when this function returns
|
||||
NULL.
|
||||
@param entry The current list item
|
||||
@param flag unused yet, submit 0
|
||||
@return Pointer to the next list item or NULL if end of list.
|
||||
This pointer does not have to be freed.
|
||||
*/
|
||||
struct Xorriso_lsT *Xorriso_lst_get_next(struct Xorriso_lsT *entry, int flag);
|
||||
|
||||
|
||||
/** Obtain the address of the previous item in the chain of messages.
|
||||
@param entry The current list item
|
||||
@param flag unused yet, submit 0
|
||||
@return Pointer to the previous list item or NULL if start of list.
|
||||
This pointer does not have to be freed.
|
||||
*/
|
||||
struct Xorriso_lsT *Xorriso_lst_get_prev(struct Xorriso_lsT *entry, int flag);
|
||||
|
||||
|
||||
/** Destroy all list items which are directly or indirectly connected to
|
||||
the given link item.
|
||||
Apply this to each of the two list handles obtained by
|
||||
Xorriso_pull_outlists() when the lists are no longer needed.
|
||||
@param lstring *lstring will be freed and set to NULL.
|
||||
It is not dangerous to submit a pointer to a NULL-pointer.
|
||||
@param flag unused yet, submit 0
|
||||
@return -1= lstring was NULL (i.e. wrong use of this call),
|
||||
0= *lstring was already NULL,
|
||||
1= item actually disposed
|
||||
*/
|
||||
int Xorriso_lst_destroy_all(struct Xorriso_lsT **lstring, int flag);
|
||||
|
||||
|
||||
|
||||
/* ---------------------------- Options API ------------------------ */
|
||||
/* See man 1 xorriso for explanation of the particular options */
|
||||
/*
|
||||
@ -301,14 +186,6 @@ 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 -check_media */
|
||||
int Xorriso_option_check_media(struct XorrisO *xorriso,
|
||||
int argc, char **argv, int *idx, int flag);
|
||||
|
||||
/* Option -check_media_defaults */
|
||||
int Xorriso_option_check_media_defaults(struct XorrisO *xorriso,
|
||||
int argc, char **argv, int *idx, int flag);
|
||||
|
||||
/* Option -chgrp alias -chgrpi , chgrp_r alias chgrpi */
|
||||
/* @param flag bit0=recursive (-chgrp_r)
|
||||
*/
|
||||
@ -356,10 +233,7 @@ int Xorriso_option_compare(struct XorrisO *xorriso, char *disk_path,
|
||||
int Xorriso_option_cpri( struct XorrisO *xorriso, int argc, char **argv,
|
||||
int *idx, int flag);
|
||||
|
||||
/* Options -cpx , -cpax, -cp_rx , -cp_rax */
|
||||
/* @param flag bit0= recursive (-cp_rx, -cp_rax)
|
||||
bit1= full property restore (-cpax, -cp_rax)
|
||||
*/
|
||||
/* Option -cpx */
|
||||
int Xorriso_option_cpx(struct XorrisO *xorriso, int argc, char **argv,
|
||||
int *idx, int flag);
|
||||
|
||||
@ -406,17 +280,9 @@ int Xorriso_option_errfile_log(struct XorrisO *xorriso,
|
||||
int Xorriso_option_error_behavior(struct XorrisO *xorriso,
|
||||
char *occasion, char *behavior, int flag);
|
||||
|
||||
/* Options -extract , -extract_single */
|
||||
/* @param flag bit0=do not report the restored item
|
||||
bit1=do not reset pacifier, no final pacifier message
|
||||
bit5= -extract_single: eventually do not insert directory tree
|
||||
*/
|
||||
int Xorriso_option_extract(struct XorrisO *xorriso, char *disk_path,
|
||||
char *iso_path, int flag);
|
||||
|
||||
/* Option -extract_cut */
|
||||
int Xorriso_option_extract_cut(struct XorrisO *xorriso, char *iso_rr_path,
|
||||
char *start, char *count, char *disk_path, 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);
|
||||
@ -435,32 +301,20 @@ 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 -grow_blindly */
|
||||
int Xorriso_option_grow_blindly(struct XorrisO *xorriso, char *msc2, 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 -iso_rr_pattern "on"|"ls"|"off" */
|
||||
int Xorriso_option_iso_rr_pattern(struct XorrisO *xorriso, char *mode,
|
||||
int flag);
|
||||
|
||||
/* Option -joliet "on"|"off" */
|
||||
int Xorriso_option_joliet(struct XorrisO *xorriso, char *mode, int flag);
|
||||
|
||||
/* Option -list_delimiter */
|
||||
int Xorriso_option_list_delimiter(struct XorrisO *xorriso, char *text,
|
||||
int flag);
|
||||
|
||||
/* Option -list_formats */
|
||||
int Xorriso_option_list_formats(struct XorrisO *xorriso, int flag);
|
||||
|
||||
/* Option -load session|track|sbsector value */
|
||||
/* @param flag bit0= with adr_mode sbsector: adr_value is possibly 16 too high
|
||||
@return <=0 error , 1 success, 2 revoked by -reassure
|
||||
/* @return <=0 error , 1 success, 2 revoked by -reassure
|
||||
*/
|
||||
int Xorriso_option_load(struct XorrisO *xorriso, char *adr_mode,
|
||||
char *adr_value, int flag);
|
||||
@ -496,15 +350,6 @@ int Xorriso_option_lsx(struct XorrisO *xorriso, int argc, char **argv,
|
||||
int Xorriso_option_map(struct XorrisO *xorriso, char *disk_path,
|
||||
char *iso_path, int flag);
|
||||
|
||||
/* Options -map_l , -compare_l , -update_l , -extract_l */
|
||||
/* @param flag bit8-11= mode 0= -map_l
|
||||
1= -compare_l
|
||||
2= -update_l
|
||||
3= -extract_l
|
||||
*/
|
||||
int Xorriso_option_map_l(struct XorrisO *xorriso, int argc, char **argv,
|
||||
int *idx, int flag);
|
||||
|
||||
/* Option -mark */
|
||||
int Xorriso_option_mark(struct XorrisO *xorriso, char *mark, int flag);
|
||||
|
||||
@ -522,9 +367,6 @@ int Xorriso_option_no_rc(struct XorrisO *xorriso, int flag);
|
||||
/* Option -not_leaf */
|
||||
int Xorriso_option_not_leaf(struct XorrisO *xorriso, char *pattern, int flag);
|
||||
|
||||
/* Option -not_list */
|
||||
int Xorriso_option_not_list(struct XorrisO *xorriso, char *adr, int flag);
|
||||
|
||||
/* Option -not_paths */
|
||||
int Xorriso_option_not_paths(struct XorrisO *xorriso, int argc, char **argv,
|
||||
int *idx, int flag);
|
||||
@ -540,19 +382,12 @@ int Xorriso_option_osirrox(struct XorrisO *xorriso, char *mode, int flag);
|
||||
/* Option -overwrite "on"|"nondir"|"off" */
|
||||
int Xorriso_option_overwrite(struct XorrisO *xorriso, char *mode, int flag);
|
||||
|
||||
/* Option -pacifier */
|
||||
int Xorriso_option_pacifier(struct XorrisO *xorriso, char *style, 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 -paste_in */
|
||||
int Xorriso_option_paste_in(struct XorrisO *xorriso, char *iso_rr_path,
|
||||
char *disk_path, char *start, char *count, int flag);
|
||||
|
||||
/* Option -path-list */
|
||||
int Xorriso_option_path_list(struct XorrisO *xorriso, char *adr, int flag);
|
||||
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
#ifndef Xorriso_build_timestamP
|
||||
#define Xorriso_build_timestamP "-none-given-"
|
||||
#endif
|
||||
@ -1,3 +0,0 @@
|
||||
#ifndef Xorriso_build_timestamP
|
||||
#define Xorriso_build_timestamP "-none-given-"
|
||||
#endif
|
||||
@ -19,13 +19,11 @@
|
||||
|
||||
<P>
|
||||
<H2>Purpose:</H2>
|
||||
xorriso copies file objects from POSIX compliant filesystems
|
||||
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.
|
||||
<BR>
|
||||
Vice versa xorriso is able to restore file objects from ISO 9660 filesystems.
|
||||
</P>
|
||||
<P>
|
||||
|
||||
@ -60,15 +58,14 @@ and to MMC-5 for DVD or BD).
|
||||
GPL software included:<BR>
|
||||
</H2>
|
||||
<DL>
|
||||
<DT>libburn-0.5.5</DT>
|
||||
<DT>libburn-0.4.9</DT>
|
||||
<DD>reads and writes data from and to CD, DVD, BD-RE.</DD>
|
||||
<DD>(founded by Derek Foreman and Ben Jansens,
|
||||
developed and maintained since August 2006 by
|
||||
Thomas Schmitt from team of libburnia-project.org)</DD>
|
||||
<DT>libisofs-0.6.10</DT>
|
||||
<DD>operates on ISO 9660 filesystem images.</DD>
|
||||
furthered since August 2006 by team of libburnia-project.org)</DD>
|
||||
<DT>libisofs-0.6.6</DT>
|
||||
<DD>operates ISO 9660 images.</DD>
|
||||
<DD>(By Vreixo Formoso and Mario Danic from team of libburnia-project.org)</DD>
|
||||
<DT>libisoburn-0.2.8</DT>
|
||||
<DT>libisoburn-0.1.8</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>
|
||||
@ -98,26 +95,24 @@ Operates on an existing ISO image or creates a new one.
|
||||
Copies files from filesystem into the ISO image.
|
||||
</LI>
|
||||
<LI>
|
||||
Changes file properties, renames or deletes file objects in the ISO image.
|
||||
Renames or deletes file objects in the ISO image.
|
||||
</LI>
|
||||
<LI>
|
||||
Changes file properties in the ISO image.
|
||||
</LI>
|
||||
<LI>
|
||||
Updates ISO subtrees incrementally to match given disk subtrees.
|
||||
</LI>
|
||||
<LI>
|
||||
Writes result as completely new image or as add-on session
|
||||
to optical media or filesystem objects.
|
||||
Can write result as completely new image to optical media or
|
||||
filesystem objects.
|
||||
</LI>
|
||||
<LI>
|
||||
Can activate ISOLINUX boot images by El Torito boot record.
|
||||
Can write result as add-on session to appendable multi-session media,
|
||||
to overwriteable media, to regular files, and to block devices.
|
||||
</LI>
|
||||
<LI>
|
||||
Can perform multi-session tasks as emulation of mkisofs and cdrecord.
|
||||
</LI>
|
||||
<LI>
|
||||
Can restore single files and whole trees from ISO image to disk filesystem.
|
||||
</LI>
|
||||
<LI>
|
||||
Can check media for damages and copy readable blocks to disk.
|
||||
Can copy single files from ISO image to disk filesystem.
|
||||
</LI>
|
||||
<LI>
|
||||
Scans for optical drives, blanks re-useable optical media, formats media.
|
||||
@ -132,6 +127,9 @@ Reads its instructions from command line arguments, dialog, and batch files.
|
||||
<LI>
|
||||
Provides navigation commands for interactive ISO image manipulation.
|
||||
</LI>
|
||||
<LI>
|
||||
Adjustable thresholds for abort, exit value, and problem reporting.
|
||||
</LI>
|
||||
|
||||
</UL>
|
||||
</P>
|
||||
@ -141,11 +139,6 @@ Provides navigation commands for interactive ISO image manipulation.
|
||||
<DL>
|
||||
<DT>Get an overview of drives and their addresses</DT>
|
||||
<DD>#<KBD> xorriso -devices</KBD></DD>
|
||||
<DD><KBD>...</KBD></DD>
|
||||
<DD><KBD>0 -dev '/dev/sr0' rwrw-- : 'TSSTcorp' 'CDDVDW SH-S203B'</KBD></DD>
|
||||
<DD><KBD>1 -dev '/dev/scd1' rwrw-- : 'PHILIPS ' 'SPD3300L'</KBD></DD>
|
||||
<DD><KBD>2 -dev '/dev/hda' rwrw-- : 'HL-DT-ST' 'DVD-ROM GDR8162B'</KBD></DD>
|
||||
<DD><KBD>...</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
|
||||
@ -174,7 +167,7 @@ eventually prepare yet unused BD-RE:</DT>
|
||||
<DD>$<KBD> xorriso -dev /dev/sr0 -add /home/me/sounds /home/me/pictures
|
||||
</KBD></DD>
|
||||
|
||||
<DT>Have a look at the result:</DT>
|
||||
<DT>Check the result:</DT>
|
||||
<DD>$<KBD> xorriso -indev /dev/sr0 -du / -- -toc 2>&1 | less</KBD></DD>
|
||||
|
||||
<DT>
|
||||
@ -279,67 +272,22 @@ with ".o" or ".swp" which are excluded by options -not_leaf.
|
||||
<HR>
|
||||
</DT>
|
||||
|
||||
<DT>
|
||||
After the user has already created a suitable file tree on disk
|
||||
and copied the ISOLINUX files into subdirectory ./boot/isolinux of
|
||||
that tree, xorriso can burn an El Torito bootable media:
|
||||
</DT>
|
||||
<DD>$<KBD> xorriso -outdev /dev/sr0 -blank as_needed \</KBD></DD>
|
||||
<DD><KBD> -map /home/me/ISOLINUX_prepared_tree / \</KBD></DD>
|
||||
<DD><KBD> -boot_image isolinux dir=/boot/isolinux</KBD></DD>
|
||||
|
||||
<DT>
|
||||
<HR>
|
||||
</DT>
|
||||
|
||||
<DT>ISO images may not only be stored on optical media but also in
|
||||
regular disk files or block devices for full multi-session operation.
|
||||
The prefix "stdio:" indicates that normal file operations are
|
||||
desired rather than MMC drive commands:
|
||||
</DT>
|
||||
<DD>$<KBD> xorriso -dev stdio:/tmp/regular_file ...other.options...</DD>
|
||||
|
||||
<DT>Other file types are suitable only for writing but not for reading:</DT>
|
||||
<DD>$<KBD> xorriso -outdev stdio:/tmp/named_pipe ...other.options...</DD>
|
||||
|
||||
<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> xorriso -outdev - ...other.options... | consumer</KBD></DD>
|
||||
|
||||
|
||||
<DT>
|
||||
<HR>
|
||||
</DT>
|
||||
|
||||
<DT>
|
||||
Let xorriso serve underneath growisofs via its alias name "xorrisofs"
|
||||
which enables mkisofs emulation:
|
||||
</DT>
|
||||
<DD>$<KBD> export MKISOFS="xorrisofs"</KBD></DD>
|
||||
<DD>$<KBD> growisofs -Z /dev/dvd /some/files</KBD></DD>
|
||||
<DD>$<KBD> growisofs -M /dev/dvd /more/files</KBD></DD>
|
||||
<DT>
|
||||
One may switch from mkisofs emulation to xorriso's own command mode:
|
||||
</DT>
|
||||
<DD>$<KBD> growisofs -M /dev/dvd -- outdev - -update_r /my/files /files
|
||||
</KBD></DD>
|
||||
|
||||
<DT>
|
||||
<HR>
|
||||
</DT>
|
||||
|
||||
<DT>If for any reason the reading operating system mishandles the ISO image
|
||||
or some files in it, one may enable reverse operation of xorriso and copy
|
||||
files or trees to disk:
|
||||
<DT>Enable reverse operation of xorriso and copy some single files to disk:
|
||||
<DD>$<KBD> xorriso -indev /dev/sr0 \</KBD></DD>
|
||||
<DD><KBD> -osirrox on \</KBD></DD>
|
||||
<DD><KBD> -cpx '/pictures/private/horses*/*buttercup*' \</KBD></DD>
|
||||
<DD><KBD> /home/her/buttercup_dir -- \</KBD>
|
||||
<DD><KBD> -extract /sounds /home/her/sounds_from_me</KBD></DD>
|
||||
<DD><KBD> -cpx /pictures/private/horses*/*buttercup* \</KBD></DD>
|
||||
<DD><KBD> /home/her/buttercup_dir \</KBD>
|
||||
</DD>
|
||||
<DT>Consider to enter dialog mode and use commands like
|
||||
<KBD>-cd , -du , -lsl , -find<KBD>.
|
||||
|
||||
<DT>
|
||||
<HR>
|
||||
</DT>
|
||||
@ -363,8 +311,8 @@ are interested in using BD-R media.
|
||||
<P>
|
||||
<DL>
|
||||
<DT><H3>Download as source code (see README):</H3></DT>
|
||||
<DD><A HREF="xorriso-0.2.8.pl00.tar.gz">xorriso-0.2.8.pl00.tar.gz</A>
|
||||
(1050 KB).
|
||||
<DD><A HREF="xorriso-0.1.8.pl00.tar.gz">xorriso-0.1.8.pl00.tar.gz</A>
|
||||
(990 KB).
|
||||
</DD>
|
||||
</DL>
|
||||
</DD>
|
||||
@ -388,28 +336,18 @@ an <A HREF="http://www.opensource.org/">Open Source</A> approved license</DD>
|
||||
</P>
|
||||
|
||||
<HR>
|
||||
|
||||
<P>
|
||||
Bug fixes towards xorriso-0.2.6.pl00:
|
||||
Bug fixes towards xorriso-0.1.6.pl00:
|
||||
<UL>
|
||||
<LI>A potential buffer overflow has been fixed</LI>
|
||||
<LI>-follow "link" attributed random target filenames to looping links</LI>
|
||||
<LI>-as mkisofs -iso-level was accused to be an unknown option</LI>
|
||||
<!--
|
||||
<LI>- none -</LI>
|
||||
-->
|
||||
|
||||
<LI>-indev -outdev modifying to overwriteable target yielded unmountable results</LI>
|
||||
<LI>Major,minor numbers of device files appeared as 0,1 in next session</LI>
|
||||
</UL>
|
||||
</P>
|
||||
|
||||
<P>
|
||||
Enhancements towards previous stable version xorriso-0.2.4.pl00:
|
||||
Enhancements towards previous stable version xorriso-0.1.6.pl00:
|
||||
<UL>
|
||||
|
||||
<LI>Ability to write and maintain bootable ISO images based on ISOLINUX</LI>
|
||||
<LI>New ./configure option --disable-libreadline to make binary more portable
|
||||
</LI>
|
||||
|
||||
<LI>New option -stream_recording for full speed with DVD-RAM and BD-RE</LI>
|
||||
<LI>New options -osirrox and -cpx allow to extract single files from ISO image
|
||||
</UL>
|
||||
</P>
|
||||
|
||||
@ -417,25 +355,26 @@ Enhancements towards previous stable version xorriso-0.2.4.pl00:
|
||||
|
||||
<P>
|
||||
<DL>
|
||||
<DT><H3>Development snapshot, version 0.2.9 :</H3></DT>
|
||||
<DD>Bug fixes towards xorriso-0.2.8.pl00:
|
||||
<DT><H3>Development snapshot, version 0.1.9 :</H3></DT>
|
||||
<DD>Bug fixes towards xorriso-0.1.8.pl00:
|
||||
<UL>
|
||||
<LI>- none yet -</LI>
|
||||
<!--
|
||||
-->
|
||||
</UL>
|
||||
</DD>
|
||||
<DD>Enhancements towards stable version 0.2.8.pl00:
|
||||
<DD>Enhancements towards stable version 0.1.8.pl00:
|
||||
<UL>
|
||||
</LI>
|
||||
<LI>- none yet -</LI>
|
||||
<!--
|
||||
-->
|
||||
</UL>
|
||||
</DD>
|
||||
<DD> </DD>
|
||||
<DD><A HREF="README_xorriso_devel">README 0.2.9</A>
|
||||
<DD><A HREF="xorriso_help_devel">xorriso_0.2.9 -help</A></DD>
|
||||
<DD><A HREF="man_1_xorriso_devel.html">man xorriso (as of 0.2.9)</A></DD>
|
||||
<DD><A HREF="README_xorriso_devel">README 0.1.9</A>
|
||||
<DD><A HREF="xorriso_help_devel">xorriso_0.1.9 -help</A></DD>
|
||||
<DD><A HREF="man_1_xorriso_devel.html">man xorriso (as of 0.1.9)</A></DD>
|
||||
<DD> </DD>
|
||||
<DT>If you want to distribute development versions of xorriso, then use
|
||||
this tarball which produces static linking between xorriso and the
|
||||
@ -445,8 +384,8 @@ libburnia libraries.
|
||||
installation see README)
|
||||
</DD>
|
||||
<DD>
|
||||
<A HREF="xorriso-0.2.9.tar.gz">xorriso-0.2.9.tar.gz</A>
|
||||
(1050 KB).
|
||||
<A HREF="xorriso-0.1.9.tar.gz">xorriso-0.1.9.tar.gz</A>
|
||||
(990 KB).
|
||||
</DD>
|
||||
<DT>A dynamically linked development version of xorriso can be obtained
|
||||
from repositories of
|
||||
|
||||
@ -20,19 +20,6 @@ xorriso_xorriso_CFLAGS = -DXorriso_standalonE -DXorriso_with_maiN -DXorriso_with
|
||||
|
||||
xorriso_xorriso_LDADD = $(THREAD_LIBS)
|
||||
|
||||
|
||||
# This looks quite ugly with make install: xorriso.c is compiled twice again
|
||||
#
|
||||
# Trying to create a build timestamp file
|
||||
#
|
||||
# BUILT_SOURCES = xorriso/xorriso_buildstamp.h
|
||||
# phony targets get rebuilt every time
|
||||
# .PHONY: xorriso/xorriso_buildstamp.h
|
||||
# xorriso/xorriso_buildstamp.h:
|
||||
# date -u '+#define Xorriso_build_timestamP "%Y.%m.%d.%H%M%S"' >xorriso/xorriso_buildstamp.h
|
||||
# cat xorriso/xorriso_buildstamp.h
|
||||
|
||||
|
||||
xorriso_xorriso_SOURCES = \
|
||||
\
|
||||
xorriso/xorriso.h \
|
||||
@ -41,7 +28,6 @@ xorriso_xorriso_SOURCES = \
|
||||
xorriso/xorrisoburn.h \
|
||||
xorriso/xorrisoburn.c \
|
||||
xorriso/xorriso_timestamp.h \
|
||||
xorriso/xorriso_buildstamp.h \
|
||||
\
|
||||
libisoburn/libisoburn.h \
|
||||
libisoburn/isoburn.h \
|
||||
@ -151,6 +137,7 @@ xorriso_xorriso_SOURCES = \
|
||||
\
|
||||
version.h
|
||||
|
||||
|
||||
noinst_PROGRAMS = \
|
||||
test/compare_file
|
||||
|
||||
@ -164,30 +151,6 @@ test_compare_file_LDADD =
|
||||
test_compare_file_SOURCES = test/compare_file.c
|
||||
|
||||
|
||||
# Install symbolic links to the xorriso binary
|
||||
#
|
||||
install-exec-hook:
|
||||
if test -e "$(DESTDIR)$(bindir)"/xorrisofs ; then rm "$(DESTDIR)$(bindir)"/xorrisofs ; else echo ; fi
|
||||
ln -s xorriso "$(DESTDIR)$(bindir)"/xorrisofs
|
||||
if test -e "$(DESTDIR)$(bindir)"/osirrox ; then rm "$(DESTDIR)$(bindir)"/osirrox ; else echo ; fi
|
||||
ln -s xorriso "$(DESTDIR)$(bindir)"/osirrox
|
||||
if test -e "$(DESTDIR)$(bindir)"/xorrecord ; then rm "$(DESTDIR)$(bindir)"/xorrecord ; else echo ; fi
|
||||
ln -s xorriso "$(DESTDIR)$(bindir)"/xorrecord
|
||||
|
||||
|
||||
|
||||
# Alternative to the disabled .PHONY above.
|
||||
# Trying to create a build timestamp file semi-manually: make buildstamped
|
||||
#
|
||||
buildstamp:
|
||||
date -u '+#define Xorriso_build_timestamP "%Y.%m.%d.%H%M%S"' >xorriso/xorriso_buildstamp.h
|
||||
cat xorriso/xorriso_buildstamp.h
|
||||
|
||||
# For now make buildstamped has to be performed manually.
|
||||
buildstamped: buildstamp
|
||||
make
|
||||
|
||||
|
||||
## ========================================================================= ##
|
||||
|
||||
# Indent source files
|
||||
@ -221,7 +184,6 @@ EXTRA_DIST = \
|
||||
COPYING \
|
||||
INSTALL \
|
||||
xorriso/changelog.txt \
|
||||
xorriso/xorriso_buildstamp_none.h \
|
||||
$(man_MANS)
|
||||
|
||||
|
||||
|
||||
@ -18,7 +18,7 @@
|
||||
#ifndef Xorriso_private_includeD
|
||||
#define Xorriso_private_includeD yes
|
||||
|
||||
#define Xorriso_program_versioN "0.2.8"
|
||||
#define Xorriso_program_versioN "0.1.8"
|
||||
|
||||
/** The source code release timestamp */
|
||||
#include "xorriso_timestamp.h"
|
||||
@ -26,10 +26,7 @@
|
||||
#define Xorriso_timestamP "-none-given-"
|
||||
#endif
|
||||
|
||||
/** The binary build timestamp is to be set externally by the compiler
|
||||
or by a macro definition in xorriso_buildstamp.h.
|
||||
*/
|
||||
#include "xorriso_buildstamp.h"
|
||||
/** The binary build timestamp is to be set externally by the compiler */
|
||||
#ifndef Xorriso_build_timestamP
|
||||
#define Xorriso_build_timestamP "-none-given-"
|
||||
#endif
|
||||
@ -45,12 +42,12 @@
|
||||
#define Smem_freE free
|
||||
#define SfileadrL 4096
|
||||
|
||||
/* <<< ??? */
|
||||
typedef int (*Cleanup_app_handler_T)();
|
||||
|
||||
struct LinkiteM; /* Trace of hops during symbolic link resolution */
|
||||
struct ExclusionS; /* List of -not_* conditions */
|
||||
struct PermiteM; /* Stack of temporarily altered access permissions */
|
||||
struct SpotlisT; /* List of intervals with different read qualities */
|
||||
struct CheckmediajoB; /* Parameters for Xorriso_check_media() */
|
||||
struct SectorbitmaP; /* Distiniction between valid and invalid sectors */
|
||||
|
||||
|
||||
/* maximum number of history lines to be reported with -status:long_history */
|
||||
@ -65,13 +62,6 @@ struct SectorbitmaP; /* Distiniction between valid and invalid sectors */
|
||||
#define Xorriso_rc_nuM 4
|
||||
|
||||
|
||||
/* Default setting for the size limit of single data files:
|
||||
100 extents with 4 GB - 2 kB each = 400 GB - 200 kB
|
||||
*/
|
||||
#define Xorriso_default_file_size_limiT \
|
||||
(((off_t) 400) * ((off_t) 1024*1024*1024) - (off_t) 204800)
|
||||
|
||||
|
||||
struct XorrisO { /* the global context of xorriso */
|
||||
|
||||
int libs_are_started;
|
||||
@ -81,13 +71,6 @@ struct XorrisO { /* the global context of xorriso */
|
||||
char initial_wdx[SfileadrL];
|
||||
int no_rc;
|
||||
|
||||
/* Command line argument emulations:
|
||||
0=xorriso mode
|
||||
1=mkisofs mode
|
||||
2=cdrecord mode
|
||||
*/
|
||||
int argument_emulation;
|
||||
|
||||
/** List of startupfiles */
|
||||
char rc_filenames[Xorriso_rc_nuM][SfileadrL];
|
||||
int rc_filename_count;
|
||||
@ -99,8 +82,6 @@ struct XorrisO { /* the global context of xorriso */
|
||||
int add_plainly;
|
||||
off_t split_size;
|
||||
|
||||
char list_delimiter[81];
|
||||
|
||||
/* >>> put libisofs aspects here <<< */
|
||||
|
||||
int do_joliet;
|
||||
@ -134,8 +115,6 @@ struct XorrisO { /* the global context of xorriso */
|
||||
|
||||
int toc_emulation_flag; /* bit0= bit3 for isoburn_drive_aquire()
|
||||
scan -ROM profiles for ISO sessions
|
||||
bit1= bit4 for isoburn_drive_aquire()
|
||||
do not emulate TOC on overwriteable media
|
||||
*/
|
||||
|
||||
int image_start_mode; /* From what address to load the ISO image
|
||||
@ -144,8 +123,6 @@ struct XorrisO { /* the global context of xorriso */
|
||||
1= value is session number
|
||||
2= value is track number
|
||||
3= value is lba
|
||||
bit16= with mode 3 : value is possibly 16 too high.
|
||||
Let isoburn_set_msc1() adjust it.
|
||||
bit30= interference with normal msc1 processing
|
||||
is enabled. Without this bit,
|
||||
isoburn_set_msc1() will not be called.
|
||||
@ -162,21 +139,12 @@ struct XorrisO { /* the global context of xorriso */
|
||||
int volset_change_pending; /* whether -commit would make sense */
|
||||
int no_volset_present; /* set to 1 on first failure */
|
||||
|
||||
struct CheckmediajoB *check_media_default;
|
||||
struct SectorbitmaP *in_sector_map; /* eventual sector validity bitmap */
|
||||
|
||||
|
||||
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 grow_blindly_msc2; /* if >= 0 this causes growing from drive to drive.
|
||||
The value is used as block address offset for
|
||||
image generation. Like in: mkisofs -C msc1,msc2
|
||||
*/
|
||||
|
||||
int ban_stdio_write;
|
||||
int do_dummy;
|
||||
int do_close;
|
||||
@ -187,13 +155,6 @@ struct XorrisO { /* the global context of xorriso */
|
||||
|
||||
int keep_boot_image;
|
||||
int patch_isolinux_image;
|
||||
char boot_image_bin_path[SfileadrL];
|
||||
int boot_image_emul; /* 0=no emulation
|
||||
(1=emulation as hard disk)
|
||||
(2=emulation as floppy)
|
||||
*/
|
||||
char boot_image_cat_path[SfileadrL];
|
||||
off_t boot_image_load_size;
|
||||
|
||||
|
||||
/* XORRISO options */
|
||||
@ -203,11 +164,8 @@ struct XorrisO { /* the global context of xorriso */
|
||||
int do_concat_split; /* 1= restore complete split file directories as
|
||||
regular files
|
||||
*/
|
||||
int do_auto_chmod; /* 1= eventually temporarily open access permissions
|
||||
of self-owned directories during restore
|
||||
*/
|
||||
|
||||
int dialog; /* 0=off , 1=single-line , 2=multi-line */
|
||||
int dialog;
|
||||
|
||||
|
||||
/* Pattern matching facility. It still carries legacy from scdbackup/askme.c
|
||||
@ -234,8 +192,6 @@ struct XorrisO { /* the global context of xorriso */
|
||||
|
||||
int temp_mem_limit;
|
||||
|
||||
off_t file_size_limit;
|
||||
|
||||
struct ExclusionS *disk_exclusions;
|
||||
int disk_excl_mode; /* bit0= on (else off)
|
||||
bit1= parameter too (else rekursion only)
|
||||
@ -250,17 +206,7 @@ struct XorrisO { /* the global context of xorriso */
|
||||
char mark_text[SfileadrL]; /* ( stdout+stderr, M: ) */
|
||||
int packet_output;
|
||||
char logfile[4][SfileadrL];
|
||||
FILE *logfile_fp[4];
|
||||
FILE *pktlog_fp;
|
||||
struct Xorriso_lsT *result_msglists[Xorriso_max_outlist_stacK];
|
||||
struct Xorriso_lsT *info_msglists[Xorriso_max_outlist_stacK];
|
||||
int msglist_flags[Xorriso_max_outlist_stacK]; /* bit0= result is redirected
|
||||
bit1= info is redirected
|
||||
*/
|
||||
int msglist_stackfill;
|
||||
|
||||
int status_history_max; /* for -status long_history */
|
||||
|
||||
|
||||
char report_about_text[20];
|
||||
int report_about_severity;
|
||||
@ -275,7 +221,6 @@ struct XorrisO { /* the global context of xorriso */
|
||||
FILE *errfile_fp;
|
||||
|
||||
int img_read_error_mode; /* 0=best_effort , 1=failure , 2=fatal */
|
||||
int extract_error_mode; /* 0=best_effort , 1=keep , 2=delete */
|
||||
|
||||
char return_with_text[20];
|
||||
int return_with_severity;
|
||||
@ -308,14 +253,12 @@ struct XorrisO { /* the global context of xorriso */
|
||||
double error_count; /* double will not roll over */
|
||||
|
||||
/* pacifiers */
|
||||
int pacifier_style; /* 0= xorriso, 1=mkisofs 2=cdrecord */
|
||||
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;
|
||||
off_t pacifier_byte_count; /* auxiliary counter for data bytes */
|
||||
|
||||
void *pacifier_fifo;
|
||||
|
||||
@ -324,7 +267,7 @@ struct XorrisO { /* the global context of xorriso */
|
||||
struct PermiteM *perm_stack; /* Temporarily altered dir access permissions */
|
||||
|
||||
/* result (stdout, R: ) */
|
||||
char result_line[10*SfileadrL];
|
||||
char result_line[5*SfileadrL];
|
||||
int result_line_counter;
|
||||
int result_page_counter;
|
||||
int result_open_line_len;
|
||||
@ -475,91 +418,6 @@ int Xorriso_lsx_filev(struct XorrisO *xorriso, char *wd,
|
||||
int Xorriso_rmx(struct XorrisO *xorriso, off_t boss_mem, char *path, int flag);
|
||||
|
||||
|
||||
int Xorriso_make_tmp_path(struct XorrisO *xorriso, char *orig_path,
|
||||
char *tmp_path, int *fd, int flag);
|
||||
|
||||
/* @param flag bit0= path is a directory
|
||||
bit2= recursion: do not reassure in mode 2 "tree"
|
||||
bit3= this is for overwriting and not for plain removal
|
||||
*/
|
||||
int Xorriso_reassure_restore(struct XorrisO *xorriso, char *path, int flag);
|
||||
|
||||
|
||||
int Xorriso_auto_chmod(struct XorrisO *xorriso, char *disk_path, int flag);
|
||||
|
||||
int Xorriso_protect_stdout(struct XorrisO *xorriso, int flag);
|
||||
|
||||
|
||||
/* @param flag bit0= mark untested areas as valid
|
||||
*/
|
||||
int Xorriso_spotlist_to_sectormap(struct XorrisO *xorriso,
|
||||
struct SpotlisT *spotlist,
|
||||
int read_chunk,
|
||||
struct SectorbitmaP **map,
|
||||
int flag);
|
||||
|
||||
int Xorriso_toc_to_string(struct XorrisO *xorriso, char **toc_text, int flag);
|
||||
|
||||
|
||||
struct Xorriso_lsT {
|
||||
char *text;
|
||||
struct Xorriso_lsT *prev,*next;
|
||||
};
|
||||
|
||||
/** Create a new list item with arbitrary byte content.
|
||||
@param lstring The newly created object or NULL on failure
|
||||
@param data An array of bytes to be copied into the new object
|
||||
@param data_len Number of bytes to be copied
|
||||
@param link Xorriso_lsT object to which the new object shall be linked
|
||||
@param flag Bitfield for control purposes
|
||||
bit0= insert before link rather than after it
|
||||
bit1= do not copy data (e.g. because *data is invalid)
|
||||
@return <=0 error, 1 ok
|
||||
*/
|
||||
int Xorriso_lst_new_binary(struct Xorriso_lsT **lstring, char *data,
|
||||
int data_len, struct Xorriso_lsT *link, int flag);
|
||||
|
||||
|
||||
/** Create a new list item with a 0-terminated text as content.
|
||||
@param lstring The newly created object or NULL on failure
|
||||
@param text A 0-terminated array of bytes
|
||||
@param link Xorriso_lsT object to which the new object shall be linked
|
||||
@param flag Bitfield for control purposes
|
||||
bit0= insert before link rather than after it
|
||||
@return <=0 error, 1 ok
|
||||
*/
|
||||
int Xorriso_lst_new(struct Xorriso_lsT **lstring, char *text,
|
||||
struct Xorriso_lsT *link, int flag);
|
||||
|
||||
|
||||
/** Create a new list item at the end of a given list.
|
||||
@param lstring Contains as input a pointer to a pointer to any existing
|
||||
list item. As output this list item pointer will be
|
||||
changed to the address of the new list item.
|
||||
@param data An array of bytes to be copied into the new object
|
||||
@param data_len Number of bytes to be copied
|
||||
@param flag unused yet, submit 0
|
||||
@return <=0 error, 1 ok
|
||||
*/
|
||||
int Xorriso_lst_append_binary(struct Xorriso_lsT **entry,
|
||||
char *data, int data_len, int flag);
|
||||
|
||||
|
||||
/** Destroy a single list item and connect its eventual list neighbors.
|
||||
@param lstring pointer to the pointer to be freed and set to NULL
|
||||
@param flag unused yet, submit 0
|
||||
@return 0= *lstring was alredy NULL, 1= ok
|
||||
*/
|
||||
int Xorriso_lst_destroy(struct Xorriso_lsT **lstring, int flag);
|
||||
|
||||
|
||||
/* Opens the -check_media data copy in for reading and writing
|
||||
*/
|
||||
int Xorriso_open_job_data_to(struct XorrisO *xorriso,
|
||||
struct CheckmediajoB *job, int flag);
|
||||
|
||||
|
||||
|
||||
int Sfile_str(char target[SfileadrL], char *source, int flag);
|
||||
|
||||
double Sfile_microtime(int flag);
|
||||
@ -604,12 +462,6 @@ int Sort_argv(int argc, char **argv, int flag);
|
||||
/* @param flag bit0= single letters */
|
||||
char *Ftypetxt(mode_t st_mode, int flag);
|
||||
|
||||
/* @param flag bit0=with year and seconds
|
||||
bit1=timestamp format YYYY.MM.DD.hhmmss
|
||||
*/
|
||||
char *Ftimetxt(time_t t, char timetext[40], int flag);
|
||||
|
||||
|
||||
struct DirseQ;
|
||||
|
||||
int Dirseq_new(struct DirseQ **o, char *adr, int flag);
|
||||
@ -664,11 +516,6 @@ int Findjob_set_start_path(struct FindjoB *o, char *start_path, int flag);
|
||||
|
||||
int Findjob_get_start_path(struct FindjoB *o, char **start_path, int flag);
|
||||
|
||||
int Findjob_get_lba_damage_filter(struct FindjoB *o, int *start_lba,
|
||||
int *end_lba, int *damage_filter, int flag);
|
||||
|
||||
int Findjob_get_commit_filter(struct FindjoB *o, int *commit_filter, int flag);
|
||||
|
||||
|
||||
struct SplitparT;
|
||||
|
||||
@ -692,6 +539,33 @@ int Splitpart__compose(char *adr, int partno, int total_parts,
|
||||
|
||||
int Splitparts_sort(struct SplitparT *o, int count, int flag);
|
||||
|
||||
struct LstrinG {
|
||||
char *text;
|
||||
struct LstrinG *prev,*next;
|
||||
};
|
||||
|
||||
int Lstring_destroy(struct LstrinG **lstring, int flag);
|
||||
|
||||
int Lstring_destroy_all(struct LstrinG **lstring, int flag);
|
||||
|
||||
/*
|
||||
@param flag Bitfield for control purposes
|
||||
bit0= insert before link rather than after it
|
||||
bit1= do not copy data (e.g. because *data is invalid)
|
||||
*/
|
||||
int Lstring_new_binary(struct LstrinG **lstring, char *data, int data_len,
|
||||
struct LstrinG *link, int flag);
|
||||
|
||||
/*
|
||||
@param flag Bitfield for control purposes
|
||||
bit0= insert before link rather than after it
|
||||
*/
|
||||
int Lstring_new(struct LstrinG **lstring, char *text, struct LstrinG *link,
|
||||
int flag);
|
||||
|
||||
int Lstring_append_binary(struct LstrinG **entry, char *data, int data_len,
|
||||
int flag);
|
||||
|
||||
|
||||
int Permstack_push(struct PermiteM **o, char *disk_path, struct stat *stbuf,
|
||||
int flag);
|
||||
@ -700,62 +574,5 @@ int Permstack_pop(struct PermiteM **o, struct PermiteM *stopper,
|
||||
struct XorrisO *xorriso, int flag);
|
||||
|
||||
|
||||
int Spotlist_new(struct SpotlisT **o, int flag);
|
||||
|
||||
int Spotlist_destroy(struct SpotlisT **o, int flag);
|
||||
|
||||
int Spotlist_add_item(struct SpotlisT *o, int start_lba, int blocks,
|
||||
int quality, int flag);
|
||||
|
||||
int Spotlist_count(struct SpotlisT *o, int flag);
|
||||
|
||||
int Spotlist_block_count(struct SpotlisT *o, int flag);
|
||||
|
||||
int Spotlist_sector_size(struct SpotlisT *o, int read_chunk, int flag);
|
||||
|
||||
int Spotlist_get_item(struct SpotlisT *o, int idx,
|
||||
int *start_lba, int *blocks, int *quality, int flag);
|
||||
|
||||
char *Spotlist__quality_name(int quality, char name[80], int flag);
|
||||
|
||||
|
||||
#define Xorriso_read_quality_gooD 0x7fffffff
|
||||
#define Xorriso_read_quality_sloW 0x60000000
|
||||
#define Xorriso_read_quality_partiaL 0x50000000
|
||||
#define Xorriso_read_quality_valiD 0x40000000
|
||||
#define Xorriso_read_quality_untesteD 0x3fffffff
|
||||
#define Xorriso_read_quality_invaliD 0x3ffffffe
|
||||
#define Xorriso_read_quality_tao_enD 0x28000000
|
||||
#define Xorriso_read_quality_off_tracK 0x20000000
|
||||
#define Xorriso_read_quality_unreadablE 0x00000000
|
||||
|
||||
|
||||
int Checkmediajob_new(struct CheckmediajoB **o, int flag);
|
||||
|
||||
int Checkmediajob_destroy(struct CheckmediajoB **o, int flag);
|
||||
|
||||
int Checkmediajob_copy(struct CheckmediajoB *from, struct CheckmediajoB *to,
|
||||
int flag);
|
||||
|
||||
int Sectorbitmap_new(struct SectorbitmaP **o, int sectors, int sector_size,
|
||||
int flag);
|
||||
int Sectorbitmap_destroy(struct SectorbitmaP **o, int flag);
|
||||
int Sectorbitmap_from_file(struct SectorbitmaP **o, char *path, char *msg,
|
||||
int *os_errno, int flag);
|
||||
int Sectorbitmap_to_file(struct SectorbitmaP *o, char *path, char *info,
|
||||
char *msg, int *os_errno, int flag);
|
||||
int Sectorbitmap_set(struct SectorbitmaP *o, int sector, int flag);
|
||||
int Sectorbitmap_set_range(struct SectorbitmaP *o,
|
||||
int start_sector, int sectors, int flag);
|
||||
int Sectorbitmap_is_set(struct SectorbitmaP *o, int sector, int flag);
|
||||
int Sectorbitmap_bytes_are_set(struct SectorbitmaP *o,
|
||||
off_t start_byte, off_t end_byte, int flag);
|
||||
|
||||
int Sectorbitmap_get_layout(struct SectorbitmaP *o,
|
||||
int *sectors, int *sector_size, int flag);
|
||||
|
||||
int Sectorbitmap_copy(struct SectorbitmaP *from, struct SectorbitmaP *to,
|
||||
int flag);
|
||||
|
||||
#endif /* Xorriso_private_includeD */
|
||||
|
||||
|
||||
@ -1 +1 @@
|
||||
#define Xorriso_timestamP "2008.10.12.120001"
|
||||
#define Xorriso_timestamP "2008.06.02.070301"
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -14,11 +14,13 @@
|
||||
#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 2
|
||||
#define xorriso_libisoburn_req_minor 1
|
||||
#define xorriso_libisoburn_req_micro 8
|
||||
|
||||
int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag);
|
||||
@ -186,13 +188,7 @@ int Xorriso_iso_lstat(struct XorrisO *xorriso, char *path, struct stat *stbuf,
|
||||
*/
|
||||
int Xorriso_atip(struct XorrisO *xorriso, int flag);
|
||||
|
||||
/* @param write_start_address is valid if >=0
|
||||
@param tsize is valid if >0
|
||||
@param flag bit0= grow_overwriteable_iso
|
||||
bit1= do_isosize
|
||||
*/
|
||||
int Xorriso_burn_track(struct XorrisO *xorriso, off_t write_start_address,
|
||||
char *track_source, off_t tsize, int flag);
|
||||
int Xorriso_burn_track(struct XorrisO *xorriso, char *track_source, int flag);
|
||||
|
||||
/* @param flag bit1= outdev rather than indev
|
||||
@return <=0 = failure , 1= ok , 2= ok, is CD profile
|
||||
@ -204,10 +200,8 @@ int Xorriso_get_profile(struct XorrisO *xorriso, int *profile_number,
|
||||
int Xorriso_set_publisher(struct XorrisO *xorriso, char *name, int flag);
|
||||
|
||||
|
||||
/* @param flag bit0= node_pt is a valid ISO object handle, ignore pathname
|
||||
*/
|
||||
int Xorriso_iso_file_open(struct XorrisO *xorriso, char *pathname,
|
||||
void *node_pt, void **stream, int flag);
|
||||
void **stream, int flag);
|
||||
|
||||
int Xorriso_iso_file_read(struct XorrisO *xorriso, void *stream, char *buf,
|
||||
int count, int flag);
|
||||
@ -222,9 +216,6 @@ int Xorriso_copy_properties(struct XorrisO *xorriso,
|
||||
int Xorriso_cut_out(struct XorrisO *xorriso, char *disk_path,
|
||||
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag);
|
||||
|
||||
int Xorriso_paste_in(struct XorrisO *xorriso, char *disk_path,
|
||||
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag);
|
||||
|
||||
struct SplitparT;
|
||||
|
||||
/* @param flag bit0= in_node is valid, do not resolve iso_adr
|
||||
@ -245,7 +236,7 @@ int Xorriso_is_split(struct XorrisO *xorriso, char *path, void *node,
|
||||
>>> bit0= mkdir: graft in as empty directory, not as copy from iso
|
||||
bit1= do not report copied files
|
||||
bit2= -follow, -not_*: this is not a command parameter
|
||||
bit3= use offset and cut_size for -paste_in
|
||||
??? <<< bit3= use offset and cut_size for cut_out_node
|
||||
bit4= return 3 on rejection by exclusion or user
|
||||
bit5= if directory then do not add sub tree
|
||||
bit6= this is a copy action: do not fake times and ownership
|
||||
@ -253,97 +244,7 @@ int Xorriso_is_split(struct XorrisO *xorriso, char *path, void *node,
|
||||
3 = rejected
|
||||
*/
|
||||
int Xorriso_restore(struct XorrisO *xorriso,
|
||||
char *img_path, char *disk_path,
|
||||
off_t offset, off_t cut_size, int flag);
|
||||
|
||||
|
||||
/* @param flag bit0= in_node is valid, do not resolve img_path
|
||||
*/
|
||||
int Xorriso_restore_is_identical(struct XorrisO *xorriso, void *in_node,
|
||||
char *img_path, char *disk_path,
|
||||
char type_text[5], int flag);
|
||||
|
||||
|
||||
/* Return the official libburn address of an address string. This may fail
|
||||
if the string does not constitute a valid drive address.
|
||||
@param official_adr must offer SfileadrL bytes of reply buffer
|
||||
@return 1 = success , 0 = failure , -1 = severe error
|
||||
*/
|
||||
int Xorriso_libburn_adr(struct XorrisO *xorriso, char *address_string,
|
||||
char official_adr[], int flag);
|
||||
|
||||
|
||||
/* @param flag bit1= obtain info from outdev
|
||||
*/
|
||||
int Xorriso_msinfo(struct XorrisO *xorriso, int *msc1, int *msc2, int flag);
|
||||
|
||||
/*
|
||||
@param flag bit0= obtain iso_lba from indev
|
||||
bit1= head_buffer already contains a valid head
|
||||
bit2= issue message about success
|
||||
bit3= check whether source blocks are banned by in_sector_map
|
||||
*/
|
||||
int Xorriso_update_iso_lba0(struct XorrisO *xorriso, int iso_lba, int isosize,
|
||||
char *head_buffer, struct CheckmediajoB *job,
|
||||
int flag);
|
||||
|
||||
|
||||
struct CheckmediajoB {
|
||||
int use_dev; /* 0= use indev , 1= use outdev , 2= use sector map*/
|
||||
|
||||
int min_lba; /* if >=0 : begin checking at this address */
|
||||
int max_lba; /* if >=0 : read up to this address, else use mode */
|
||||
|
||||
int min_block_size; /* >>> not yet implemented:
|
||||
granularity desired by user
|
||||
*/
|
||||
int mode; /* 0= track by track
|
||||
1= single sweep over libisoburn media capacity
|
||||
>>> 2= single sweep over libburn media capacity
|
||||
*/
|
||||
time_t start_time;
|
||||
int time_limit; /* Number of seconds after which to abort */
|
||||
|
||||
int item_limit; /* Maximum number of media check list items as result */
|
||||
|
||||
char abort_file_path[SfileadrL];
|
||||
|
||||
char data_to_path[SfileadrL];
|
||||
int data_to_fd;
|
||||
off_t data_to_offset; /* usually 0 with image copy, negative with file copy */
|
||||
off_t data_to_limit; /* used with file copy */
|
||||
int patch_lba0;
|
||||
int patch_lba0_msc1;
|
||||
|
||||
char sector_map_path[SfileadrL];
|
||||
struct SectorbitmaP *sector_map;
|
||||
int map_with_volid; /* 0=add quick toc to map file,
|
||||
1=read ISO heads for toc
|
||||
*/
|
||||
|
||||
int retry; /* -1= only try full read_chunk, 1=retry with 2k blocks
|
||||
0= retry with CD, full chunk else
|
||||
*/
|
||||
|
||||
int report_mode; /* 0= print MCL items
|
||||
1= print damaged files
|
||||
*/
|
||||
|
||||
};
|
||||
|
||||
int Xorriso_check_media(struct XorrisO *xorriso, struct SpotlisT **spotlist,
|
||||
struct CheckmediajoB *job, int flag);
|
||||
|
||||
int Xorriso_extract_cut(struct XorrisO *xorriso,
|
||||
char *img_path, char *disk_path,
|
||||
off_t img_offset, off_t bytes, int flag);
|
||||
|
||||
|
||||
/* A pseudo file type for El-Torito bootsectors as in man 2 stat :
|
||||
For now take the highest possible value.
|
||||
*/
|
||||
#define Xorriso_IFBOOT S_IFMT
|
||||
|
||||
char *img_path, char *disk_path, int flag);
|
||||
|
||||
#endif /* Xorrisoburn_includeD */
|
||||
|
||||
|
||||
Reference in New Issue
Block a user