You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3372 lines
101 KiB
3372 lines
101 KiB
|
|
|
|
/* Adapter to libisoburn, libisofs and libburn for xorriso, |
|
a command line oriented batch and dialog tool which creates, loads, |
|
manipulates and burns ISO 9660 filesystem images. |
|
|
|
Copyright 2007-2008 Thomas Schmitt, <scdbackup@gmx.net> |
|
|
|
Provided under GPL version 2. |
|
*/ |
|
|
|
#include <ctype.h> |
|
#include <sys/types.h> |
|
#include <unistd.h> |
|
#include <stdlib.h> |
|
#include <stdio.h> |
|
#include <errno.h> |
|
#include <string.h> |
|
#include <sys/stat.h> |
|
#include <time.h> |
|
|
|
|
|
/* ------------------------------------------------------------------------ */ |
|
|
|
#ifndef Xorriso_standalonE |
|
|
|
/* The library which does the ISO 9660 / RockRidge manipulations */ |
|
#include <libisofs/libisofs.h> |
|
|
|
/* The library which does MMC optical drive operations */ |
|
#include <libburn/libburn.h> |
|
|
|
/* The library which enhances overwriteable media with ISO 9660 multi-session |
|
capabilities via the method invented by Andy Polyakov for growisofs */ |
|
#include <libisoburn/libisoburn.h> |
|
|
|
/* The official xorriso options API. "No shortcuts" */ |
|
#include "xorriso.h" |
|
|
|
/* The inner description of XorrisO */ |
|
#include "xorriso_private.h" |
|
|
|
/* The inner isofs- and burn-library interface */ |
|
#include "xorrisoburn.h" |
|
|
|
#else /* ! Xorriso_standalonE */ |
|
|
|
#include "../libisofs/libisofs.h" |
|
#include "../libburn/libburn.h" |
|
#include "../libisoburn/libisoburn.h" |
|
#include "xorriso.h" |
|
#include "xorriso_private.h" |
|
#include "xorrisoburn.h" |
|
|
|
#endif /* Xorriso_standalonE */ |
|
|
|
|
|
int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive, |
|
int flag); |
|
|
|
#define LIBISO_ISDIR(node) (iso_node_get_type(node) == LIBISO_DIR) |
|
#define LIBISO_ISREG(node) (iso_node_get_type(node) == LIBISO_FILE) |
|
#define LIBISO_ISLNK(node) (iso_node_get_type(node) == LIBISO_SYMLINK) |
|
#define LIBISO_ISCHR(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \ |
|
S_ISCHR(iso_node_get_mode(node))) |
|
#define LIBISO_ISBLK(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \ |
|
S_ISBLK(iso_node_get_mode(node))) |
|
#define LIBISO_ISFIFO(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \ |
|
S_ISFIFO(iso_node_get_mode(node))) |
|
#define LIBISO_ISSOCK(node) (iso_node_get_type(node) == LIBISO_SPECIAL && \ |
|
S_ISSOCK(iso_node_get_mode(node))) |
|
|
|
|
|
#define Xorriso_min_track_sizE 300 |
|
|
|
|
|
/* ------------------------------------------------------------------------ */ |
|
|
|
|
|
int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag) |
|
{ |
|
int ret, major, minor, micro; |
|
char *handler_prefix= NULL; |
|
char *queue_sev, *print_sev, reason[1024]; |
|
|
|
|
|
/* First an ugly compile time check for header version compatibility. |
|
If everthing matches, then no C code is produced. In case of mismatch, |
|
intentionally faulty C code will be inserted. |
|
*/ |
|
|
|
/* The minimum requirement of xorriso towards the libisoburn header |
|
at compile time is defined in xorriso/xorrisoburn.h |
|
xorriso_libisoburn_req_major |
|
xorriso_libisoburn_req_minor |
|
xorriso_libisoburn_req_micro |
|
It gets compared against the version macros in libburn/libburn.h : |
|
isoburn_header_version_major |
|
isoburn_header_version_minor |
|
isoburn_header_version_micro |
|
If the header is too old then the following code shall cause failure of |
|
cdrskin compilation rather than to allow production of a program with |
|
unpredictable bugs or memory corruption. |
|
The compiler messages supposed to appear in this case are: |
|
error: 'LIBISOBURN_MISCONFIGURATION' undeclared (first use in this function) |
|
error: 'INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisoburn_dot_h_TOO_OLD__SEE_xorrisoburn_dot_c' undeclared (first use in this function) |
|
error: 'LIBISOBURN_MISCONFIGURATION_' undeclared (first use in this function) |
|
*/ |
|
/* The indendation is an advise of man gcc to help old compilers ignoring */ |
|
#if xorriso_libisoburn_req_major > isoburn_header_version_major |
|
#define Isoburn_libisoburn_dot_h_too_olD 1 |
|
#endif |
|
#if xorriso_libisoburn_req_major == isoburn_header_version_major && xorriso_libisoburn_req_minor > isoburn_header_version_minor |
|
#define Isoburn_libisoburn_dot_h_too_olD 1 |
|
#endif |
|
#if xorriso_libisoburn_req_minor == isoburn_header_version_minor && xorriso_libisoburn_req_micro > isoburn_header_version_micro |
|
#define Isoburn_libisoburn_dot_h_too_olD 1 |
|
#endif |
|
|
|
#ifdef Isoburn_libisoburn_dot_h_too_olD |
|
LIBISOBURN_MISCONFIGURATION = 0; |
|
INTENTIONAL_ABORT_OF_COMPILATION__HEADERFILE_libisoburn_dot_h_TOO_OLD__SEE_xorrisoburn_dot_c = 0; |
|
LIBISOBURN_MISCONFIGURATION_ = 0; |
|
#endif |
|
|
|
/* End of ugly compile time test (scroll up for explanation) */ |
|
|
|
|
|
sprintf(xorriso->info_text, "Starting up libraries ...\n"); |
|
Xorriso_info(xorriso, 0); |
|
|
|
handler_prefix= calloc(strlen(xorriso->progname)+3+1, 1); |
|
if(handler_prefix==NULL) { |
|
sprintf(xorriso->info_text, |
|
"Cannot allocate memory for initializing libraries"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
return(-1); |
|
} |
|
reason[0]= 0; |
|
ret= isoburn_initialize(reason, 0); |
|
if(ret==0) { |
|
sprintf(xorriso->info_text, "Cannot initialize libraries"); |
|
if(reason[0]) |
|
sprintf(xorriso->info_text+strlen(xorriso->info_text), |
|
". Reason given:\n%s", reason); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
free(handler_prefix); |
|
return(0); |
|
} |
|
ret= isoburn_is_compatible(isoburn_header_version_major, |
|
isoburn_header_version_minor, |
|
isoburn_header_version_micro, 0); |
|
if(ret<=0) { |
|
isoburn_version(&major, &minor, µ); |
|
sprintf(xorriso->info_text, |
|
"libisoburn version too old: %d.%d.%d . Need at least: %d.%d.%d .\n", |
|
major, minor, micro, |
|
isoburn_header_version_major, isoburn_header_version_minor, |
|
isoburn_header_version_micro); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
return(-1); |
|
} |
|
|
|
if(reason[0]) { |
|
sprintf(xorriso->info_text, "%s", reason); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
} |
|
|
|
xorriso->libs_are_started= 1; |
|
|
|
|
|
queue_sev= "DEBUG"; |
|
if(xorriso->library_msg_direct_print) { |
|
|
|
/* >>> need option for controlling this in XorrisO. |
|
See also Xorriso_msgs_submit */; |
|
|
|
print_sev= xorriso->report_about_text; |
|
} else |
|
print_sev= "NEVER"; |
|
|
|
iso_set_msgs_severities(queue_sev, print_sev, "libsofs : "); |
|
burn_msgs_set_severities(queue_sev, print_sev, "libburn : "); |
|
|
|
/* ??? >>> do we want united queues ? */ |
|
/* burn_set_messenger(iso_get_messenger()); */ |
|
|
|
sprintf(handler_prefix, "%s : ", xorriso->progname); |
|
burn_set_signal_handling(handler_prefix, NULL, 0); |
|
|
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, "Library startup done.\n"); |
|
Xorriso_info(xorriso, 0); |
|
free(handler_prefix); |
|
return(1); |
|
} |
|
|
|
|
|
/* @param flag bit0= global shutdown of libraries */ |
|
int Xorriso_detach_libraries(struct XorrisO *xorriso, int flag) |
|
{ |
|
Xorriso_give_up_drive(xorriso, 3); |
|
if(xorriso->in_volset_handle!=NULL) { /* standalone image */ |
|
iso_image_unref((IsoImage *) xorriso->in_volset_handle); |
|
xorriso->in_volset_handle= NULL; |
|
} |
|
if(flag&1) { |
|
if(xorriso->libs_are_started==0) |
|
return(0); |
|
isoburn_finish(); |
|
} |
|
return(1); |
|
} |
|
|
|
|
|
/* @param flag bit1= obtain outdrive, else indrive */ |
|
int Xorriso_get_drive_handles(struct XorrisO *xorriso, |
|
struct burn_drive_info **dinfo, |
|
struct burn_drive **drive, |
|
char *attempt, int flag) |
|
{ |
|
if(flag&2) |
|
*dinfo= (struct burn_drive_info *) xorriso->out_drive_handle; |
|
else |
|
*dinfo= (struct burn_drive_info *) xorriso->in_drive_handle; |
|
if(*dinfo==NULL) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, "No %s drive aquired %s", |
|
(flag&2 ? "output" : "input"), attempt); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
*drive= (*dinfo)[0].drive; |
|
return((*drive)!=NULL); |
|
} |
|
|
|
|
|
/* @param flag bit0= suppress DEBUG messages */ |
|
int Xorriso_set_image_severities(struct XorrisO *xorriso, int flag) |
|
{ |
|
char *queue_sev, *print_sev; |
|
|
|
if(flag&1) |
|
queue_sev= "UPDATE"; |
|
else |
|
queue_sev= "DEBUG"; |
|
if(xorriso->library_msg_direct_print) |
|
print_sev= xorriso->report_about_text; |
|
else |
|
print_sev= "NEVER"; |
|
iso_set_msgs_severities(queue_sev, print_sev, "libisofs : "); |
|
return(1); |
|
} |
|
|
|
|
|
int Xorriso_update_volid(struct XorrisO *xorriso, int flag) |
|
{ |
|
int gret, sret= 1; |
|
|
|
gret= Xorriso_get_volid(xorriso, xorriso->loaded_volid, 0); |
|
if(gret>0 && strcmp(xorriso->volid, "ISOIMAGE")==0) |
|
strcpy(xorriso->volid, xorriso->loaded_volid); |
|
else |
|
sret= Xorriso_set_volid(xorriso, xorriso->volid, 1); |
|
return(gret>0 && sret>0); |
|
} |
|
|
|
|
|
int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag) |
|
{ |
|
int ret; |
|
IsoImage *volset; |
|
struct isoburn_read_opts *ropts; |
|
struct burn_drive_info *dinfo= NULL; |
|
struct burn_drive *drive= NULL; |
|
|
|
if(xorriso->out_drive_handle != NULL) { |
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive, |
|
"on attempt to attach volset to drive", 2); |
|
if(ret<=0) |
|
return(ret); |
|
} |
|
if(xorriso->in_volset_handle!=NULL) { |
|
iso_image_unref((IsoImage *) xorriso->in_volset_handle); |
|
xorriso->in_volset_handle= NULL; |
|
xorriso->loaded_volid[0]= 0; |
|
xorriso->volset_change_pending= 0; |
|
} |
|
|
|
ret= isoburn_ropt_new(&ropts, 0); |
|
if(ret<=0) |
|
return(ret); |
|
/* Note: no return before isoburn_ropt_destroy() */ |
|
isoburn_ropt_set_extensions(ropts, isoburn_ropt_pretend_blank); |
|
isoburn_ropt_set_input_charset(ropts, NULL); |
|
ret= isoburn_read_image(drive, ropts, &volset); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
isoburn_ropt_destroy(&ropts, 0); |
|
if(ret<=0) { |
|
sprintf(xorriso->info_text, "Failed to create new empty ISO image object"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
return(-1); |
|
} |
|
xorriso->in_volset_handle= (void *) volset; |
|
Xorriso_update_volid(xorriso, 0); |
|
xorriso->volset_change_pending= 0; |
|
return(1); |
|
} |
|
|
|
|
|
/* @param flag bit0=aquire as isoburn input drive |
|
bit1=aquire as libburn output drive (as isoburn drive if bit0) |
|
@return <=0 failure , 1= ok |
|
2=success, but not writeable with bit1 |
|
3=success, but not blank and not ISO with bit0 |
|
*/ |
|
int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag) |
|
{ |
|
int ret, hret, not_writeable= 0; |
|
struct burn_drive_info *dinfo= NULL, *out_dinfo, *in_dinfo; |
|
struct burn_drive *drive, *out_drive, *in_drive; |
|
enum burn_disc_status state; |
|
IsoImage *volset = NULL; |
|
struct isoburn_read_opts *ropts= NULL; |
|
char adr_data[SfileadrL], *libburn_adr; |
|
|
|
if((flag&3)==0) { |
|
sprintf(xorriso->info_text, |
|
"XORRISOBURN program error : Xorriso_aquire_drive bit0+bit1 not set"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
return(0); |
|
} |
|
ret= Xorriso_give_up_drive(xorriso, (flag&3)|8); |
|
if(ret<=0) |
|
return(ret); |
|
|
|
libburn_adr= adr; |
|
if(strcmp(adr,"stdio:/dev/fd/1")==0) { |
|
if(xorriso->dev_fd_1<0) { |
|
sprintf(xorriso->info_text, |
|
"\"stdio:/dev/fd/1\" was not a start argument. stdout possibly already tainted."); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
{ret= 0; goto ex;} |
|
} else { |
|
sprintf(adr_data, "stdio:/dev/fd/%d", xorriso->dev_fd_1); |
|
libburn_adr= adr_data; |
|
} |
|
} |
|
|
|
if((flag&3)==1 && xorriso->out_drive_handle!=NULL) { |
|
ret= Xorriso_get_drive_handles(xorriso, &out_dinfo, &out_drive, |
|
"on attempt to compare new indev with outdev", 2); |
|
if(ret<=0) |
|
goto ex; |
|
ret= burn_drive_equals_adr(out_drive, libburn_adr, 1); |
|
if(ret==1) |
|
dinfo= out_dinfo; |
|
} else if((flag&3)==2 && xorriso->in_drive_handle!=NULL) { |
|
ret= Xorriso_get_drive_handles(xorriso, &in_dinfo, &in_drive, |
|
"on attempt to compare new indev with outdev", 0); |
|
if(ret<=0) |
|
goto ex; |
|
ret= burn_drive_equals_adr(in_drive, libburn_adr, 1); |
|
if(ret==1) |
|
dinfo= in_dinfo; |
|
} |
|
|
|
if(dinfo==NULL) { |
|
ret= isoburn_drive_scan_and_grab(&dinfo, libburn_adr, 1); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(ret<=0) { |
|
sprintf(xorriso->info_text,"Cannot aquire drive '%s'", adr); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
} |
|
drive= dinfo[0].drive; |
|
state= isoburn_disc_get_status(drive); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(flag&1) { |
|
volset= isoburn_get_attached_image(drive); |
|
if(volset != NULL) { /* The image object is already created */ |
|
iso_image_unref(volset); |
|
} |
|
} |
|
|
|
if(flag&2) { |
|
xorriso->out_drive_handle= dinfo; |
|
if(Sfile_str(xorriso->outdev, adr, 0)<=0) |
|
return(-1); |
|
if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) { |
|
sprintf(xorriso->info_text, "Disc status unsuitable for writing"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0); |
|
not_writeable= 1; |
|
} |
|
} |
|
if(flag&1) { |
|
xorriso->in_drive_handle= dinfo; |
|
if(Sfile_str(xorriso->indev, adr, 0)<=0) |
|
return(-1); |
|
} else if(flag&2) { |
|
if(xorriso->in_volset_handle==NULL) { |
|
/* No volume loaded: create empty one */ |
|
ret= Xorriso_create_empty_iso(xorriso, 0); |
|
if(ret<=0) |
|
return(ret); |
|
} else { |
|
iso_image_ref((IsoImage *) xorriso->in_volset_handle); |
|
ret= isoburn_attach_image(drive, (IsoImage *) xorriso->in_volset_handle); |
|
if(ret<=0) { |
|
sprintf(xorriso->info_text, |
|
"Failed to attach ISO image object to outdev"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
return(-1); |
|
} |
|
} |
|
Xorriso_toc(xorriso, 1|2); |
|
return(1+not_writeable); |
|
} |
|
|
|
if(xorriso->in_volset_handle!=NULL) |
|
iso_image_unref((IsoImage *) xorriso->in_volset_handle); |
|
xorriso->in_volset_handle= NULL; |
|
|
|
/* check for invalid state */ |
|
if(state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE && |
|
state != BURN_DISC_FULL) { |
|
sprintf(xorriso->info_text, |
|
"Disc status not blank and unsuitable for reading"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
/* fill read opts */ |
|
ret= isoburn_ropt_new(&ropts, 0); |
|
if(ret<=0) |
|
return(ret); |
|
isoburn_ropt_set_extensions(ropts, isoburn_ropt_noiso1999); |
|
isoburn_ropt_set_default_perms(ropts, (uid_t) 0, (gid_t) 0, (mode_t) 0555); |
|
isoburn_ropt_set_input_charset(ropts, NULL); |
|
|
|
#ifdef NIX |
|
memset(&ropts, sizeof(ropts), 0); |
|
ropts.norock= 0; |
|
ropts.nojoliet= 0; |
|
ropts.noiso1999= 1; |
|
ropts.preferjoliet= 0; |
|
ropts.uid= 0; |
|
ropts.gid= 0; |
|
ropts.mode= 0555; |
|
ropts.input_charset= NULL; |
|
ropts.pretend_blank= 0; |
|
#endif /* NIX */ |
|
|
|
Xorriso_set_image_severities(xorriso, 1); /* No DEBUG messages */ |
|
if(isoburn_read_image(drive, ropts, &volset) <= 0) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
Xorriso_set_image_severities(xorriso, 0); |
|
sprintf(xorriso->info_text,"Cannot read ISO image volset"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret= 3; goto ex; |
|
} |
|
xorriso->in_volset_handle= (void *) volset; |
|
Xorriso_set_image_severities(xorriso, 0); |
|
Xorriso_update_volid(xorriso, 0); |
|
|
|
if(xorriso->out_drive_handle != NULL && |
|
xorriso->out_drive_handle != xorriso->in_drive_handle) { |
|
ret= Xorriso_get_drive_handles(xorriso, &out_dinfo, &out_drive, |
|
"on attempt to attach ISO image volset to outdev", 2); |
|
if(ret<=0) |
|
goto ex; |
|
iso_image_ref((IsoImage *) xorriso->in_volset_handle); |
|
isoburn_attach_image(out_drive, xorriso->in_volset_handle); |
|
} |
|
Xorriso_process_msg_queues(xorriso,0); |
|
Xorriso_toc(xorriso, 1); |
|
if(xorriso->loaded_volid[0]!=0) { |
|
sprintf(xorriso->result_line,"Volume id : '%s'\n",xorriso->loaded_volid); |
|
Xorriso_result(xorriso,0); |
|
if(strcmp(xorriso->loaded_volid, xorriso->volid)!=0) { |
|
sprintf(xorriso->result_line, "New volume id: '%s'\n", xorriso->volid); |
|
Xorriso_result(xorriso,0); |
|
} |
|
} |
|
ret= 1+not_writeable; |
|
ex: |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(ret<=0) { |
|
hret= Xorriso_give_up_drive(xorriso, flag&3); |
|
if(hret<ret) |
|
ret= hret; |
|
} |
|
isoburn_ropt_destroy(&ropts, 0); |
|
return(ret); |
|
} |
|
|
|
|
|
/* @param flag bit0=input drive |
|
bit1=output drive |
|
bit2=eject |
|
bit3=no info message or toc |
|
*/ |
|
int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag) |
|
{ |
|
int in_is_out_too, ret; |
|
struct burn_drive_info *dinfo; |
|
struct burn_drive *drive; |
|
char sfe[5*SfileadrL]; |
|
|
|
in_is_out_too= (xorriso->in_drive_handle == xorriso->out_drive_handle); |
|
if((flag&4) && in_is_out_too && (flag&(1|2))) { |
|
if((flag&3)!=3) { |
|
sprintf(xorriso->info_text,"Giving up for -eject whole -dev %s", |
|
Text_shellsafe(xorriso->indev, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
} |
|
flag|= 3; /* give up in/out drive to eject it */ |
|
} |
|
|
|
if((flag&1) && xorriso->in_drive_handle != NULL) { |
|
Xorriso_get_drive_handles(xorriso, &dinfo, &drive, |
|
"on attempt to give up drive", 0); |
|
|
|
if(!in_is_out_too) { |
|
if(drive!=NULL && !in_is_out_too) |
|
isoburn_drive_release(drive,!!(flag&4)); |
|
if(dinfo!=NULL && !in_is_out_too) |
|
burn_drive_info_free(dinfo); |
|
} |
|
xorriso->in_drive_handle= NULL; |
|
xorriso->indev[0]= 0; |
|
|
|
if(xorriso->in_volset_handle!=NULL) |
|
iso_image_unref((IsoImage *) xorriso->in_volset_handle); |
|
xorriso->in_volset_handle= NULL; |
|
xorriso->loaded_volid[0]= 0; |
|
xorriso->volset_change_pending= 0; |
|
|
|
in_is_out_too= 0; |
|
} |
|
if((flag&2) && xorriso->out_drive_handle!=NULL) { |
|
Xorriso_get_drive_handles(xorriso, &dinfo, &drive, |
|
"on attempt to give up drive", 2); |
|
if(!in_is_out_too) { |
|
if(drive!=NULL) |
|
isoburn_drive_release(drive,!!(flag&4)); |
|
if(dinfo!=NULL) |
|
burn_drive_info_free(dinfo); |
|
} |
|
xorriso->out_drive_handle= NULL; |
|
xorriso->outdev[0]= 0; |
|
} else if((flag&1) && xorriso->out_drive_handle!=NULL) { |
|
ret= Xorriso_create_empty_iso(xorriso, 0); |
|
if(ret<=0) |
|
return(ret); |
|
if(!(flag&8)) { |
|
sprintf(xorriso->info_text, |
|
"Only the output drive remains. Created empty ISO image.\n"); |
|
Xorriso_info(xorriso, 0); |
|
Xorriso_toc(xorriso, 1|2); |
|
} |
|
} |
|
Xorriso_process_msg_queues(xorriso,0); |
|
return(1); |
|
} |
|
|
|
|
|
int Xorriso_make_write_options( |
|
struct XorrisO *xorriso, struct burn_drive *drive, |
|
struct burn_write_opts **burn_options, int flag) |
|
{ |
|
int drive_role; |
|
|
|
*burn_options= burn_write_opts_new(drive); |
|
if(*burn_options==NULL) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text,"Cannot allocate option set"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
burn_write_opts_set_simulate(*burn_options, !!xorriso->do_dummy); |
|
drive_role= burn_drive_get_drive_role(drive); |
|
burn_write_opts_set_multi(*burn_options, |
|
!(xorriso->do_close || drive_role==0 || drive_role==3)); |
|
burn_drive_set_speed(drive, xorriso->speed, xorriso->speed); |
|
burn_write_opts_set_underrun_proof(*burn_options, 1); |
|
return(1); |
|
} |
|
|
|
|
|
/* @param flag bit0= do not write but only prepare and return size in sectors |
|
*/ |
|
int Xorriso_write_session(struct XorrisO *xorriso, int flag) |
|
{ |
|
int ret, media_space, img_sectors; |
|
struct isoburn_imgen_opts *sopts= NULL; |
|
struct burn_drive_info *dinfo, *source_dinfo; |
|
struct burn_drive *drive, *source_drive; |
|
struct burn_disc *disc= NULL; |
|
struct burn_write_opts *burn_options; |
|
off_t readcounter= 0,writecounter= 0; |
|
int num_sessions= 0, num_tracks= 0; |
|
struct burn_session **sessions; |
|
struct burn_track **tracks; |
|
enum burn_disc_status s; |
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive, |
|
"on attempt to write", 2); |
|
if(ret<=0) |
|
return(0); |
|
|
|
ret= isoburn_igopt_new(&sopts, 0); |
|
if(ret<=0) |
|
return(ret); |
|
isoburn_igopt_set_level(sopts, 2); |
|
isoburn_igopt_set_extensions(sopts, 1|((!!xorriso->do_joliet)<<1)); |
|
isoburn_igopt_set_relaxed(sopts, isoburn_igopt_allow_deep_paths); |
|
isoburn_igopt_set_sort_files(sopts, 1); |
|
isoburn_igopt_set_over_mode(sopts, 0, 0, (mode_t) 0, (mode_t) 0); |
|
isoburn_igopt_set_over_ugid(sopts, 0, 0, (uid_t) 0, (gid_t) 0); |
|
isoburn_igopt_set_out_charset(sopts, NULL); |
|
isoburn_igopt_set_fifo_size(sopts, xorriso->fs * 2048); |
|
|
|
#ifdef NIX |
|
memset(&sopts, 0, sizeof(sopts)); |
|
sopts.level= 2; |
|
sopts.rockridge= 1; |
|
sopts.joliet= !!xorriso->do_joliet; |
|
sopts.iso1999= 0; |
|
sopts.omit_version_numbers= 0; |
|
sopts.allow_deep_paths= 1; |
|
sopts.allow_longer_paths= 0; |
|
sopts.max_37_char_filenames= 0; |
|
sopts.no_force_dots= 0; |
|
sopts.allow_lowercase= 0; |
|
sopts.allow_full_ascii= 0; |
|
sopts.joliet_longer_paths= 0; |
|
sopts.sort_files= 1; |
|
sopts.replace_dir_mode= 2*!!xorriso->do_global_mode; |
|
sopts.dir_mode= xorriso->global_dir_mode; |
|
sopts.replace_file_mode= 2*!!xorriso->do_global_mode; |
|
sopts.file_mode= xorriso->global_file_mode; |
|
sopts.replace_uid= 2*!!xorriso->do_global_uid; |
|
sopts.uid= xorriso->global_uid; |
|
sopts.replace_gid= 2*!!xorriso->do_global_gid; |
|
sopts.gid= xorriso->global_gid; |
|
sopts.output_charset= NULL; |
|
sopts.fifo_size= xorriso->fs * 2048; |
|
#endif /* NIX */ |
|
|
|
if(xorriso->out_drive_handle == xorriso->in_drive_handle || |
|
xorriso->in_drive_handle == NULL) { |
|
ret= isoburn_prepare_disc(drive, &disc, sopts); |
|
} else { |
|
s= isoburn_disc_get_status(drive); |
|
if(s!=BURN_DISC_BLANK) { |
|
s= burn_disc_get_status(drive); |
|
if(s!=BURN_DISC_BLANK) |
|
sprintf(xorriso->info_text, |
|
"-indev differs from -outdev and -outdev media is not blank"); |
|
else |
|
sprintf(xorriso->info_text, |
|
"-indev differs from -outdev and -outdev media holds valid ISO image"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
{ret= 0; goto ex;} |
|
} |
|
ret= Xorriso_get_drive_handles(xorriso, &source_dinfo, &source_drive, |
|
"on attempt to get source for write", 0); |
|
if(ret<=0) |
|
goto ex; |
|
ret= isoburn_prepare_new_image(source_drive, &disc, sopts, drive); |
|
} |
|
if (ret <= 0) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text,"Failed to prepare session write run"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
{ret= 0; goto ex;} |
|
} |
|
|
|
ret= Xorriso_make_write_options(xorriso, drive, &burn_options, 0); |
|
if(ret<=0) |
|
goto ex; |
|
|
|
ret= img_sectors= burn_disc_get_sectors(disc); |
|
if(flag&1) |
|
goto ex; |
|
|
|
media_space= burn_disc_available_space(drive, burn_options) / (off_t) 2048; |
|
if(media_space < img_sectors || media_space < Xorriso_min_track_sizE) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text,"Image size %ds exceeds free space on media %ds", |
|
(img_sectors < Xorriso_min_track_sizE ? Xorriso_min_track_sizE |
|
: img_sectors ), |
|
media_space); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
{ret= 0; goto ex;} |
|
} |
|
|
|
if(img_sectors < Xorriso_min_track_sizE) { |
|
sessions= burn_disc_get_sessions(disc, &num_sessions); |
|
if(sessions==NULL || num_sessions < 1) { |
|
no_track:; |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text,"Program error : no track in prepared disc"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
{ret= -1; goto ex;} |
|
} |
|
tracks= burn_session_get_tracks(sessions[0], &num_tracks); |
|
if(tracks==NULL || num_tracks < 1) |
|
goto no_track; |
|
burn_track_define_data(tracks[0], 0, |
|
(Xorriso_min_track_sizE - img_sectors) * 2048, |
|
0, BURN_MODE1); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, "Expanded track to minimum size of %d sectors", |
|
Xorriso_min_track_sizE); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
} |
|
|
|
isoburn_disc_write(burn_options, disc); |
|
burn_write_opts_free(burn_options); |
|
|
|
ret= Xorriso_pacifier_loop(xorriso, drive, 0); |
|
if(ret<=0) |
|
goto ex; |
|
if(!isoburn_drive_wrote_well(drive)) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, |
|
"libburn indicates failure with writing."); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret= 0; goto ex; |
|
} |
|
|
|
sessions= burn_disc_get_sessions(disc, &num_sessions); |
|
if(num_sessions>0) { |
|
tracks= burn_session_get_tracks(sessions[0], &num_tracks); |
|
if(tracks!=NULL && num_tracks>0) { |
|
burn_track_get_counters(tracks[0],&readcounter,&writecounter); |
|
sprintf(xorriso->info_text, |
|
"ISO image produced: %d sectors. Written to media: %d sectors\n", |
|
(int) (readcounter/ (off_t) 2048), |
|
(int) (writecounter/ (off_t) 2048)); |
|
Xorriso_info(xorriso, 0); |
|
} |
|
} |
|
|
|
ret= isoburn_activate_session(drive); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(ret<=0) { |
|
sprintf(xorriso->info_text, |
|
"Could not write new set of volume descriptors"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
goto ex; |
|
} |
|
|
|
sprintf(xorriso->info_text, "Writing completed sucessfully.\n\n"); |
|
Xorriso_info(xorriso, 0); |
|
ret= 1; |
|
ex:; |
|
if(disc!=NULL) |
|
burn_disc_free(disc); |
|
isoburn_igopt_destroy(&sopts, 0); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
return(ret); |
|
} |
|
|
|
|
|
int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive, |
|
int flag) |
|
{ |
|
int ret, size, free_bytes, i; |
|
struct burn_progress progress; |
|
char *status_text; |
|
enum burn_drive_status drive_status; |
|
double start_time, current_time; |
|
|
|
start_time= Sfile_microtime(0); |
|
while(burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING) |
|
usleep(100002); |
|
|
|
while(1) { |
|
drive_status= burn_drive_get_status(drive, &progress); |
|
if(drive_status == BURN_DRIVE_IDLE) |
|
break; |
|
current_time= Sfile_microtime(0); |
|
if(drive_status == BURN_DRIVE_WRITING && progress.sectors > 0) { |
|
sprintf(xorriso->info_text, "Writing: sector %d of %d", |
|
progress.sector, progress.sectors); |
|
ret= isoburn_get_fifo_status(drive, &size, &free_bytes, &status_text); |
|
if(ret>0 ) |
|
sprintf(xorriso->info_text+strlen(xorriso->info_text), |
|
" [fifo %s, %2d%% fill]", status_text, |
|
(int) (100.0-100.0*((double) free_bytes)/(double) size)); |
|
} else if(drive_status == BURN_DRIVE_CLOSING_SESSION || |
|
drive_status == BURN_DRIVE_CLOSING_TRACK) |
|
sprintf(xorriso->info_text, |
|
"Closing track/session. Working since %.f seconds", |
|
current_time-start_time); |
|
else if(drive_status == BURN_DRIVE_FORMATTING) |
|
sprintf(xorriso->info_text, "Formatting. Working since %.f seconds", |
|
current_time-start_time); |
|
else |
|
sprintf(xorriso->info_text, |
|
"Thank you for being patient since %.f seconds", |
|
current_time-start_time); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0); |
|
|
|
for(i= 0; i<10; i++) { |
|
Xorriso_process_msg_queues(xorriso, 0); |
|
usleep(100000); |
|
} |
|
} |
|
return(1); |
|
} |
|
|
|
|
|
int Xorriso_get_volume(struct XorrisO *xorriso, IsoImage **volume, |
|
int flag) |
|
{ |
|
if(xorriso->in_volset_handle==NULL) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text,"No ISO image present."); |
|
if(xorriso->indev[0]==0 && xorriso->outdev[0]==0) |
|
sprintf(xorriso->info_text+strlen(xorriso->info_text), |
|
" No -dev, -indev, or -outdev selected."); |
|
else |
|
sprintf(xorriso->info_text+strlen(xorriso->info_text), |
|
" Possible program error with drive '%s'.", xorriso->indev); |
|
|
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
*volume= (IsoImage *) xorriso->in_volset_handle; |
|
return(*volume != NULL); |
|
} |
|
|
|
|
|
/* @param flag bit0=do not complain about non existent node */ |
|
int Xorriso_node_from_path(struct XorrisO *xorriso, IsoImage *volume, |
|
char *path, IsoNode **node, int flag) |
|
{ |
|
int ret; |
|
char sfe[5*SfileadrL], *path_pt; |
|
|
|
path_pt= path; |
|
if(path[0]==0) |
|
path_pt= "/"; |
|
*node= NULL; |
|
ret= iso_tree_path_to_node(volume, path_pt, node); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(ret<=0) { |
|
if(!(flag&1)) { |
|
sprintf(xorriso->info_text, "Cannot find path %s in loaded ISO image", |
|
Text_shellsafe(path_pt, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
} |
|
return(0); |
|
} |
|
return(1); |
|
} |
|
|
|
|
|
/* @param eff_path returns resulting effective path. |
|
Must provide at least SfileadrL bytes of storage. |
|
@param flag bit0= do not produce problem events (unless faulty path format) |
|
bit1= work purely literally, do not use libisofs |
|
bit2= (with bit1) this is an address in the disk world |
|
@return -1 = faulty path format, 0 = not found , |
|
1 = found simple node , 2 = found directory |
|
*/ |
|
int Xorriso_normalize_img_path(struct XorrisO *xorriso, char *wd, |
|
char *img_path, char eff_path[], int flag) |
|
{ |
|
int ret, is_dir= 0, done= 0; |
|
IsoImage *volume; |
|
IsoDir *dir= NULL; |
|
IsoNode *node= NULL; |
|
char path[SfileadrL], *apt, *npt, sfe[5*SfileadrL], *cpt; |
|
|
|
eff_path[0]= 0; |
|
if(img_path[0]==0) |
|
return(2); /* root directory */ |
|
|
|
if(!(flag&2)) { |
|
ret= Xorriso_get_volume(xorriso, &volume, 0); |
|
if(ret<=0) |
|
return(ret); |
|
} |
|
|
|
apt= npt= path; |
|
if(img_path[0]!='/') { |
|
strcpy(path, wd); |
|
ret= Sfile_add_to_path(path, img_path, 0); |
|
if(ret<=0) |
|
goto much_too_long; |
|
} else |
|
if(Sfile_str(path, img_path, 0)<=0) |
|
return(-1); |
|
|
|
if(path[0]!='/') { |
|
sprintf(xorriso->info_text, |
|
"Internal error: Unresolvable relative addressing in iso_rr_path '%s'", |
|
img_path); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FATAL", 0); |
|
return(-1); |
|
} else if(path[1]==0) |
|
return(2); /* root directory */ |
|
|
|
for(npt= apt; !done; apt= npt+1) { |
|
npt= strchr(apt, '/'); |
|
if(npt==NULL) { |
|
npt= apt+strlen(apt); |
|
done= 1; |
|
} else |
|
*npt= 0; |
|
if(*apt==0) { |
|
*apt= '/'; |
|
apt++; |
|
if(done) |
|
break; |
|
continue; |
|
} |
|
if(strcmp(apt,".")==0) |
|
continue; |
|
if(strcmp(apt,"..")==0) { |
|
if(!(flag&2)) { |
|
node= (IsoNode *) dir; |
|
if(node==NULL) { |
|
bonked_root:; |
|
sprintf(xorriso->info_text, |
|
"Relative addressing in path exceeds root directory: %s", |
|
Text_shellsafe(img_path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(-1); |
|
} |
|
dir= iso_node_get_parent(node); |
|
} |
|
/* truncate eff_path */; |
|
cpt= strrchr(eff_path, '/'); |
|
if(cpt==NULL) /* ??? if not flag&2 then this is a bug */ |
|
goto bonked_root; |
|
*cpt= 0; |
|
continue; |
|
} |
|
ret= Sfile_add_to_path(eff_path, apt, 0); |
|
if(ret<=0) { |
|
much_too_long:; |
|
sprintf(xorriso->info_text, "Effective path gets much too long (%d)", |
|
(int) (strlen(eff_path)+strlen(apt)+1)); |
|
if(!(flag&1)) |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(-1); |
|
} |
|
if(!(flag&2)) { |
|
dir= (IsoDir *) node; |
|
ret= Xorriso_node_from_path(xorriso, volume, eff_path, &node, flag&1); |
|
if(ret<=0) |
|
return(0); |
|
if(dir==NULL) /* could be false with "/dir/.." */ |
|
dir= iso_node_get_parent(node); |
|
is_dir= LIBISO_ISDIR(node); |
|
} |
|
} |
|
return(1+!!is_dir); |
|
} |
|
|
|
|
|
int Xorriso_get_node_by_path(struct XorrisO *xorriso, |
|
char *in_path, char *eff_path, |
|
IsoNode **node, int flag) |
|
{ |
|
int ret; |
|
char path[SfileadrL]; |
|
IsoImage *volume; |
|
|
|
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, in_path, path, 0); |
|
if(ret<=0) |
|
return(ret); |
|
if(eff_path!=NULL) |
|
strcpy(eff_path, path); |
|
ret= Xorriso_get_volume(xorriso, &volume, 0); |
|
if(ret<=0) |
|
return(ret); |
|
ret= Xorriso_node_from_path(xorriso, volume, path, node, 0); |
|
if(ret<=0) |
|
return(0); |
|
return(1); |
|
} |
|
|
|
|
|
int Xorriso_transfer_properties(struct XorrisO *xorriso, struct stat *stbuf, |
|
IsoNode *node, int flag) |
|
{ |
|
iso_node_set_permissions(node, stbuf->st_mode & 07777); |
|
iso_node_set_uid(node, stbuf->st_uid); |
|
iso_node_set_gid(node, stbuf->st_gid); |
|
iso_node_set_atime(node, stbuf->st_atime); |
|
iso_node_set_mtime(node, stbuf->st_mtime); |
|
iso_node_set_ctime(node, stbuf->st_ctime); |
|
return(1); |
|
} |
|
|
|
|
|
/* @param flag bit0= recursion is active */ |
|
int Xorriso_add_tree(struct XorrisO *xorriso, IsoDir *dir, |
|
char *img_dir_path, char *disk_dir_path, |
|
struct LinkiteM *link_stack, int flag) |
|
{ |
|
IsoImage *volume; |
|
IsoNode *node; |
|
IsoSymlink *iso_symlink; |
|
int ret, target_is_dir, source_is_dir, source_is_link, fret, was_failure= 0; |
|
int do_not_dive; |
|
struct DirseQ *dirseq= NULL; |
|
char *name, *img_name, *srcpt; |
|
struct stat stbuf, hstbuf; |
|
dev_t dir_dev; |
|
struct LinkiteM *own_link_stack; |
|
|
|
#ifdef Xorriso_fat_local_meM |
|
char sfe[5*SfileadrL], sfe2[5*SfileadrL]; |
|
char disk_path[2*SfileadrL], img_path[2*SfileadrL], link_target[SfileadrL]; |
|
#else /* Xorriso_fat_local_meM */ |
|
|
|
char *sfe= NULL, *sfe2= NULL; |
|
char *disk_path= NULL, *img_path= NULL, *link_target= NULL; |
|
|
|
/* Avoiding large local memory objects in order to save stack space */ |
|
sfe= malloc(5*SfileadrL); |
|
sfe2= malloc(5*SfileadrL); |
|
disk_path= malloc(2*SfileadrL); |
|
img_path= malloc(2*SfileadrL); |
|
link_target= malloc(SfileadrL); |
|
if(sfe==NULL || sfe2==NULL || disk_path==NULL || img_path==NULL || |
|
link_target==NULL) { |
|
Xorriso_no_malloc_memory(xorriso, &sfe, 0); |
|
{ret= -1; goto ex;} |
|
} |
|
|
|
#endif /* ! Xorriso_fat_local_meM */ |
|
|
|
own_link_stack= link_stack; |
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0); |
|
if(ret<=0) |
|
goto ex; |
|
|
|
if(lstat(disk_dir_path, &stbuf)==-1) |
|
goto cannot_open_dir; |
|
dir_dev= stbuf.st_dev; |
|
if(S_ISLNK(stbuf.st_mode)) { |
|
if(!(xorriso->do_follow_links || (xorriso->do_follow_param && !(flag&1)))) |
|
{ret= 2; goto ex;} |
|
if(stat(disk_dir_path, &stbuf)==-1) |
|
goto cannot_open_dir; |
|
if(dir_dev != stbuf.st_dev && |
|
!(xorriso->do_follow_mount || (xorriso->do_follow_param && !(flag&1)))) |
|
{ret= 2; goto ex;} |
|
} |
|
ret= Dirseq_new(&dirseq, disk_dir_path, 1); |
|
if(ret<0) { |
|
sprintf(xorriso->info_text,"Failed to create source filesystem iterator"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
{ret= -1; goto ex;} |
|
} |
|
if(ret==0) { |
|
cannot_open_dir:; |
|
sprintf(xorriso->info_text,"Cannot open as source directory: %s", |
|
Text_shellsafe(disk_dir_path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
{ret= 0; goto ex;} |
|
} |
|
|
|
if(Sfile_str(disk_path, disk_dir_path,0)<=0) |
|
{ret= -1; goto ex;} |
|
if(disk_path[0]==0 || disk_path[strlen(disk_path)-1]!='/') |
|
strcat(disk_path,"/"); |
|
name= disk_path+strlen(disk_path); |
|
if(Sfile_str(img_path, img_dir_path, 0)<=0) |
|
{ret= -1; goto ex;} |
|
if(img_path[0] || img_path[strlen(img_path)-1]!='/') |
|
strcat(img_path,"/"); |
|
img_name= img_path+strlen(img_path); |
|
|
|
while(1) { /* loop over directory content */ |
|
Linkitem_reset_stack(&own_link_stack, link_stack, 0); |
|
srcpt= disk_path; |
|
Xorriso_process_msg_queues(xorriso,0); |
|
ret= Dirseq_next_adr(dirseq,name,0); |
|
if(ret==0) |
|
break; |
|
if(ret<0) { |
|
sprintf(xorriso->info_text,"Failed to obtain next directory entry"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
{ret= -1; goto ex;} |
|
} |
|
strcpy(img_name, name); |
|
if(Xorriso_much_too_long(xorriso, strlen(img_path), 0)<=0) |
|
{ret= 0; goto was_problem;} |
|
if(Xorriso_much_too_long(xorriso, strlen(srcpt), 0)<=0) |
|
{ret= 0; goto was_problem;} |
|
if(lstat(srcpt, &stbuf)==-1) { |
|
cannot_lstat:; |
|
sprintf(xorriso->info_text, |
|
"Cannot determine attributes of source file %s", |
|
Text_shellsafe(srcpt, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0); |
|
ret= 0; goto was_problem; |
|
} |
|
source_is_dir= 0; |
|
source_is_link= S_ISLNK(stbuf.st_mode); |
|
if(xorriso->do_follow_links && source_is_link) { |
|
/* Xorriso_hop_link checks for wide link loops */ |
|
ret= Xorriso_hop_link(xorriso, srcpt, &own_link_stack, &hstbuf, 0); |
|
if(ret<0) |
|
goto was_problem; |
|
if(ret==1) { |
|
ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 0); |
|
if(ret<=0) |
|
goto was_problem; |
|
srcpt= link_target; |
|
if(lstat(srcpt, &stbuf)==-1) |
|
goto cannot_lstat; |
|
} else { |
|
if(Xorriso_eval_problem_status(xorriso, 0, 1|2)<0) |
|
{ret= 0; goto was_problem;} |
|
} |
|
} else if (S_ISLNK(stbuf.st_mode)) { |
|
ret= Xorriso_resolve_link(xorriso, srcpt, link_target, 1); |
|
if(ret<=0) |
|
goto was_problem; |
|
} |
|
do_not_dive= 0; |
|
if(S_ISDIR(stbuf.st_mode)) { |
|
source_is_dir= 1; |
|
if(dir_dev != stbuf.st_dev && !xorriso->do_follow_mount) |
|
do_not_dive= 1; |
|
|
|
#ifdef NIX |
|
} else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) { |
|
sprintf(xorriso->info_text,"Source file %s %s non-supported file type", |
|
Text_shellsafe(disk_path, sfe, 0), |
|
source_is_link ? "leads to" : "is of"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret= 0; goto was_problem; |
|
#endif /* NIX */ |
|
|
|
} |
|
|
|
/* does a node exist with this name ? */ |
|
node= NULL; |
|
ret= Xorriso_node_from_path(xorriso, volume, img_path, &node, 1); |
|
if(ret>0) { |
|
target_is_dir= LIBISO_ISDIR(node); |
|
if(!(target_is_dir && source_is_dir)) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
|
|
/* handle overwrite situation */; |
|
if(xorriso->do_overwrite==1 || |
|
(xorriso->do_overwrite==2 && !target_is_dir)) { |
|
ret= Xorriso_rmi(xorriso, NULL, img_path, 1|8); |
|
if(ret<=0) |
|
goto was_problem; |
|
if(ret==3) { |
|
sprintf(xorriso->info_text, "User revoked adding of: %s", |
|
Text_shellsafe(img_path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
ret= 0; goto was_problem; |
|
} |
|
node= NULL; |
|
} else { |
|
sprintf(xorriso->info_text, |
|
"While grafting %s : file object exists and may not be overwritten", |
|
Text_shellsafe(img_path,sfe,0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret= 0; goto was_problem; |
|
} |
|
} |
|
} |
|
|
|
if(node==NULL) { |
|
if(S_ISLNK(stbuf.st_mode)) { |
|
|
|
/* ??? NG : A80107 : is this solved now ? */ |
|
/* <<< One should rather change libisofs so that iso_tree_add_node() |
|
adds a disk_link as RR link, if RR is enabled */ |
|
|
|
ret= iso_tree_add_new_symlink(dir, img_name, link_target, &iso_symlink); |
|
node= (IsoNode *) iso_symlink; |
|
if(ret>0) { |
|
ret= Xorriso_transfer_properties(xorriso, &stbuf, node, 0); |
|
if(ret<=0) |
|
goto was_problem; |
|
} else |
|
{ret= 0; goto was_problem;} |
|
} else { |
|
ret= iso_tree_add_node(volume, dir, srcpt, &node); |
|
if(ret<0) |
|
goto was_problem; |
|
} |
|
} |
|
if(node==NULL) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, "Grafting failed: %s = %s", |
|
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret=0; goto was_problem; |
|
} |
|
xorriso->volset_change_pending= 1; |
|
if(source_is_dir) { |
|
if(do_not_dive) { |
|
sprintf(xorriso->info_text, "Did not follow mount point : %s", |
|
Text_shellsafe(disk_path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
} else { |
|
ret= Xorriso_add_tree(xorriso, (IsoDir *) node, |
|
img_path, disk_path, own_link_stack, 1); |
|
} |
|
if(ret<=0) |
|
goto was_problem; |
|
} |
|
|
|
continue; /* regular bottom of loop */ |
|
was_problem:; |
|
was_failure= 1; |
|
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2); |
|
if(fret<0) |
|
goto ex; |
|
} |
|
|
|
ret= 1; |
|
ex: |
|
|
|
#ifndef Xorriso_fat_local_meM |
|
if(sfe!=NULL) |
|
free(sfe); |
|
if(sfe2!=NULL) |
|
free(sfe2); |
|
if(disk_path!=NULL) |
|
free(disk_path); |
|
if(img_path!=NULL) |
|
free(img_path); |
|
if(link_target!=NULL) |
|
free(link_target); |
|
#endif /* ! Xorriso_fat_local_meM */ |
|
|
|
Xorriso_process_msg_queues(xorriso,0); |
|
Linkitem_reset_stack(&own_link_stack, link_stack, 0); |
|
Dirseq_destroy(&dirseq, 0); |
|
if(ret<=0) |
|
return(ret); |
|
return(!was_failure); |
|
} |
|
|
|
|
|
/** @param flag bit0= mkdir: graft in as empty directory, not as copy from disk |
|
@return <=0 = error , 1 = added simple node , 2 = added directory */ |
|
int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path, |
|
int flag) |
|
{ |
|
IsoImage *volume; |
|
char path[SfileadrL], *apt, *npt, *cpt, sfe[5*SfileadrL], sfe2[5*SfileadrL]; |
|
IsoDir *dir, *hdir; |
|
IsoNode *node; |
|
int done= 0, is_dir= 0, l, ret, target_is_dir, source_is_dir; |
|
struct stat stbuf; |
|
|
|
for(cpt= img_path; 1; cpt++) { |
|
/* |
|
if(cpt[0]!='/') |
|
break; |
|
*/ |
|
cpt= strstr(cpt,"/."); |
|
if(cpt==NULL) |
|
break; |
|
if(cpt[2]=='.') { |
|
if(cpt[3]=='/' || cpt[3]==0) |
|
break; |
|
} else if(cpt[2]=='/' || cpt[2]==0) |
|
break; |
|
} |
|
if(cpt!=NULL) { |
|
sprintf(xorriso->info_text, |
|
"Unsupported relative addressing in iso_rr_path '%s'", img_path); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0); |
|
return(0); |
|
} |
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0); |
|
if(ret<=0) |
|
return(ret); |
|
|
|
strncpy(path, img_path, sizeof(path)-1); |
|
path[sizeof(path)-1]= 0; |
|
apt= npt= path; |
|
|
|
if(!(flag&1)) { |
|
if(xorriso->do_follow_links || xorriso->do_follow_param) |
|
ret= stat(disk_path, &stbuf); |
|
else |
|
ret= lstat(disk_path, &stbuf); |
|
if(ret == -1) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, |
|
"Cannot determine attributes of source file '%s'",disk_path); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0); |
|
return(0); |
|
} |
|
if(S_ISDIR(stbuf.st_mode)) { |
|
is_dir= 1; |
|
|
|
#ifdef NIX |
|
} else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, |
|
"Source file '%s' is of non-supported file type", disk_path); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
#endif /* NIX */ |
|
|
|
} else { |
|
l= strlen(img_path); |
|
if(l>0) |
|
if(img_path[l-1]=='/') |
|
l= 0; |
|
if(l==0) { |
|
sprintf(xorriso->info_text, |
|
"Source '%s' is not a directory. Target '%s' would be.", |
|
disk_path, img_path); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
} |
|
} |
|
|
|
dir= iso_image_get_root(volume); |
|
if(dir==NULL) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, |
|
"While grafting '%s' : no root node available", img_path); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
return(0); |
|
} |
|
for(npt= apt; !done; apt= npt+1) { |
|
npt= strchr(apt, '/'); |
|
if(npt==NULL) { |
|
npt= apt+strlen(apt); |
|
done= 1; |
|
} else |
|
*npt= 0; |
|
if(*apt==0) { |
|
*apt= '/'; |
|
apt++; |
|
if(done) |
|
goto attach_source; |
|
continue; |
|
} |
|
source_is_dir= (is_dir || (flag&1) || !done); |
|
ret= Xorriso_node_from_path(xorriso, volume, path, &node, 1); |
|
if(ret>0) { |
|
target_is_dir= LIBISO_ISDIR(node); |
|
if(!(target_is_dir && source_is_dir)) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
|
|
/* handle overwrite situation */; |
|
if(xorriso->do_overwrite==1 || |
|
(xorriso->do_overwrite==2 && !target_is_dir)) { |
|
ret= Xorriso_rmi(xorriso, NULL, path, 1|8); |
|
if(ret<=0) |
|
return(ret); |
|
if(ret==3) { |
|
sprintf(xorriso->info_text, "User revoked adding of: %s", |
|
Text_shellsafe(disk_path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
return(0); |
|
} |
|
node= NULL; |
|
goto handle_path_node; |
|
} |
|
|
|
sprintf(xorriso->info_text, |
|
"While grafting '%s' : '%s' exists and may not be overwritten", |
|
img_path, path); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
dir= (IsoDir *) node; |
|
} |
|
|
|
handle_path_node:; |
|
if(node==NULL && source_is_dir) { /* make a directory */ |
|
ret= iso_tree_add_new_dir(dir, apt, &hdir); |
|
if(ret<0) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, |
|
"While grafting '%s' : could not insert '%s'", img_path, path); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
dir= hdir; |
|
xorriso->volset_change_pending= 1; |
|
iso_node_set_ctime((IsoNode *) dir, time(NULL)); |
|
iso_node_set_uid((IsoNode *) dir, geteuid()); |
|
iso_node_set_gid((IsoNode *) dir, getegid()); |
|
|
|
/* >>> copy properties from correspondent directory in disk_path |
|
if there is any */; |
|
|
|
} |
|
if(done) { |
|
attach_source:; |
|
if(flag&1) { |
|
/* directory node was created above */; |
|
|
|
} else if(is_dir) { |
|
Xorriso_transfer_properties(xorriso, &stbuf, (IsoNode *) dir, 0); |
|
ret= Xorriso_add_tree(xorriso, dir, img_path, disk_path, NULL, 0); |
|
if(ret<=0) |
|
return(ret); |
|
|
|
} else { |
|
ret= iso_tree_add_node(volume, dir, disk_path, &node); |
|
if(ret<0) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, "Grafting failed: %s = %s", |
|
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
xorriso->volset_change_pending= 1; |
|
iso_node_set_name(node, apt); |
|
} |
|
} else |
|
*npt= '/'; |
|
} |
|
Xorriso_process_msg_queues(xorriso,0); |
|
return(1+!!is_dir); |
|
} |
|
|
|
|
|
int Xorriso__text_to_sev(char *severity_name, int *severity_number, int flag) |
|
{ |
|
int ret= 1; |
|
|
|
if(severity_name[0]==0) |
|
*severity_number= 0; |
|
else |
|
ret= burn_text_to_sev(severity_name, severity_number, 0); |
|
return(ret); |
|
} |
|
|
|
|
|
int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag) |
|
{ |
|
int ret, error_code= 0, os_errno= 0, count= 0, pass, imgid; |
|
char severity[80]; |
|
|
|
if(!xorriso->libs_are_started) |
|
return(1); |
|
for(pass= 0; pass< 2; pass++) { |
|
while(1) { |
|
if(pass==0) |
|
ret= iso_obtain_msgs("ALL", &error_code, &imgid, |
|
xorriso->info_text, severity); |
|
else |
|
ret= burn_msgs_obtain("ALL", &error_code, xorriso->info_text, &os_errno, |
|
severity); |
|
if(ret<=0) |
|
break; |
|
Xorriso_msgs_submit(xorriso, error_code, xorriso->info_text, os_errno, |
|
severity, (pass+1)<<2); |
|
count++; |
|
} |
|
} |
|
if(xorriso->library_msg_direct_print && count>0) { |
|
sprintf(xorriso->info_text," (%d library messages repeated by xorriso)\n", |
|
count); |
|
Xorriso_info(xorriso, 0); |
|
} |
|
return(1); |
|
} |
|
|
|
|
|
/* @param flag bit0=short report form |
|
bit1=report about output drive |
|
*/ |
|
int Xorriso_toc(struct XorrisO *xorriso, int flag) |
|
{ |
|
int num_sessions= 0, num_tracks= 0, lba= 0, nwa= -1, pmin, psec, pframe, ret; |
|
int track_count= 0, session_no, track_no, profile_no= -1; |
|
int last_track_start= 0, last_track_size= -1, num_data= 0, is_data= 0; |
|
int is_inout_drive= 0, drive_role; |
|
char profile_name[80],*respt,*devadr; |
|
struct burn_disc *disc= NULL; |
|
struct burn_session **sessions; |
|
struct burn_track **tracks; |
|
struct burn_toc_entry toc_entry; |
|
struct burn_drive_info *dinfo; |
|
struct burn_drive *drive; |
|
enum burn_disc_status s; |
|
char mem_text[80]; |
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive, |
|
"on attempt to print Table Of Content", flag&2); |
|
if(ret<=0) |
|
return(0); |
|
|
|
respt= xorriso->result_line; |
|
|
|
if(strcmp(xorriso->indev, xorriso->outdev)==0) |
|
is_inout_drive= 1; |
|
if(flag&2) |
|
devadr= xorriso->outdev; |
|
else |
|
devadr= xorriso->indev; |
|
sprintf(respt, "Drive current: %s '%s'\n", |
|
(is_inout_drive ? "-dev" : (flag&2 ? "-outdev" : "-indev")), |
|
devadr); |
|
Xorriso_result(xorriso,0); |
|
sprintf(respt, "Drive type : vendor '%s' product '%s' revision '%s'\n", |
|
dinfo[0].vendor, dinfo[0].product, dinfo[0].revision); |
|
if(!(flag&1)) |
|
Xorriso_result(xorriso,0); |
|
|
|
sprintf(respt, "Media current: "); |
|
ret= burn_disc_get_profile(drive, &profile_no, profile_name); |
|
if (profile_no > 0 && ret > 0) { |
|
if (profile_name[0]) |
|
sprintf(respt+strlen(respt), "%s", profile_name); |
|
else |
|
sprintf(respt+strlen(respt), "%4.4Xh", profile_no); |
|
drive_role= burn_drive_get_drive_role(drive); |
|
if(drive_role==2) |
|
sprintf(respt+strlen(respt), ", overwriteable"); |
|
else if(drive_role==0 || drive_role==3) |
|
sprintf(respt+strlen(respt), ", sequential"); |
|
strcat(respt, "\n"); |
|
} else |
|
sprintf(respt+strlen(respt), "is not recognizable\n"); |
|
Xorriso_result(xorriso,0); |
|
|
|
sprintf(respt, "Media status : "); |
|
s= isoburn_disc_get_status(drive); |
|
if (s == BURN_DISC_FULL) { |
|
sprintf(respt+strlen(respt), "is written , is closed\n"); |
|
} else if (s == BURN_DISC_APPENDABLE) { |
|
sprintf(respt+strlen(respt), "is written , is appendable\n"); |
|
} else if (s == BURN_DISC_BLANK) { |
|
sprintf(respt+strlen(respt), "is blank\n"); |
|
} else if (s == BURN_DISC_EMPTY) |
|
sprintf(respt+strlen(respt), "is not present\n"); |
|
else |
|
sprintf(respt+strlen(respt), "is not recognizable\n"); |
|
Xorriso_result(xorriso,0); |
|
|
|
if(s != BURN_DISC_FULL && s != BURN_DISC_APPENDABLE) |
|
return(1); |
|
|
|
if(xorriso->request_to_abort) |
|
return(1); |
|
|
|
disc= burn_drive_get_disc(drive); |
|
if (disc==NULL) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
|
|
#define Xorriso_with_isoburn_get_min_start_bytE 1 |
|
#ifdef Xorriso_with_isoburn_get_min_start_bytE |
|
{ off_t start_byte= 0; |
|
ret= isoburn_get_min_start_byte(drive, &start_byte, 0); |
|
nwa= start_byte / 2048; |
|
} |
|
#else |
|
ret= isoburn_disc_track_lba_nwa(drive, NULL, 0, &lba, &nwa); |
|
#endif |
|
|
|
if(ret<=0) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(flag&1) |
|
return(0); |
|
sprintf(xorriso->info_text, "Cannot obtain Table Of Content"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
/* fabricate TOC */ |
|
sprintf(respt, "Media content: session %2d ", 1); |
|
sprintf(respt+strlen(respt), "track %2d %s lba: %9d\n", 1, "data ", 0); |
|
if(!(flag&1)) |
|
Xorriso_result(xorriso,0); |
|
last_track_start= lba; |
|
sprintf(respt, "Media content: session %2d ", 1); |
|
sprintf(respt+strlen(respt), "leadout lba: %9d\n", nwa); |
|
if(!(flag&1)) |
|
Xorriso_result(xorriso,0); |
|
num_data= last_track_size= nwa; |
|
num_sessions= 1; |
|
} else { |
|
sessions= burn_disc_get_sessions(disc, &num_sessions); |
|
for (session_no= 0; session_no<num_sessions && !(xorriso->request_to_abort); |
|
session_no++) { |
|
tracks = burn_session_get_tracks(sessions[session_no], &num_tracks); |
|
if (tracks==NULL) |
|
continue; |
|
for(track_no= 0; track_no<num_tracks && !(xorriso->request_to_abort); |
|
track_no++) { |
|
track_count++; |
|
is_data= 0; |
|
burn_track_get_entry(tracks[track_no], &toc_entry); |
|
if (toc_entry.extensions_valid & 1) { |
|
/* DVD extension valid */ |
|
lba= toc_entry.start_lba; |
|
} else { |
|
lba= burn_msf_to_lba(toc_entry.pmin, toc_entry.psec, toc_entry.pframe); |
|
} |
|
sprintf(respt, "Media content: session %2d ", session_no+1); |
|
sprintf(respt+strlen(respt), "track %2d %s lba: %9d\n", |
|
track_count, ((toc_entry.control&7)<4?"audio":"data "), lba); |
|
if(!(flag&1)) |
|
Xorriso_result(xorriso,0); |
|
last_track_start= lba; |
|
if((toc_entry.control&7)>=4) /* data track */ |
|
is_data= 1; |
|
} |
|
burn_session_get_leadout_entry(sessions[session_no], &toc_entry); |
|
if (toc_entry.extensions_valid & 1) { |
|
lba= toc_entry.start_lba; |
|
burn_lba_to_msf(lba, &pmin, &psec, &pframe); |
|
} else { |
|
lba= burn_msf_to_lba(pmin, psec, pframe); |
|
lba= burn_msf_to_lba(toc_entry.pmin, toc_entry.psec, toc_entry.pframe); |
|
} |
|
sprintf(respt, "Media content: session %2d ", session_no+1); |
|
sprintf(respt+strlen(respt), "leadout lba: %9d\n", lba); |
|
if(!(flag&1)) |
|
Xorriso_result(xorriso,0); |
|
last_track_size= lba - last_track_start; |
|
if(is_data) |
|
num_data+= last_track_size; |
|
} |
|
} |
|
if(xorriso->request_to_abort) |
|
return(1); |
|
Sfile_scale(((double) num_data) * 2048.0, mem_text,5,1e4,1); |
|
sprintf(respt, "Media summary: %d session%s, %d data blocks, %s\n", |
|
num_sessions, (num_sessions==1 ? "" : "s"), num_data, mem_text); |
|
Xorriso_result(xorriso,0); |
|
|
|
if (s == BURN_DISC_APPENDABLE && nwa!=0) { |
|
ret= isoburn_disc_track_lba_nwa(drive, NULL, 0, &lba, &nwa); |
|
if(ret>0) { |
|
sprintf(respt, "Media nwa : %ds\n", nwa); |
|
if(!(flag&1)) |
|
Xorriso_result(xorriso,0); |
|
} |
|
} |
|
|
|
if (disc!=NULL) |
|
burn_disc_free(disc); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
return(1); |
|
} |
|
|
|
|
|
int Xorriso_show_devices(struct XorrisO *xorriso, int flag) |
|
{ |
|
char adr[BURN_DRIVE_ADR_LEN]; |
|
int i; |
|
struct burn_drive_info *drive_list= NULL; |
|
unsigned int drive_count; |
|
char *respt, perms[8]; |
|
struct stat stbuf; |
|
|
|
sprintf(xorriso->info_text, "Beginning to scan for devices ...\n"); |
|
Xorriso_info(xorriso,0); |
|
|
|
burn_drive_clear_whitelist(); |
|
while(!burn_drive_scan(&drive_list, &drive_count)) { |
|
Xorriso_process_msg_queues(xorriso,0); |
|
usleep(100000); |
|
} |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(drive_count <= 0) { |
|
|
|
/* >>> was a drive_list created at all ? */ |
|
/* >>> must it be freed ? */ |
|
|
|
sprintf(xorriso->info_text, "No drives found"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return(0); |
|
} |
|
sprintf(xorriso->info_text, "Full drive scan done\n"); |
|
Xorriso_info(xorriso,0); |
|
|
|
respt= xorriso->result_line; |
|
for(i= 0; i < drive_count && !(xorriso->request_to_abort); i++) { |
|
if(burn_drive_get_adr(&(drive_list[i]), adr)<=0) |
|
strcpy(adr, "-get_adr_failed-"); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(stat(adr,&stbuf)==-1) { |
|
sprintf(perms,"errno=%d",errno); |
|
} else { |
|
strcpy(perms,"------"); |
|
if(stbuf.st_mode&S_IRUSR) perms[0]= 'r'; |
|
if(stbuf.st_mode&S_IWUSR) perms[1]= 'w'; |
|
if(stbuf.st_mode&S_IRGRP) perms[2]= 'r'; |
|
if(stbuf.st_mode&S_IWGRP) perms[3]= 'w'; |
|
if(stbuf.st_mode&S_IROTH) perms[4]= 'r'; |
|
if(stbuf.st_mode&S_IWOTH) perms[5]= 'w'; |
|
} |
|
sprintf(respt, "%d -dev '%s' %s : '%-8.8s' '%s' \n", |
|
i, adr, perms, drive_list[i].vendor, drive_list[i].product); |
|
Xorriso_result(xorriso,0); |
|
} |
|
burn_drive_info_free(drive_list); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
return(1); |
|
} |
|
|
|
|
|
int Xorriso_tell_media_space(struct XorrisO *xorriso, |
|
int *media_space, int *free_space, int flag) |
|
{ |
|
int ret; |
|
struct burn_drive_info *dinfo; |
|
struct burn_drive *drive; |
|
struct burn_write_opts *burn_options; |
|
|
|
(*free_space)= (*media_space)= 0; |
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive, |
|
"on attempt to -tell_media_space", 2); |
|
if(ret<=0) |
|
return(0); |
|
|
|
ret= Xorriso_make_write_options(xorriso, drive, &burn_options, 0); |
|
if(ret<=0) |
|
return(-1); |
|
(*free_space)= (*media_space)= |
|
burn_disc_available_space(drive, burn_options) / (off_t) 2048; |
|
burn_write_opts_free(burn_options); |
|
|
|
if(xorriso->volset_change_pending) { |
|
ret= Xorriso_write_session(xorriso, 1); |
|
if(ret>0) |
|
(*free_space)-= ret; |
|
} |
|
Xorriso_process_msg_queues(xorriso,0); |
|
return(1); |
|
} |
|
|
|
|
|
/* @param flag bit0=fast , bit1=deformat |
|
@return 0=failure, did not touch media , -1=failure, altered media |
|
1=success, altered media , 2=success, did not touch media |
|
*/ |
|
int Xorriso_blank_media(struct XorrisO *xorriso, int flag) |
|
{ |
|
int ret, do_deformat= 0; |
|
struct burn_drive_info *dinfo; |
|
struct burn_drive *drive; |
|
enum burn_disc_status disc_state; |
|
struct burn_progress p; |
|
double percent = 1.0; |
|
int current_profile; |
|
char current_profile_name[80]; |
|
char mode_names[4][80]= {"all", "fast", "deformat", "deformat_quickest"}; |
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive, |
|
"on attempt to -blank", 2); |
|
if(ret<=0) |
|
return(0); |
|
|
|
burn_disc_get_profile(drive, ¤t_profile, current_profile_name); |
|
|
|
/* >>> */; |
|
|
|
disc_state = isoburn_disc_get_status(drive); |
|
if(current_profile == 0x13) { /* overwriteable DVD-RW */ |
|
/* Depending on flag bit1 formatted DVD-RW will get blanked to sequential |
|
state or pseudo blanked by invalidating an eventual ISO image. */ |
|
if(flag&2) |
|
do_deformat= 1; |
|
} else if(current_profile == 0x14) { /* sequential DVD-RW */ |
|
if((flag&1) && !(flag&2)) { |
|
sprintf(xorriso->info_text, |
|
"-blank: DVD-RW present. Mode 'fast' defaulted to mode 'all'."); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
sprintf(xorriso->info_text, |
|
"Mode 'deformat_quickest' produces single-session-only media."); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "HINT", 0); |
|
flag&= ~1; |
|
} |
|
} else if(disc_state == BURN_DISC_BLANK) { |
|
sprintf(xorriso->info_text,"Blank media detected. Will leave it untouched"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
return 2; |
|
} else if(disc_state==BURN_DISC_FULL || disc_state==BURN_DISC_APPENDABLE) { |
|
; |
|
} else if(disc_state == BURN_DISC_EMPTY) { |
|
sprintf(xorriso->info_text,"No media detected in drive"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return 0; |
|
} else { |
|
sprintf(xorriso->info_text, "Unsuitable drive and media state"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return 0; |
|
} |
|
if(!isoburn_disc_erasable(drive)) { |
|
sprintf(xorriso->info_text, "Media is not of erasable type"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
return 0; |
|
} |
|
if(xorriso->do_dummy) { |
|
sprintf(xorriso->info_text, |
|
"-dummy mode prevents blanking of media in mode '%s'.", |
|
mode_names[flag&3]); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
return(1); |
|
} |
|
sprintf(xorriso->info_text, "Beginning to blank media in mode '%s'.\n", |
|
mode_names[flag&3]); |
|
Xorriso_info(xorriso,0); |
|
|
|
if(do_deformat) |
|
burn_disc_erase(drive, (flag&1)); |
|
else |
|
isoburn_disc_erase(drive, (flag&1)); |
|
usleep(1000000); |
|
while (burn_drive_get_status(drive, &p) != BURN_DRIVE_IDLE) { |
|
if(p.sectors>0 && p.sector>=0) /* display 1 to 99 percent */ |
|
percent = 1.0 + ((double) p.sector+1.0) / ((double) p.sectors) * 98.0; |
|
sprintf(xorriso->info_text, "Blanking ( %.1f%% done )", percent); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "UPDATE", 0); |
|
usleep(1000000); |
|
} |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, "Blanking done\n"); |
|
Xorriso_info(xorriso,0); |
|
return(1); |
|
} |
|
|
|
/* @return 0=failure, did not touch media , -1=failure, altered media |
|
1=success, altered media , 2=success, did not touch media |
|
*/ |
|
int Xorriso_format_media(struct XorrisO *xorriso, int flag) |
|
{ |
|
int ret, mode_flag= 0; |
|
struct burn_drive_info *dinfo; |
|
struct burn_drive *drive; |
|
int current_profile; |
|
char current_profile_name[80]; |
|
|
|
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive, |
|
"on attempt to -format", 2); |
|
if(ret<=0) |
|
return(0); |
|
|
|
burn_disc_get_profile(drive, ¤t_profile, current_profile_name); |
|
if(current_profile == 0x14) { |
|
; /* ok DVD-RW sequential */ |
|
} else if(current_profile == 0x1a) { |
|
mode_flag= 2; |
|
} else { |
|
sprintf(xorriso->info_text, |
|
"Can only -format DVD+RW and sequential DVD-RW"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
sprintf(xorriso->info_text,"Media current: %s (%4.4xh)", |
|
current_profile_name, current_profile); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
return 0; |
|
} |
|
|
|
if(xorriso->do_dummy) { |
|
sprintf(xorriso->info_text, "-dummy mode prevents formatting of media."); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
return(1); |
|
} |
|
sprintf(xorriso->info_text, "Beginning to format media.\n"); |
|
Xorriso_info(xorriso, 0); |
|
burn_disc_format(drive, (off_t) 0, mode_flag); |
|
|
|
ret= Xorriso_pacifier_loop(xorriso, drive, 0); |
|
if(ret<=0) |
|
return(ret); |
|
|
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, "Formatting done\n"); |
|
Xorriso_info(xorriso,0); |
|
return(1); |
|
} |
|
|
|
|
|
/* @param boss_iter If not NULL then this is an iterator suitable for |
|
iso_dir_iter_remove() which is then to be used instead |
|
of iso_node_remove(). |
|
@param flag bit0= remove whole sub tree: rm -r |
|
bit1= remove empty directory: rmdir |
|
bit2= recursion: do not reassure in mode 2 "tree" |
|
bit3= this is for overwriting and not for plain removal |
|
@return <=0 = error |
|
1 = removed simple node |
|
2 = removed directory or tree |
|
3 = did not remove on user revocation |
|
*/ |
|
int Xorriso_rmi(struct XorrisO *xorriso, void *boss_iter, |
|
char *path, int flag) |
|
{ |
|
int ret, is_dir= 0, pl, not_removed= 0, fret; |
|
IsoNode *victim_node, *node; |
|
IsoDir *boss_node, *root_dir; |
|
IsoDirIter *iter= NULL; |
|
IsoImage *volume; |
|
char *sub_name, *name; |
|
|
|
#ifdef Xorriso_fat_local_meM |
|
char sfe[5*SfileadrL], sub_path[2*SfileadrL]; |
|
#else |
|
char *sfe= NULL, *sub_path= NULL; |
|
|
|
/* Avoiding large local memory objects in order to save stack space */ |
|
sfe= malloc(5*SfileadrL); |
|
sub_path= malloc(2*SfileadrL); |
|
if(sfe==NULL || sub_path==NULL) { |
|
Xorriso_no_malloc_memory(xorriso, &sfe, 0); |
|
{ret= -1; goto ex;} |
|
} |
|
#endif /* ! Xorriso_fat_local_meM */ |
|
|
|
ret= Xorriso_get_volume(xorriso, &volume, 0); |
|
if(ret<=0) |
|
goto ex; |
|
|
|
if(Xorriso_much_too_long(xorriso, strlen(path), 0)<=0) |
|
{ret= 0; goto ex;} |
|
ret= Xorriso_node_from_path(xorriso, volume, path, &victim_node, 0); |
|
if(ret<=0) |
|
goto ex; |
|
root_dir= iso_image_get_root(volume); |
|
if(((void *) root_dir) == ((void *) victim_node)) { |
|
sprintf(xorriso->info_text, "May not delete root directory"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
{ret= 0; goto ex;} |
|
} |
|
|
|
if(LIBISO_ISDIR(victim_node)) |
|
is_dir= 1; |
|
if(!is_dir) { |
|
if(flag&2) { /* rmdir */ |
|
sprintf(xorriso->info_text, "%s in loaded ISO image is not a directory", |
|
Text_shellsafe(path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret= 0; goto ex; |
|
} |
|
} else { |
|
if(flag&1) { /* rm -r */ |
|
if(xorriso->do_reassure==1 && !xorriso->request_not_to_ask) { |
|
/* Iterate over subordinates and delete them */ |
|
|
|
ret= iso_dir_get_children((IsoDir *) victim_node, &iter); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(ret<0) { |
|
cannot_create_iter:; |
|
sprintf(xorriso->info_text, "Cannot create IsoDirIter object"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
ret= -1; goto ex; |
|
} |
|
pl= strlen(path); |
|
strcpy(sub_path, path); |
|
if(pl==0 || sub_path[pl-1]!='/') { |
|
sub_path[pl++]= '/'; |
|
sub_path[pl]= 0; |
|
} |
|
sub_name= sub_path+pl; |
|
while(iso_dir_iter_next(iter, &node) == 1 |
|
&& !xorriso->request_to_abort) { |
|
name= (char *) iso_node_get_name(node); |
|
if(Xorriso_much_too_long(xorriso, pl+1+strlen(name), 0)<=0) |
|
{ret= 0; goto rm_r_problem_handler;} |
|
strcpy(sub_name, name); |
|
ret= Xorriso_rmi(xorriso, iter, sub_path, (flag&(1|2|8))|4); |
|
if(ret==3 || ret<=0 || xorriso->request_to_abort) { |
|
rm_r_problem_handler:; |
|
not_removed= 1; |
|
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2); |
|
if(fret<0) |
|
goto dir_not_removed; |
|
} |
|
} |
|
if(not_removed) { |
|
dir_not_removed:; |
|
sprintf(xorriso->info_text, "Directory not removed: %s", |
|
Text_shellsafe(path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
if(ret>0) |
|
ret= 3; |
|
goto ex; |
|
} |
|
} |
|
} else { |
|
if(!(flag&2)) { /* not rmdir */ |
|
sprintf(xorriso->info_text, "%s in loaded ISO image is a directory", |
|
Text_shellsafe(path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret= 0; goto ex; |
|
} |
|
|
|
ret= iso_dir_get_children((IsoDir *) victim_node, &iter); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(ret<0) |
|
goto cannot_create_iter; |
|
if(ret>0) { |
|
if(iso_dir_iter_next(iter, &node) == 1) { |
|
sprintf(xorriso->info_text, |
|
"Directory not empty on attempt to delete: %s", |
|
Text_shellsafe(path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret= 0; goto ex; |
|
} |
|
} |
|
} |
|
} |
|
|
|
if(xorriso->request_to_abort) |
|
{ret= 3; goto ex;} |
|
boss_node= iso_node_get_parent(victim_node); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(boss_node==NULL) { |
|
sprintf(xorriso->info_text, |
|
"Cannot find parent node of %s in loaded ISO image", |
|
Text_shellsafe(path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); |
|
ret= 0; goto ex; |
|
} |
|
|
|
while((xorriso->do_reassure==1 || (xorriso->do_reassure==2 && !(flag&4))) |
|
&& !xorriso->request_not_to_ask) { |
|
/* ls -ld */ |
|
Xorriso_ls_filev(xorriso, xorriso->wdi, 1, &path, (off_t) 0, 1|2|8); |
|
if(is_dir) /* du -s */ |
|
Xorriso_ls_filev(xorriso, xorriso->wdi, 1, &path, (off_t) 0, 2|4); |
|
if(flag&8) |
|
sprintf(xorriso->info_text, |
|
"File exists. Remove ? n= keep old, y= remove, x= abort, @= stop asking\n"); |
|
else |
|
sprintf(xorriso->info_text, |
|
"Remove above file ? n= keep it, y= remove it, x= abort, @= stop asking\n"); |
|
Xorriso_info(xorriso, 4); |
|
ret= Xorriso_request_confirmation(xorriso, 1|2|4|16); |
|
if(ret<=0) |
|
goto ex; |
|
if(xorriso->request_to_abort) { |
|
sprintf(xorriso->info_text, |
|
"Removal operation aborted by user before file: %s", |
|
Text_shellsafe(path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
ret= 3; goto ex; |
|
} |
|
if(ret==3) |
|
continue; |
|
if(ret==6) /* yes */ |
|
break; |
|
if(ret==4) { /* yes, do not ask again */ |
|
xorriso->request_not_to_ask= 1; |
|
break; |
|
} |
|
if(ret==1) { /* no */ |
|
sprintf(xorriso->info_text, "Kept in existing state: %s", |
|
Text_shellsafe(path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); |
|
ret= 3; goto ex; |
|
} |
|
} |
|
|
|
if(boss_iter!=NULL) { |
|
ret= iso_dir_iter_remove((IsoDirIter *) boss_iter); |
|
if(ret<0) |
|
ret= -1; |
|
} else |
|
ret= iso_node_remove(victim_node); |
|
Xorriso_process_msg_queues(xorriso,0); |
|
if(ret==-1) { |
|
sprintf(xorriso->info_text, |
|
"Internal failure to remove %s from loaded ISO image", |
|
Text_shellsafe(path, sfe, 0)); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
ret= -1; goto ex; |
|
} |
|
xorriso->volset_change_pending= 1; |
|
ret= 1+!!is_dir; |
|
ex:; |
|
|
|
#ifndef Xorriso_fat_local_meM |
|
if(sfe!=NULL) |
|
free(sfe); |
|
if(sub_path!=NULL) |
|
free(sub_path); |
|
#endif /* ! Xorriso_fat_local_meM */ |
|
|
|
if(iter!=NULL) |
|
iso_dir_iter_free(iter); |
|
return(ret); |
|
} |
|
|
|
|
|
int Xorriso__node_name_cmp(const void *node1, const void *node2) |
|
{ |
|
char *name1, *name2; |
|
|
|
name1= (char *) iso_node_get_name(*((IsoNode **) node1)); |
|
name2= (char *) iso_node_get_name(*((IsoNode **) node2)); |
|
return(strcmp(name1,name2)); |
|
} |
|
|
|
|
|
/* @param flag bit0= only accept directory nodes |
|
bit1= do not report memory usage as DEBUG |
|
bit2= do not apply search pattern but accept any node |
|
*/ |
|
int Xorriso_sorted_node_array(struct XorrisO *xorriso, |
|
IsoDir *dir_node, |
|
int *nodec, IsoNode ***node_array, |
|
off_t boss_mem, int flag) |
|
{ |
|
int i, ret, failed_at; |
|
char *npt; |
|
IsoDirIter *iter= NULL; |
|
IsoNode *node; |
|
off_t mem; |
|
|
|
mem= ((*nodec)+1)*sizeof(IsoNode *); |
|
ret= Xorriso_check_temp_mem_limit(xorriso, mem+boss_mem, flag&2); |
|
if(ret<=0) |
|
return(ret); |
|
|
|
*node_array= calloc(sizeof(IsoNode *), (*nodec)+1); |
|
if(*node_array==NULL) { |
|
sprintf(xorriso->info_text, |
|
"Cannot allocate memory for %d directory entries", *nodec); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
return(-1); |
|
} |
|
|
|
ret= iso_dir_get_children(dir_node, &iter); |
|
if(ret<0) { |
|
sprintf(xorriso->info_text, "Cannot create IsoDirIter object"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
return(-1); |
|
} |
|
|
|
for(i= 0; iso_dir_iter_next(iter, &node) == 1 && i<*nodec; ) { |
|
npt= (char *) iso_node_get_name(node); |
|
if(!(flag&4)) { |
|
ret= Xorriso_regexec(xorriso, npt, &failed_at, 0); |
|
if(ret) |
|
continue; /* no match */ |
|
} |
|
if(flag&1) |
|
if(!LIBISO_ISDIR(node)) |
|
continue; |
|
(*node_array)[i++]= node; |
|
} |
|
iso_dir_iter_free(iter); |
|
*nodec= i; |
|
if(*nodec<=0) |
|
return(1); |
|
qsort(*node_array, *nodec, sizeof(IsoNode *), Xorriso__node_name_cmp); |
|
return(1); |
|
} |
|
|
|
|
|
/* @param flag bit0= do not only sum up sizes but also print subdirs |
|
*/ |
|
int Xorriso_show_du_subs(struct XorrisO *xorriso, IsoDir *dir_node, |
|
char *abs_path, char *rel_path, off_t *size, |
|
off_t boss_mem, int flag) |
|
{ |
|
int i, ret, no_sort= 0, filec= 0, l; |
|
IsoDirIter *iter= NULL; |
|
IsoNode *node, **node_array= NULL; |
|
char *name; |
|
off_t sub_size, report_size, mem= 0; |
|
|
|
#ifdef Xorriso_fat_local_meM |
|
char path[SfileadrL], show_path[SfileadrL], sfe[5*SfileadrL]; |
|
#else /* Xorriso_fat_local_meM */ |
|
char *path= NULL, *show_path= NULL, *sfe= NULL; |
|
|
|
sfe= malloc(5*SfileadrL); |
|
path= malloc(SfileadrL); |
|
show_path= malloc(SfileadrL); |
|
if(path==NULL || show_path==NULL || sfe==NULL) { |
|
Xorriso_no_malloc_memory(xorriso, &sfe, 0); |
|
{ret= -1; goto ex;} |
|
} |
|
|
|
#endif /* ! Xorriso_fat_local_meM */ |
|
|
|
*size= 0; |
|
ret= iso_dir_get_children(dir_node, &iter); |
|
if(ret<0) { |
|
cannot_create_iter:; |
|
Xorriso_process_msg_queues(xorriso,0); |
|
sprintf(xorriso->info_text, "Cannot obtain ISO directory iterator"); |
|
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0); |
|
{ret= -1; goto ex;} |
|
} |
|