legacy/libisoburn/trunk/test/xorrisoburn.c

2803 lines
85 KiB
C
Raw Normal View History

/* 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 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>
2007-10-15 15:27:51 +00:00
#include <sys/stat.h>
#include <time.h>
/* ------------------------------------------------------------------------ */
/* 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"
2007-11-07 12:37:19 +00:00
int Xorriso_pacifier_loop(struct XorrisO *xorriso, struct burn_drive *drive,
int flag);
/* ------------------------------------------------------------------------ */
int Xorriso_startup_libraries(struct XorrisO *xorriso, int flag)
{
int ret;
char *handler_prefix= NULL;
char *queue_sev, *print_sev;
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);
}
ret= isoburn_initialize();
if(ret==0) {
sprintf(xorriso->info_text, "Cannot initialize libraries");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
free(handler_prefix);
return(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_msgs_set_severities(queue_sev, print_sev, "libisofs : ");
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);
2007-10-15 15:27:51 +00:00
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);
}
2007-10-18 18:32:32 +00:00
/* @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);
2007-11-14 14:28:44 +00:00
sprintf(xorriso->info_text, "No %s drive aquired %s",
(flag&2 ? "output" : "input"), attempt);
2007-10-18 18:32:32 +00:00
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
}
*drive= (*dinfo)[0].drive;
2007-10-19 17:35:20 +00:00
return((*drive)!=NULL);
2007-10-18 18:32:32 +00:00
}
2007-11-14 14:28:44 +00:00
int Xorriso_create_empty_iso(struct XorrisO *xorriso, int flag)
{
int ret;
struct iso_volset *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_volset_free((struct iso_volset *) xorriso->in_volset_handle);
xorriso->in_volset_handle= NULL;
xorriso->volset_change_pending= 0;
}
memset(&ropts, sizeof(ropts), 0);
ropts.pretend_blank= 1;
ret= isoburn_read_volset(drive, &ropts, &volset);
Xorriso_process_msg_queues(xorriso,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= volset;
xorriso->volset_change_pending= 0;
return(1);
}
2007-10-15 15:27:51 +00:00
/* @param flag bit0=aquire as isoburn input drive
bit1=aquire as libburn output drive (as isoburn drive if bit0)
2007-11-14 14:28:44 +00:00
@return <=0 failure , 1= ok
2=success, but not writeable with bit1
3=success, but not blank and not ISO with bit0
2007-10-15 15:27:51 +00:00
*/
int Xorriso_aquire_drive(struct XorrisO *xorriso, char *adr, int flag)
{
2007-11-14 14:28:44 +00:00
int ret, hret, not_writeable= 0;
struct burn_drive_info *dinfo= NULL, *out_dinfo, *in_dinfo;
struct burn_drive *drive, *out_drive, *in_drive;
2007-10-15 15:27:51 +00:00
enum burn_disc_status state;
struct iso_volset *volset;
struct isoburn_read_opts ropts;
2007-11-14 14:28:44 +00:00
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);
2007-10-15 15:27:51 +00:00
return(0);
}
2007-11-14 14:28:44 +00:00
ret= Xorriso_give_up_drive(xorriso, (flag&3)|8);
2007-10-15 15:27:51 +00:00
if(ret<=0)
return(ret);
2007-11-14 14:28:44 +00:00
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, 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, adr, 1);
if(ret==1)
dinfo= in_dinfo;
}
if(dinfo==NULL) {
ret= isoburn_drive_scan_and_grab(&dinfo, 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);
}
2007-10-15 15:27:51 +00:00
}
2007-11-14 14:28:44 +00:00
drive= dinfo[0].drive;
state= isoburn_disc_get_status(drive);
Xorriso_process_msg_queues(xorriso,0);
2007-10-19 20:41:34 +00:00
if(flag&2) {
2007-10-15 15:27:51 +00:00
xorriso->out_drive_handle= dinfo;
2007-11-14 14:28:44 +00:00
if(Sfile_str(xorriso->outdev, adr, 0)<=0)
2007-10-19 20:41:34 +00:00
return(-1);
2007-11-14 14:28:44 +00:00
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;
}
2007-10-19 20:41:34 +00:00
}
if(flag&1) {
2007-10-15 15:27:51 +00:00
xorriso->in_drive_handle= dinfo;
2007-11-14 14:28:44 +00:00
if(Sfile_str(xorriso->indev, adr, 0)<=0)
2007-10-19 20:41:34 +00:00
return(-1);
2007-11-14 14:28:44 +00:00
} 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_volset_ref(xorriso->in_volset_handle);
ret= isoburn_attach_volset(drive,
(struct iso_volset *) 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);
}
2007-10-15 15:27:51 +00:00
2007-11-14 14:28:44 +00:00
if(xorriso->in_volset_handle!=NULL)
iso_volset_free((struct iso_volset *) xorriso->in_volset_handle);
xorriso->in_volset_handle= NULL;
2007-10-15 15:27:51 +00:00
/* check for invalid state */
2007-11-14 14:28:44 +00:00
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);
2007-10-15 15:27:51 +00:00
}
/* fill read opts */
2007-11-14 14:28:44 +00:00
memset(&ropts, sizeof(ropts), 0);
2007-10-15 15:27:51 +00:00
ropts.norock= 0;
ropts.nojoliet= 0;
ropts.preferjoliet= 0;
ropts.uid= 0;
ropts.gid= 0;
ropts.mode= 0555;
2007-11-14 14:28:44 +00:00
ropts.pretend_blank= 0;
2007-10-15 15:27:51 +00:00
if(isoburn_read_volset(drive, &ropts, &volset) <= 0) {
Xorriso_process_msg_queues(xorriso,0);
2007-10-17 20:02:45 +00:00
sprintf(xorriso->info_text,"Cannot read ISO image volset");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
2007-11-14 14:28:44 +00:00
ret= 3; goto ex;
2007-10-15 15:27:51 +00:00
}
xorriso->in_volset_handle= volset;
2007-11-14 14:28:44 +00:00
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_volset_ref(xorriso->in_volset_handle);
isoburn_attach_volset(out_drive, xorriso->in_volset_handle);
}
Xorriso_process_msg_queues(xorriso,0);
Xorriso_toc(xorriso, 1);
2007-11-14 14:28:44 +00:00
ret= 1+not_writeable;
2007-10-15 15:27:51 +00:00
ex:
2007-11-14 14:28:44 +00:00
if(ret<=0) {
hret= Xorriso_give_up_drive(xorriso, flag&3);
if(hret<ret)
ret= hret;
2007-10-15 15:27:51 +00:00
}
Xorriso_process_msg_queues(xorriso,0);
2007-10-15 15:27:51 +00:00
return(ret);
}
/* @param flag bit0=input drive
bit1=output drive
2007-10-19 17:35:20 +00:00
bit2=eject
2007-11-14 14:28:44 +00:00
bit3=no info message or toc
2007-10-15 15:27:51 +00:00
*/
int Xorriso_give_up_drive(struct XorrisO *xorriso, int flag)
{
2007-11-14 14:28:44 +00:00
int in_is_out_too, ret;
2007-10-15 15:27:51 +00:00
struct burn_drive_info *dinfo;
struct burn_drive *drive;
in_is_out_too= (xorriso->in_drive_handle == xorriso->out_drive_handle);
if((flag&1) && xorriso->in_drive_handle != NULL) {
2007-10-18 18:32:32 +00:00
Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
2007-11-14 14:28:44 +00:00
"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;
2007-10-15 15:27:51 +00:00
2007-10-18 22:56:43 +00:00
if(xorriso->in_volset_handle!=NULL)
iso_volset_free((struct iso_volset *) xorriso->in_volset_handle);
xorriso->in_volset_handle= NULL;
2007-10-15 22:40:39 +00:00
xorriso->volset_change_pending= 0;
2007-10-15 15:27:51 +00:00
2007-11-14 14:28:44 +00:00
in_is_out_too= 0;
2007-10-15 15:27:51 +00:00
}
if((flag&2) && xorriso->out_drive_handle!=NULL) {
2007-10-18 18:32:32 +00:00
Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
"on attempt to give drive up", 2);
2007-11-14 14:28:44 +00:00
if(!in_is_out_too) {
if(drive!=NULL)
isoburn_drive_release(drive,!!(flag&4));
if(dinfo!=NULL)
burn_drive_info_free(dinfo);
}
2007-10-15 15:27:51 +00:00
xorriso->out_drive_handle= NULL;
2007-10-19 20:41:34 +00:00
xorriso->outdev[0]= 0;
2007-11-14 14:28:44 +00:00
} 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);
}
2007-10-15 15:27:51 +00:00
}
Xorriso_process_msg_queues(xorriso,0);
2007-10-15 15:27:51 +00:00
return(1);
}
2007-10-15 22:40:39 +00:00
2007-10-18 18:32:32 +00:00
int Xorriso_make_write_options(
struct XorrisO *xorriso, struct burn_drive *drive,
struct burn_write_opts **burn_options, int flag)
{
*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);
burn_write_opts_set_multi(*burn_options, !xorriso->do_close);
burn_drive_set_speed(drive, xorriso->speed, xorriso->speed);
burn_write_opts_set_underrun_proof(*burn_options, 1);
return(1);
}
2007-10-19 15:13:16 +00:00
/* @param flag bit0= do not write but only prepare and return size in sectors
*/
2007-11-14 14:28:44 +00:00
int Xorriso_write_session(struct XorrisO *xorriso, int flag)
2007-10-15 15:27:51 +00:00
{
int ret, media_space;
2007-10-15 15:27:51 +00:00
struct isoburn_source_opts sopts;
2007-11-14 14:28:44 +00:00
struct burn_drive_info *dinfo, *source_dinfo;
struct burn_drive *drive, *source_drive;
struct burn_disc *disc= NULL;
2007-10-15 15:27:51 +00:00
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;
2007-11-14 14:28:44 +00:00
enum burn_disc_status s;
2007-10-15 15:27:51 +00:00
2007-10-18 18:32:32 +00:00
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
"on attempt to write", 2);
if(ret<=0)
2007-10-15 15:27:51 +00:00
return(0);
sopts.level= 2;
sopts.flags= ECMA119_ROCKRIDGE;
if(xorriso->do_joliet)
sopts.flags|= ECMA119_JOLIET;
2007-10-15 15:27:51 +00:00
sopts.relaxed_constraints= 0;
sopts.copy_eltorito= 1;
sopts.no_cache_inodes= 0;
sopts.sort_files= 1;
sopts.default_mode= 1;
sopts.replace_dir_mode= xorriso->do_global_mode;
sopts.dir_mode= xorriso->global_dir_mode;
sopts.replace_file_mode= xorriso->do_global_mode;
sopts.file_mode= xorriso->global_file_mode;
2007-10-15 15:27:51 +00:00
sopts.replace_uid= (xorriso->do_global_uid);
sopts.uid= xorriso->global_uid;
sopts.replace_gid= (xorriso->do_global_gid);
sopts.gid= xorriso->global_gid;
sopts.input_charset= NULL;
sopts.ouput_charset= NULL;
sopts.fifo_size= xorriso->fs * 2048;
2007-10-15 15:27:51 +00:00
2007-11-14 14:28:44 +00:00
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);
}
if (ret <= 0) {
Xorriso_process_msg_queues(xorriso,0);
2007-11-14 14:28:44 +00:00
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;}
2007-10-15 15:27:51 +00:00
}
2007-10-18 18:32:32 +00:00
ret= Xorriso_make_write_options(xorriso, drive, &burn_options, 0);
if(ret<=0)
goto ex;
2007-10-19 15:13:16 +00:00
ret= burn_disc_get_sectors(disc);
if(flag&1)
goto ex;
2007-11-14 14:28:44 +00:00
media_space= burn_disc_available_space(drive, burn_options) / (off_t) 2048;
if(media_space < ret) {
Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text,"Image size %ds exceeds free space on media %ds",
ret, media_space);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
{ret= 0; goto ex;}
}
2007-10-15 15:27:51 +00:00
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;
}
2007-10-15 15:27:51 +00:00
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/2048, (int) writecounter/2048);
Xorriso_info(xorriso, 0);
}
}
2007-10-15 15:27:51 +00:00
ret= isoburn_activate_session(drive);
Xorriso_process_msg_queues(xorriso,0);
2007-10-15 15:27:51 +00:00
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;
2007-10-15 15:27:51 +00:00
}
sprintf(xorriso->info_text, "Writing completed sucessfully.\n\n");
Xorriso_info(xorriso, 0);
ret= 1;
ex:;
if(disc!=NULL)
burn_disc_free(disc);
Xorriso_process_msg_queues(xorriso,0);
return(ret);
2007-10-15 15:27:51 +00:00
}
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;
2007-10-15 15:27:51 +00:00
start_time= Sfile_microtime(0);
2007-10-15 15:27:51 +00:00
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);
2007-10-15 15:27:51 +00:00
for(i= 0; i<10; i++) {
Xorriso_process_msg_queues(xorriso, 0);
2007-10-15 15:27:51 +00:00
usleep(100000);
}
}
return(1);
}
2007-10-21 09:48:17 +00:00
int Xorriso_get_volume(struct XorrisO *xorriso, struct iso_volume **volume,
int flag)
2007-10-15 15:27:51 +00:00
{
if(xorriso->in_volset_handle==NULL) {
Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text,"No volset is loaded.");
if(xorriso->indev[0]==0)
2007-10-18 18:32:32 +00:00
sprintf(xorriso->info_text+strlen(xorriso->info_text),
" No -dev or -indev is selected.");
else
2007-10-18 18:32:32 +00:00
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);
}
2007-10-21 09:48:17 +00:00
*volume= iso_volset_get_volume(
(struct iso_volset *) xorriso->in_volset_handle, 0);
return(*volume != NULL);
}
2007-10-21 15:10:41 +00:00
/* @param eff_path returns resulting effective path.
Must provide at least SfileadrL bytes of storage.
2007-10-24 17:53:54 +00:00
@param flag bit0= do not produce problem events (unless faulty path format)
2007-10-21 18:52:03 +00:00
bit1= work purely literally, do not use libisofs
2007-10-27 23:04:35 +00:00
bit2= (with bit1) this is an address in the disk world
2007-10-24 17:53:54 +00:00
@return -1 = faulty path format, 0 = not found ,
2007-10-21 15:10:41 +00:00
1 = found simple node , 2 = found directory
*/
2007-12-15 18:31:39 +00:00
int Xorriso_normalize_img_path(struct XorrisO *xorriso, char *wd,
char *img_path, char eff_path[], int flag)
2007-10-21 15:10:41 +00:00
{
2007-10-24 17:53:54 +00:00
int ret, is_dir= 0, done= 0;
2007-10-21 15:10:41 +00:00
struct iso_volume *volume;
struct iso_tree_node_dir *dir= NULL;
struct iso_tree_node *node= NULL;
char path[SfileadrL], *apt, *npt, sfe[5*SfileadrL], *cpt;
2007-10-21 15:10:41 +00:00
eff_path[0]= 0;
if(img_path[0]==0)
return(2); /* root directory */
2007-10-21 18:52:03 +00:00
if(!(flag&2)) {
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
}
2007-10-21 15:10:41 +00:00
apt= npt= path;
2007-10-27 22:41:24 +00:00
if(img_path[0]!='/') {
2007-12-15 18:31:39 +00:00
strcpy(path, wd);
2007-10-27 22:41:24 +00:00
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);
2007-10-21 15:10:41 +00:00
if(path[0]!='/') {
sprintf(xorriso->info_text,
2007-10-27 22:41:24 +00:00
"Internal error: Unresolvable relative addressing in iso_rr_path '%s'",
img_path);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FATAL", 0);
2007-10-24 17:53:54 +00:00
return(-1);
} else if(path[1]==0)
return(2); /* root directory */
2007-10-21 15:10:41 +00:00
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) {
2007-10-21 18:52:03 +00:00
if(!(flag&2)) {
node= (struct iso_tree_node *) dir;
if(node==NULL) {
bonked_root:;
sprintf(xorriso->info_text,
"Relative addressing in path exceeds root directory: %s",
2007-10-24 17:53:54 +00:00
Text_shellsafe(img_path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(-1);
2007-10-21 18:52:03 +00:00
}
dir= iso_tree_node_get_parent(node);
2007-10-21 15:10:41 +00:00
}
/* truncate eff_path */;
cpt= strrchr(eff_path, '/');
2007-10-21 18:52:03 +00:00
if(cpt==NULL) /* ??? if not flag&2 then this is a bug */
goto bonked_root;
2007-10-21 15:10:41 +00:00
*cpt= 0;
continue;
}
ret= Sfile_add_to_path(eff_path, apt, 0);
if(ret<=0) {
2007-10-27 22:41:24 +00:00
much_too_long:;
2007-10-21 18:52:03 +00:00
sprintf(xorriso->info_text, "Effective path gets much too long (%d)",
2007-11-26 19:22:38 +00:00
(int) (strlen(eff_path)+strlen(apt)+1));
2007-10-21 15:10:41 +00:00
if(!(flag&1))
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
2007-10-24 17:53:54 +00:00
return(-1);
2007-10-21 15:10:41 +00:00
}
2007-10-21 18:52:03 +00:00
if(!(flag&2)) {
dir= (struct iso_tree_node_dir *) node;
node= iso_tree_volume_path_to_node(volume,eff_path);
if(node==NULL) {
sprintf(xorriso->info_text, "Cannot find in ISO image: %s",
Text_shellsafe(eff_path, sfe, 0));
if(!(flag&1))
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
}
if(dir==NULL) /* could be false with "/dir/.." */
dir= iso_tree_node_get_parent(node);
is_dir= LIBISO_ISDIR(node);
2007-10-21 15:10:41 +00:00
}
}
return(1+!!is_dir);
}
int Xorriso_get_node_by_path(struct XorrisO *xorriso,
char *in_path, char *eff_path,
struct iso_tree_node **node, int flag)
{
int ret;
char sfe[5*SfileadrL], path[SfileadrL];
struct iso_volume *volume;
2007-12-15 18:31:39 +00:00
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);
*node= iso_tree_volume_path_to_node(volume,path);
if(*node==NULL) {
sprintf(xorriso->info_text, "Not found in ISO image: %s",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
}
return(1);
}
int Xorriso_transfer_properties(struct XorrisO *xorriso, struct stat *stbuf,
struct iso_tree_node *node, int flag)
{
iso_tree_node_set_permissions(node, stbuf->st_mode & 07777);
iso_tree_node_set_uid(node, stbuf->st_uid);
iso_tree_node_set_gid(node, stbuf->st_gid);
iso_tree_node_set_atime(node, stbuf->st_atime);
iso_tree_node_set_mtime(node, stbuf->st_mtime);
iso_tree_node_set_ctime(node, stbuf->st_ctime);
return(1);
}
2007-11-06 16:32:39 +00:00
/* @param flag bit0= recursion is active */
int Xorriso_add_tree(struct XorrisO *xorriso, struct iso_tree_node_dir *dir,
2007-12-15 18:31:39 +00:00
char *img_dir_path, char *disk_dir_path,
struct LinkiteM *link_stack, int flag)
2007-11-06 16:32:39 +00:00
{
struct iso_volume *volume;
struct iso_tree_node *node;
2007-12-15 18:31:39 +00:00
int ret, target_is_dir, source_is_dir, source_is_link, fret, was_failure= 0;
int do_not_dive;
2007-11-06 16:32:39 +00:00
struct DirseQ *dirseq= NULL;
char sfe[5*SfileadrL], sfe2[5*SfileadrL];
2007-12-15 18:31:39 +00:00
char disk_path[2*SfileadrL], img_path[2*SfileadrL], link_target[SfileadrL];
char *name, *img_name, *srcpt;
struct stat stbuf, hstbuf;
dev_t dir_dev;
struct LinkiteM *own_link_stack;
own_link_stack= link_stack;
2007-11-06 16:32:39 +00:00
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
2007-12-15 18:31:39 +00:00
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))))
return(2);
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))))
return(2);
}
2007-11-06 16:32:39 +00:00
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) {
2007-12-15 18:31:39 +00:00
cannot_open_dir:;
2007-11-06 16:32:39 +00:00
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;}
2007-11-07 12:37:19 +00:00
if(disk_path[0]==0 || disk_path[strlen(disk_path)-1]!='/')
2007-11-06 16:32:39 +00:00
strcat(disk_path,"/");
name= disk_path+strlen(disk_path);
if(Sfile_str(img_path, img_dir_path, 0)<=0)
{ret= -1; goto ex;}
2007-11-07 12:37:19 +00:00
if(img_path[0] || img_path[strlen(img_path)-1]!='/')
2007-11-06 16:32:39 +00:00
strcat(img_path,"/");
img_name= img_path+strlen(img_path);
while(1) { /* loop over directory content */
2007-12-15 18:31:39 +00:00
Linkitem_reset_stack(&own_link_stack, link_stack, 0);
srcpt= disk_path;
2007-11-06 16:32:39 +00:00
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;}
2007-12-15 18:31:39 +00:00
if(Xorriso_much_too_long(xorriso, strlen(srcpt), 0)<=0)
{ret= 0; goto was_problem;}
2007-12-15 18:31:39 +00:00
if(lstat(srcpt, &stbuf)==-1) {
cannot_lstat:;
2007-11-06 16:32:39 +00:00
sprintf(xorriso->info_text,
"Cannot determine attributes of source file %s",
2007-12-15 18:31:39 +00:00
Text_shellsafe(srcpt, sfe, 0));
2007-11-06 16:32:39 +00:00
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0);
ret= 0; goto was_problem;
2007-11-06 16:32:39 +00:00
}
source_is_dir= 0;
2007-12-15 18:31:39 +00:00
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;
2007-11-06 16:32:39 +00:00
if(S_ISDIR(stbuf.st_mode)) {
source_is_dir= 1;
2007-12-15 18:31:39 +00:00
if(dir_dev != stbuf.st_dev && !xorriso->do_follow_mount)
do_not_dive= 1;
2007-11-06 16:32:39 +00:00
} else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) {
2007-12-15 18:31:39 +00:00
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");
2007-11-06 16:32:39 +00:00
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
ret= 0; goto was_problem;
2007-11-06 16:32:39 +00:00
}
/* does a node exist with this name ? */
node= iso_tree_volume_path_to_node(volume,img_path);
if(node!=NULL) {
target_is_dir= (iso_tree_node_get_type(node)==LIBISO_NODE_DIR);
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)) {
2007-11-07 12:37:19 +00:00
ret= Xorriso_rmi(xorriso, NULL, img_path, 1|8);
2007-11-06 16:32:39 +00:00
if(ret<=0)
goto was_problem;
2007-11-07 12:37:19 +00:00
if(ret==3) {
sprintf(xorriso->info_text, "User revoked adding of: %s",
2007-12-15 18:31:39 +00:00
Text_shellsafe(img_path, sfe, 0));
2007-11-07 12:37:19 +00:00
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
ret= 0; goto was_problem;
2007-11-07 12:37:19 +00:00
}
2007-11-06 16:32:39 +00:00
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;
2007-11-06 16:32:39 +00:00
}
}
}
2007-12-15 18:31:39 +00:00
if(node==NULL) {
if(S_ISLNK(stbuf.st_mode)) {
/* <<< One should rather change libisofs so that iso_tree_add_node()
adds a disk_link as RR link, if RR is enabled */
node= iso_tree_add_symlink(dir, img_name, link_target);
if(node!=NULL) {
ret= Xorriso_transfer_properties(xorriso, &stbuf, node, 0);
if(ret<=0)
goto was_problem;
2007-12-15 18:31:39 +00:00
}
} else
node= iso_tree_add_node(dir, srcpt);
}
2007-11-06 16:32:39 +00:00
if(node == NULL) {
Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text,
"While grafting %s=%s : libisofs_errno = %d",
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0),
libisofs_errno);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
ret=0; goto was_problem;
2007-11-06 16:32:39 +00:00
}
xorriso->volset_change_pending= 1;
2007-11-06 16:32:39 +00:00
if(source_is_dir) {
2007-12-15 18:31:39 +00:00
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, (struct iso_tree_node_dir *) node,
img_path, disk_path, own_link_stack, 1);
}
if(ret<=0)
2007-11-06 16:32:39 +00:00
goto was_problem;
}
continue; /* regular bottom of loop */
2007-11-06 16:32:39 +00:00
was_problem:;
was_failure= 1;
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
if(fret<0)
goto ex;
2007-11-06 16:32:39 +00:00
}
ret= 1;
ex:
Xorriso_process_msg_queues(xorriso,0);
2007-12-15 18:31:39 +00:00
Linkitem_reset_stack(&own_link_stack, link_stack, 0);
2007-11-06 16:32:39 +00:00
Dirseq_destroy(&dirseq, 0);
if(ret<=0)
return(ret);
return(!was_failure);
2007-11-06 16:32:39 +00:00
}
2007-10-27 22:41:24 +00:00
/** @param flag bit0= mkdir: graft in as empty directory, not as copy from disk
@return <=0 = error , 1 = added simple node , 2 = added directory */
2007-10-21 09:48:17 +00:00
int Xorriso_graft_in(struct XorrisO *xorriso, char *disk_path, char *img_path,
int flag)
{
struct iso_volume *volume;
char path[SfileadrL], *apt, *npt, *cpt, sfe[5*SfileadrL];
2007-10-21 09:48:17 +00:00
struct iso_tree_node_dir *dir;
struct iso_tree_node *node;
2007-11-06 16:32:39 +00:00
int done= 0, is_dir= 0, l, ret, target_is_dir, source_is_dir;
2007-10-21 09:48:17 +00:00
struct stat stbuf;
2007-10-21 15:10:41 +00:00
for(cpt= img_path; 1; cpt++) {
/*
2007-10-21 15:10:41 +00:00
if(cpt[0]!='/')
break;
*/
2007-10-21 15:10:41 +00:00
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);
}
2007-10-21 09:48:17 +00:00
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
2007-10-15 15:27:51 +00:00
strncpy(path, img_path, sizeof(path)-1);
path[sizeof(path)-1]= 0;
apt= npt= path;
2007-10-27 22:41:24 +00:00
if(!(flag&1)) {
2007-12-15 18:31:39 +00:00
if(xorriso->do_follow_links || xorriso->do_follow_param)
ret= stat(disk_path, &stbuf);
else
ret= lstat(disk_path, &stbuf);
if(ret == -1) {
2007-10-27 22:41:24 +00:00
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;
else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) {
Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text,
2007-10-27 22:41:24 +00:00
"Source file '%s' is of non-supported file type", disk_path);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
2007-10-27 22:41:24 +00:00
return(0);
} 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);
2007-10-27 22:41:24 +00:00
}
}
2007-10-15 15:27:51 +00:00
}
dir= iso_volume_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);
2007-10-15 15:27:51 +00:00
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;
2007-10-15 15:27:51 +00:00
continue;
}
2007-11-06 16:32:39 +00:00
source_is_dir= (is_dir || (flag&1) || !done);
2007-10-15 15:27:51 +00:00
node= iso_tree_volume_path_to_node(volume,path);
if(node!=NULL) {
2007-11-06 16:32:39 +00:00
target_is_dir= (iso_tree_node_get_type(node)==LIBISO_NODE_DIR);
if(!(target_is_dir && source_is_dir)) {
Xorriso_process_msg_queues(xorriso,0);
2007-10-15 15:27:51 +00:00
2007-11-06 16:32:39 +00:00
/* handle overwrite situation */;
if(xorriso->do_overwrite==1 ||
(xorriso->do_overwrite==2 && !target_is_dir)) {
2007-11-07 12:37:19 +00:00
ret= Xorriso_rmi(xorriso, NULL, path, 1|8);
2007-11-06 16:32:39 +00:00
if(ret<=0)
return(ret);
2007-11-07 12:37:19 +00:00
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);
}
2007-11-06 16:32:39 +00:00
node= NULL;
goto handle_path_node;
}
2007-11-06 16:32:39 +00:00
sprintf(xorriso->info_text,
2007-11-06 16:32:39 +00:00
"While grafting '%s' : '%s' exists and may not be overwritten",
img_path, path);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
2007-10-15 15:27:51 +00:00
return(0);
}
dir= (struct iso_tree_node_dir *) node;
2007-11-06 16:32:39 +00:00
}
handle_path_node:;
if(node==NULL && source_is_dir) { /* make a directory */
2007-10-15 15:27:51 +00:00
dir= iso_tree_add_dir(dir, apt);
if(dir==NULL) {
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);
2007-10-15 15:27:51 +00:00
return(0);
}
xorriso->volset_change_pending= 1;
iso_tree_node_set_ctime((struct iso_tree_node *) dir, time(NULL));
/* >>> copy properties from correspondent directory in disk_path
if there is any */;
2007-10-15 15:27:51 +00:00
}
if(done) {
attach_source:;
2007-10-27 22:41:24 +00:00
if(flag&1) {
/* directory node was created above */;
} else if(is_dir) {
2007-12-15 18:31:39 +00:00
ret= Xorriso_add_tree(xorriso, dir, img_path, disk_path, NULL, 0);
2007-11-06 16:32:39 +00:00
if(ret<=0)
return(ret);
2007-10-15 15:27:51 +00:00
} else {
node= iso_tree_add_node(dir, disk_path);
if(node == NULL) {
Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text,
"While grafting '%s'='%s' : libisofs_errno = %d",
img_path, disk_path, libisofs_errno);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
2007-10-15 15:27:51 +00:00
return(0);
}
xorriso->volset_change_pending= 1;
iso_tree_node_set_name(node, apt);
2007-10-15 15:27:51 +00:00
}
} else
*npt= '/';
}
Xorriso_process_msg_queues(xorriso,0);
2007-10-21 09:48:17 +00:00
return(1+!!is_dir);
2007-10-15 15:27:51 +00:00
}
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;
char severity[80];
if(!xorriso->libs_are_started)
return(1);
for(pass= 0; pass< 2; pass++) {
while(1) {
if(pass==0)
ret= iso_msgs_obtain("ALL", &error_code, xorriso->info_text, &os_errno,
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);
}
2007-10-17 18:30:37 +00:00
/* @param flag bit0=short report form
2007-11-14 14:28:44 +00:00
bit1=report about output drive
*/
2007-10-17 18:30:37 +00:00
int Xorriso_toc(struct XorrisO *xorriso, int flag)
{
int num_sessions= 0, num_tracks= 0, lba= 0, nwa= -1, pmin, psec, pframe, ret;
2007-10-17 18:30:37 +00:00
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;
2007-11-14 14:28:44 +00:00
int is_inout_drive= 0;
char profile_name[80],*respt,*devadr;
2007-10-17 18:30:37 +00:00
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];
2007-10-17 18:30:37 +00:00
2007-10-18 18:32:32 +00:00
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
2007-11-14 14:28:44 +00:00
"on attempt to print Table Of Content", flag&2);
2007-10-18 18:32:32 +00:00
if(ret<=0)
2007-10-17 18:30:37 +00:00
return(0);
respt= xorriso->result_line;
2007-11-14 14:28:44 +00:00
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);
2007-10-17 20:02:45 +00:00
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);
2007-10-17 20:02:45 +00:00
2007-10-17 18:30:37 +00:00
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\n", profile_name);
else
sprintf(respt+strlen(respt), "%4.4Xh\n", profile_no);
} 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)
2007-10-17 18:30:37 +00:00
return(1);
2007-11-06 16:32:39 +00:00
if(xorriso->request_to_abort)
return(1);
2007-10-17 18:30:37 +00:00
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
2007-10-17 18:30:37 +00:00
ret= isoburn_disc_track_lba_nwa(drive, NULL, 0, &lba, &nwa);
#endif
2007-10-17 18:30:37 +00:00
if(ret<=0) {
Xorriso_process_msg_queues(xorriso,0);
if(flag&1)
return(0);
2007-10-17 18:30:37 +00:00
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);
2007-10-17 18:30:37 +00:00
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;
2007-10-17 18:30:37 +00:00
} else {
sessions= burn_disc_get_sessions(disc, &num_sessions);
2007-11-06 16:32:39 +00:00
for (session_no= 0; session_no<num_sessions && !(xorriso->request_to_abort);
session_no++) {
2007-10-17 18:30:37 +00:00
tracks = burn_session_get_tracks(sessions[session_no], &num_tracks);
if (tracks==NULL)
continue;
2007-11-06 16:32:39 +00:00
for(track_no= 0; track_no<num_tracks && !(xorriso->request_to_abort);
track_no++) {
2007-10-17 18:30:37 +00:00
track_count++;
is_data= 0;
2007-10-17 18:30:37 +00:00
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);
2007-10-17 18:30:37 +00:00
last_track_start= lba;
if((toc_entry.control&7)>=4) /* data track */
is_data= 1;
2007-10-17 18:30:37 +00:00
}
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);
2007-10-17 20:02:45 +00:00
sprintf(respt+strlen(respt), "leadout lba: %9d\n", lba);
if(!(flag&1))
Xorriso_result(xorriso,0);
2007-10-17 18:30:37 +00:00
last_track_size= lba - last_track_start;
if(is_data)
num_data+= last_track_size;
2007-10-17 18:30:37 +00:00
}
}
2007-11-06 16:32:39 +00:00
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);
2007-10-17 18:30:37 +00:00
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);
}
2007-10-17 18:30:37 +00:00
}
if (disc!=NULL)
burn_disc_free(disc);
Xorriso_process_msg_queues(xorriso,0);
return(1);
}
2007-10-18 17:14:09 +00:00
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;
2007-11-06 16:32:39 +00:00
for(i= 0; i < drive_count && !(xorriso->request_to_abort); i++) {
2007-10-18 17:14:09 +00:00
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)
2007-10-18 18:32:32 +00:00
{
int ret;
2007-10-18 18:32:32 +00:00
struct burn_drive_info *dinfo;
struct burn_drive *drive;
struct burn_write_opts *burn_options;
(*free_space)= (*media_space)= 0;
2007-10-18 18:32:32 +00:00
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;
2007-10-18 18:32:32 +00:00
burn_write_opts_free(burn_options);
if(xorriso->volset_change_pending) {
2007-11-14 14:28:44 +00:00
ret= Xorriso_write_session(xorriso, 1);
if(ret>0)
(*free_space)-= ret;
}
2007-10-19 20:41:34 +00:00
Xorriso_process_msg_queues(xorriso,0);
return(1);
2007-10-18 18:32:32 +00:00
}
2007-10-19 20:41:34 +00:00
/* @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
*/
2007-10-19 20:41:34 +00:00
int Xorriso_blank_media(struct XorrisO *xorriso, int flag)
{
int ret, do_deformat= 0;
2007-10-19 20:41:34 +00:00
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"};
2007-10-19 20:41:34 +00:00
ret= Xorriso_get_drive_handles(xorriso, &dinfo, &drive,
"on attempt to -blank", 2);
if(ret<=0)
return(0);
burn_disc_get_profile(drive, &current_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;
}
2007-10-19 20:41:34 +00:00
} 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]);
2007-10-19 20:41:34 +00:00
Xorriso_info(xorriso,0);
if(do_deformat)
burn_disc_erase(drive, (flag&1));
else
isoburn_disc_erase(drive, (flag&1));
2007-10-19 20:41:34 +00:00
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);
2007-10-19 20:41:34 +00:00
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
*/
2007-10-19 20:41:34 +00:00
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, &current_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);
2007-10-19 20:41:34 +00:00
return(1);
}
2007-10-21 09:48:17 +00:00
int Xorriso_node_from_path(struct XorrisO *xorriso, struct iso_volume *volume,
char *path, struct iso_tree_node **node, int flag)
{
char sfe[5*SfileadrL];
*node= iso_tree_volume_path_to_node(volume, path);
Xorriso_process_msg_queues(xorriso,0);
if(*node==NULL) {
sprintf(xorriso->info_text, "Cannot find path %s in loaded ISO image",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
}
return(1);
}
2007-11-07 12:37:19 +00:00
/* @param boss_iter If not NULL then this is an iterator suitable for
iso_tree_node_remove_iter() which is then to be used instead
of iso_tree_node_remove().
@param flag bit0= remove whole sub tree: rm -r
2007-11-06 16:32:39 +00:00
bit1= remove empty directory: rmdir
2007-11-07 12:37:19 +00:00
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
2007-11-07 12:37:19 +00:00
3 = did not remove on user revocation
2007-10-21 09:48:17 +00:00
*/
2007-11-07 12:37:19 +00:00
int Xorriso_rmi(struct XorrisO *xorriso, void *boss_iter,
char *path, int flag)
2007-10-21 09:48:17 +00:00
{
int ret, is_dir= 0, pl, not_removed= 0, fret;
2007-11-07 12:37:19 +00:00
struct iso_tree_node *victim_node, *node;
struct iso_tree_node_dir *boss_node, *root_dir;
struct iso_tree_iter *iter= NULL;
2007-10-21 09:48:17 +00:00
struct iso_volume *volume;
char sfe[5*SfileadrL], sub_path[2*SfileadrL], *sub_name, *name;
2007-10-21 09:48:17 +00:00
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
2007-11-07 12:37:19 +00:00
goto ex;
2007-10-19 20:41:34 +00:00
2007-11-06 16:32:39 +00:00
if(Xorriso_much_too_long(xorriso, strlen(path), 0)<=0)
2007-11-07 12:37:19 +00:00
{ret= 0; goto ex;}
ret= Xorriso_node_from_path(xorriso, volume, path, &victim_node, 0);
if(ret<=0)
2007-11-07 12:37:19 +00:00
goto ex;
root_dir= iso_volume_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);
return(0);
}
2007-10-21 09:48:17 +00:00
if(LIBISO_ISDIR(victim_node))
is_dir= 1;
2007-11-07 15:01:20 +00:00
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 {
2007-11-07 12:37:19 +00:00
if(flag&1) { /* rm -r */
if(xorriso->do_reassure==1 && !xorriso->request_not_to_ask) {
/* Iterate over subordinates and delete them */
/* this might become standard if access permissions get respected */
iter= iso_tree_node_children((struct iso_tree_node_dir *) victim_node);
Xorriso_process_msg_queues(xorriso,0);
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((node= iso_tree_iter_next(iter)) != NULL
&& !xorriso->request_to_abort) {
name= (char *) iso_tree_node_get_name(node);
if(Xorriso_much_too_long(xorriso, pl+1+strlen(name), 0)<=0)
{ret= 0; goto rm_r_problem_handler;}
2007-11-07 12:37:19 +00:00
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:;
2007-11-07 12:37:19 +00:00
not_removed= 1;
fret= Xorriso_eval_problem_status(xorriso, ret, 1|2);
if(fret<0)
goto dir_not_removed;
}
2007-11-07 12:37:19 +00:00
}
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;
2007-11-07 12:37:19 +00:00
}
}
} else {
2007-10-21 09:48:17 +00:00
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);
2007-11-07 12:37:19 +00:00
ret= 0; goto ex;
2007-10-21 09:48:17 +00:00
}
2007-11-07 12:37:19 +00:00
iter= iso_tree_node_children((struct iso_tree_node_dir *) victim_node);
Xorriso_process_msg_queues(xorriso,0);
if(iso_tree_iter_next(iter)!=NULL) {
2007-11-07 15:01:20 +00:00
sprintf(xorriso->info_text,
"Directory not empty on attempt to delete: %s",
Text_shellsafe(path, sfe, 0));
2007-11-07 12:37:19 +00:00
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
ret= 0; goto ex;
}
2007-10-21 09:48:17 +00:00
}
}
2007-11-07 12:37:19 +00:00
if(xorriso->request_to_abort)
{ret= 3; goto ex;}
2007-10-21 09:48:17 +00:00
boss_node= iso_tree_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);
2007-11-07 12:37:19 +00:00
ret= 0; goto ex;
2007-10-21 09:48:17 +00:00
}
2007-11-07 12:37:19 +00:00
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);
2007-11-07 12:37:19 +00:00
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);
2007-11-07 12:37:19 +00:00
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);
2007-11-07 12:37:19 +00:00
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;
}
2007-11-06 16:32:39 +00:00
}
2007-10-21 09:48:17 +00:00
2007-11-07 12:37:19 +00:00
if(boss_iter!=NULL) {
ret= iso_tree_node_remove_iter((struct iso_tree_iter *) boss_iter);
if(ret<0)
ret= -1;
} else
ret= iso_tree_node_remove(boss_node, victim_node);
2007-10-21 09:48:17 +00:00
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);
2007-11-07 12:37:19 +00:00
ret= -1; goto ex;
2007-10-21 09:48:17 +00:00
}
xorriso->volset_change_pending= 1;
2007-11-07 12:37:19 +00:00
ret= 1+!!is_dir;
ex:;
if(iter!=NULL)
iso_tree_iter_free(iter);
return(ret);
2007-10-21 09:48:17 +00:00
}
2007-11-01 19:11:56 +00:00
int Xorriso__node_name_cmp(const void *node1, const void *node2)
{
char *name1, *name2;
name1= (char *) iso_tree_node_get_name(*((struct iso_tree_node **) node1));
name2= (char *) iso_tree_node_get_name(*((struct iso_tree_node **) 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,
struct iso_tree_node_dir *dir_node,
int *nodec, struct iso_tree_node ***node_array,
off_t boss_mem, int flag)
{
int i, ret, failed_at;
char *npt;
2007-11-01 19:11:56 +00:00
struct iso_tree_iter *iter= NULL;
struct iso_tree_node *node;
off_t mem;
mem= ((*nodec)+1)*sizeof(struct iso_tree_node *);
ret= Xorriso_check_temp_mem_limit(xorriso, mem+boss_mem, flag&2);
if(ret<=0)
return(ret);
2007-11-01 19:11:56 +00:00
*node_array= calloc(sizeof(struct iso_tree_node *), (*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);
}
iter= iso_tree_node_children(dir_node);
for(i= 0; (node= iso_tree_iter_next(iter)) != NULL && i<*nodec; ) {
npt= (char *) iso_tree_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;
}
*nodec= i;
if(*nodec<=0)
return(1);
qsort(*node_array, *nodec, sizeof(struct iso_tree *), 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,
struct iso_tree_node_dir *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;
struct iso_tree_iter *iter= NULL;
struct iso_tree_node *node, **node_array= NULL;
char path[SfileadrL], show_path[SfileadrL], *name, sfe[5*SfileadrL];
2007-11-01 19:11:56 +00:00
off_t sub_size, report_size, mem= 0;
*size= 0;
iter= iso_tree_node_children(dir_node);
if(iter==NULL) {
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;}
}
for(i= 0; (node= iso_tree_iter_next(iter)) != NULL; ) {
sub_size= 0;
name= (char *) iso_tree_node_get_name(node);
strcpy(show_path, rel_path);
if(Sfile_add_to_path(show_path, name, 0)<=0)
goto much_too_long;
if(LIBISO_ISDIR(node)) {
strcpy(path, abs_path);
if(Sfile_add_to_path(path, name, 0)<=0) {
much_too_long:;
2007-11-06 16:32:39 +00:00
Xorriso_much_too_long(xorriso, strlen(path)+strlen(name)+1, 2);
2007-11-01 19:11:56 +00:00
{ret= -1; goto ex;}
}
filec++;
l= strlen(rel_path)+1;
mem+= l;
2007-11-01 19:11:56 +00:00
if(l % sizeof(char *))
mem+= sizeof(char *)-(l % sizeof(char *));
if(flag&1) /* diving and counting is done further below */
continue;
2007-11-01 19:11:56 +00:00
ret= Xorriso_show_du_subs(xorriso, (struct iso_tree_node_dir *) node,
path, show_path, &sub_size, boss_mem, 0);
if(ret<0)
goto ex;
if(ret==0)
continue;
}
/*
2007-11-01 19:11:56 +00:00
sub_size+= iso_tree_node_get_size(node)+strlen(name)+1;
*/
sub_size+= iso_tree_node_get_size(node)+2048;
2007-11-01 19:11:56 +00:00
if(sub_size>0)
(*size)+= sub_size;
Xorriso_process_msg_queues(xorriso,0);
}
if(filec<=0 || !(flag&1))
{ret= 1; goto ex;}
/* Reset iteration */
iso_tree_iter_free(iter);
iter= NULL;
Xorriso_process_msg_queues(xorriso,0);
ret= Xorriso_sorted_node_array(xorriso, dir_node, &filec, &node_array,
boss_mem, 1|2|4);
if(ret<0)
goto ex;
if(ret==0) {
no_sort= 1;
iter= iso_tree_node_children(dir_node);
}
for(i= 0; (no_sort || i<filec) && !(xorriso->request_to_abort); i++) {
2007-11-01 19:11:56 +00:00
if(no_sort) {
node= iso_tree_iter_next(iter);
if(node==NULL)
break;
if(!LIBISO_ISDIR(node))
continue;
} else
node= node_array[i];
sub_size= 0;
name= (char *) iso_tree_node_get_name(node);
strcpy(show_path, rel_path);
if(Sfile_add_to_path(show_path, name, 0)<=0)
goto much_too_long;
strcpy(path, abs_path);
if(Sfile_add_to_path(path, name, 0)<=0)
goto much_too_long;
ret= Xorriso_show_du_subs(xorriso, (struct iso_tree_node_dir *) node,
path, show_path, &sub_size, boss_mem+mem, flag&1);
if(ret<0)
goto ex;
/*
sub_size+= iso_tree_node_get_size(node)+strlen(name)+1;
*/
sub_size+= iso_tree_node_get_size(node)+2048;
if(sub_size>0)
(*size)+= sub_size;
2007-11-01 19:11:56 +00:00
report_size= sub_size/1024;
if(report_size*1024<sub_size)
report_size++;
sprintf(xorriso->result_line, "%7.f ",(double) (report_size));
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
Text_shellsafe(show_path, sfe, 0));
Xorriso_result(xorriso, 0);
}
ret= 1;
ex:;
if(iter!=NULL)
iso_tree_iter_free(iter);
if(node_array!=NULL)
free((char *) node_array);
Xorriso_process_msg_queues(xorriso,0);
return(ret);
}
/* @param flag bit0= *node is already valid */
int Xorriso_fake_stbuf(struct XorrisO *xorriso, char *path, struct stat *stbuf,
struct iso_tree_node **node, int flag)
{
int ret;
struct iso_volume *volume;
2007-12-21 13:16:49 +00:00
memset((char *) stbuf, 0, sizeof(struct stat));
if(!(flag&1)) {
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(-1);
*node= iso_tree_volume_path_to_node(volume,path);
}
if(*node==NULL)
return(0);
/* >>> stbuf->st_dev */
/* >>> stbuf->st_ino */
stbuf->st_mode= iso_tree_node_get_permissions(*node);
if(LIBISO_ISDIR(*node))
stbuf->st_mode|= S_IFDIR;
else if(LIBISO_ISREG(*node))
stbuf->st_mode|= S_IFREG;
else if(LIBISO_ISLNK(*node))
stbuf->st_mode|= S_IFLNK;
/* >>> With directories this should be : number of subdirs + 2 */
/* >>> ??? How to obtain RR hardlink number for other types ? */
stbuf->st_nlink= 1;
stbuf->st_uid= iso_tree_node_get_uid(*node);
stbuf->st_gid= iso_tree_node_get_gid(*node);
/* >>> stbuf->st_rdev */
stbuf->st_size= iso_tree_node_get_size(*node);
stbuf->st_blksize= 2048;
stbuf->st_blocks= stbuf->st_size / (off_t) 2048;
if(stbuf->st_blocks * (off_t) 2048 != stbuf->st_size)
stbuf->st_blocks++;
stbuf->st_atime= iso_tree_node_get_atime(*node);
stbuf->st_mtime= iso_tree_node_get_mtime(*node);
stbuf->st_ctime= iso_tree_node_get_ctime(*node);
return(1);
}
int Xorriso_sorted_dir_i(struct XorrisO *xorriso,
struct iso_tree_node_dir *dir_node,
int *filec, char ***filev, off_t boss_mem, int flag)
{
int i,j,ret;
struct iso_tree_iter *iter= NULL;
struct iso_tree_node *node;
char *name;
off_t mem;
(*filec)= 0;
(*filev)= NULL;
iter= iso_tree_node_children(dir_node);
if(iter==NULL) {
cannot_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;}
}
mem= 0;
for(i= 0; (node= iso_tree_iter_next(iter)) != NULL; ) {
name= (char *) iso_tree_node_get_name(node);
mem+= sizeof(char *)+strlen(name)+8;
(*filec)++;
}
iso_tree_iter_free(iter);
if(*filec==0)
{ret= 1; goto ex;}
ret= Xorriso_check_temp_mem_limit(xorriso, mem+boss_mem, 2);
if(ret<=0)
goto ex;
(*filev)= (char **) calloc(*filec, sizeof(char *));
if(*filev==NULL)
{ret= -1; goto ex; }
iter= iso_tree_node_children(dir_node);
if(iter==NULL)
goto cannot_iter;
for(i= 0; i<*filec; i++) {
name= (char *) iso_tree_node_get_name(iso_tree_iter_next(iter));
(*filev)[i]= strdup(name);
if((*filev)[i]==NULL) {
for(j= 0; j<i; j++)
if((*filev)[j]!=NULL)
free((*filev)[j]);
free((char *) (*filev));
ret= -1; goto ex;
}
}
Sort_argv(*filec, *filev, 0);
ret= 1;
ex:;
if(iter!=NULL)
iso_tree_iter_free(iter);
return(ret);
}
2007-11-01 19:11:56 +00:00
/* @param flag bit0= long format
2007-11-07 12:37:19 +00:00
bit1= do not print count of nodes
2007-11-01 19:11:56 +00:00
bit2= du format
bit3= print directories as themselves (ls -d)
2007-11-01 19:11:56 +00:00
*/
int Xorriso_ls_filev(struct XorrisO *xorriso, char *wd,
int filec, char **filev, off_t boss_mem, int flag)
{
int i, ret, was_error= 0, dfilec= 0, pass, passes;
struct iso_tree_node *node;
struct iso_volume *volume;
2007-12-15 18:31:39 +00:00
char sfe[5*SfileadrL], sfe2[5*SfileadrL], path[SfileadrL];
char link_target[SfileadrL], *rpt, **dfilev= NULL;
off_t size;
struct stat stbuf;
rpt= xorriso->result_line;
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
Sort_argv(filec, filev, 0);
/* Count valid nodes, warn of invalid ones */
for(i= 0; i<filec; i++) {
2007-12-21 13:16:49 +00:00
ret= Xorriso_make_abs_adr(xorriso, wd, filev[i], path, 1|4);
if(ret<=0) {
was_error++;
continue;
}
node= iso_tree_volume_path_to_node(volume,path);
if(node==NULL) {
sprintf(xorriso->info_text, "Not found in ISO image: %s",
Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
was_error++;
continue;
}
}
if((flag&8) && !(flag&(2|4))) {
2007-11-01 19:11:56 +00:00
sprintf(xorriso->info_text, "Valid ISO nodes found: %d\n", filec-was_error);
Xorriso_info(xorriso,1);
2007-11-01 19:11:56 +00:00
if(filec-was_error<=0)
return(!was_error);
}
passes= 1+!(flag&(4|8));
for(pass= 0; pass<passes; pass++)
2007-11-06 16:32:39 +00:00
for(i= 0; i<filec && !(xorriso->request_to_abort); i++) {
rpt[0]= 0;
2007-12-21 13:16:49 +00:00
ret= Xorriso_make_abs_adr(xorriso, wd, filev[i], path, 1|4);
if(ret<=0)
continue;
ret= Xorriso_fake_stbuf(xorriso, path, &stbuf, &node, 0);
if(ret<=0)
continue;
if(LIBISO_ISDIR(node) && !(flag&(4|8))) {
if(pass==0)
continue;
if(filec>1) {
strcpy(xorriso->result_line, "\n");
Xorriso_result(xorriso,0);
sprintf(xorriso->result_line, "%s:\n", Text_shellsafe(filev[i], sfe,0));
Xorriso_result(xorriso,0);
}
ret= Xorriso_sorted_dir_i(xorriso,
(struct iso_tree_node_dir *) node, &dfilec, &dfilev, boss_mem, 0);
if(ret<=0) {
/* >>> libisofs iterator loop and single item Xorriso_lsx_filev() */;
} else {
if(flag&1) {
sprintf(xorriso->result_line, "total %d\n", dfilec);
Xorriso_result(xorriso,0);
}
Xorriso_ls_filev(xorriso, path,
dfilec, dfilev, boss_mem, (flag&1)|2|8);
}
if(dfilec>0)
Sfile_destroy_argv(&dfilec, &dfilev, 0);
continue;
} else
if(pass>0)
continue;
2007-12-15 18:31:39 +00:00
link_target[0]= 0;
2007-11-01 19:11:56 +00:00
if((flag&5)==1) { /* -ls_l */
ret= Xorriso_format_ls_l(xorriso, &stbuf, 0);
if(ret<=0)
continue;
2007-12-15 18:31:39 +00:00
if(LIBISO_ISLNK(node)) {
if(Sfile_str(link_target, (char *) iso_tree_node_symlink_get_dest(
(struct iso_tree_node_symlink *) node), 0)<=0)
link_target[0]= 0;
}
2007-12-20 11:14:49 +00:00
} else if(flag&4) { /* -du or -dus */
size= stbuf.st_size;
if(S_ISDIR(stbuf.st_mode)) {
2007-11-01 19:11:56 +00:00
ret= Xorriso_show_du_subs(xorriso, (struct iso_tree_node_dir *) node,
path, filev[i], &size, boss_mem, flag&1);
if(ret<0)
return(-1);
if(ret==0)
continue;
}
sprintf(rpt, "%7.f ",(double) (size/1024));
}
2007-12-15 18:31:39 +00:00
if(link_target[0] && (flag&5)==1)
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s -> %s\n",
Text_shellsafe(filev[i], sfe, 0),
Text_shellsafe(link_target, sfe2, 0));
else
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
Text_shellsafe(filev[i], sfe, 0));
Xorriso_result(xorriso, 0);
}
return(!was_error);
}
/* This function needs less buffer memory than Xorriso_ls_filev() but cannot
perform structured pattern matching as done by Xorriso_expand_pattern()
for subsequent Xorriso_ls_filev().
@param flag bit0= long format
bit1= only check for directory existence
bit2= do not apply search pattern but accept any file
*/
int Xorriso_ls(struct XorrisO *xorriso, int flag)
{
int ret, is_dir= 0, i, filec= 0, failed_at, no_sort= 0;
struct iso_tree_node *node, **node_array= NULL;
struct iso_tree_node_dir *dir_node;
struct iso_volume *volume;
struct iso_tree_iter *iter= NULL;
2007-12-15 18:31:39 +00:00
char sfe[5*SfileadrL], sfe2[5*SfileadrL], link_target[SfileadrL], *npt, *rpt;
struct stat stbuf;
rpt= xorriso->result_line;
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
ret= Xorriso_node_from_path(xorriso, volume, xorriso->wdi, &node, 0);
if(ret<=0)
goto wdi_is_not_a_dir;
if(LIBISO_ISDIR(node))
is_dir= 1;
if(!is_dir) {
wdi_is_not_a_dir:;
sprintf(xorriso->info_text,
"Working directory path does not lead to a directory in ISO image");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
ret= 0; goto ex;
}
if(flag&2)
{ret= 1; goto ex;}
dir_node= (struct iso_tree_node_dir *) node;
iter= iso_tree_node_children(dir_node);
Xorriso_process_msg_queues(xorriso,0);
for(i= 0; (node= iso_tree_iter_next(iter)) != NULL; ) {
npt= (char *) iso_tree_node_get_name(node);
if(!(flag&4)) {
ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
if(ret)
continue; /* no match */
}
filec++;
}
/* Reset iteration */
iso_tree_iter_free(iter);
iter= NULL;
Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text, "Valid ISO nodes found: %d\n", filec);
Xorriso_info(xorriso,1);
2007-11-01 19:11:56 +00:00
ret= Xorriso_sorted_node_array(xorriso, dir_node, &filec, &node_array, 0,
flag&4);
if(ret<0)
goto ex;
if(ret==0) {
no_sort= 1;
iter= iso_tree_node_children(dir_node);
}
2007-11-06 16:32:39 +00:00
for(i= 0; i<filec && !(xorriso->request_to_abort); i++) {
if(no_sort) {
node= iso_tree_iter_next(iter);
if(node==NULL)
break;
npt= (char *) iso_tree_node_get_name(node);
if(!(flag&4)) {
ret= Xorriso_regexec(xorriso, npt, &failed_at, 0);
if(ret)
continue; /* no match */
}
} else
node= node_array[i];
npt= (char *) iso_tree_node_get_name(node);
2007-12-15 18:31:39 +00:00
link_target[0]= 0;
if(LIBISO_ISLNK(node)) {
if(Sfile_str(link_target, (char *) iso_tree_node_symlink_get_dest(
(struct iso_tree_node_symlink *) node), 0)<=0)
link_target[0]= 0;
}
rpt[0]= 0;
if(flag&1) {
ret= Xorriso_fake_stbuf(xorriso, "", &stbuf, &node, 1);
if(ret<=0)
continue;
ret= Xorriso_format_ls_l(xorriso, &stbuf, 0);
if(ret<=0)
continue;
}
2007-12-15 18:31:39 +00:00
if(link_target[0] && (flag&1))
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s -> %s\n",
Text_shellsafe(npt, sfe, 0),
Text_shellsafe(link_target, sfe2, 0));
else
sprintf(xorriso->result_line+strlen(xorriso->result_line), "%s\n",
Text_shellsafe(npt, sfe, 0));
Xorriso_result(xorriso, 0);
}
ret= 1;
ex:;
if(iter!=NULL)
iso_tree_iter_free(iter);
Xorriso_process_msg_queues(xorriso,0);
if(node_array!=NULL)
free((char *) node_array);
return(1);
}
2007-10-21 09:48:17 +00:00
2007-10-28 16:54:29 +00:00
int Xorriso_rename(struct XorrisO *xorriso, char *origin, char *dest, int flag)
2007-10-27 22:41:24 +00:00
{
int ret, ol, dest_ret;
char sfe[5*SfileadrL], eff_dest[SfileadrL], dir_adr[SfileadrL], *cpt;
char *leafname, eff_origin[SfileadrL], sfe2[5*SfileadrL];
2007-10-27 22:41:24 +00:00
struct iso_volume *volume;
struct iso_tree_node_dir *origin_dir, *dest_dir;
struct iso_tree_node *node;
2007-12-15 18:31:39 +00:00
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, origin, eff_origin, 0);
if(ret<=0)
2007-10-27 22:41:24 +00:00
return(ret);
2007-12-15 18:31:39 +00:00
dest_ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest,1);
if(dest_ret<0)
return(dest_ret);
if(dest_ret==0) { /* obtain eff_dest address despite it does not exist */
2007-12-15 18:31:39 +00:00
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, dest, eff_dest, 2);
if(ret<=0)
return(ret);
}
/* Prevent that destination is a subordinate of origin
(that would be a black hole plopping out of the universe) */
ol= strlen(eff_origin);
if(ol==0) {
sprintf(xorriso->info_text, "May not rename root directory");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
} else if(strcmp(eff_origin, eff_dest)==0) {
sprintf(xorriso->info_text, "Ignored attempt to rename %s to itself",
Text_shellsafe(eff_origin,sfe,0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "WARNING", 0);
return(0);
} else if(strncmp(eff_origin, eff_dest, ol)==0 &&
(eff_dest[ol]==0 || eff_dest[ol]=='/')) {
sprintf(xorriso->info_text,
"May not rename %s to its own sub address %s",
Text_shellsafe(eff_origin,sfe,0), Text_shellsafe(eff_dest,sfe2,0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
}
/* Check whether destination exists and may be not overwriteable */
if(dest_ret==2 && xorriso->do_overwrite!=1) {
sprintf(xorriso->info_text, "Renaming may not overwrite directory: %s",
2007-10-27 22:41:24 +00:00
Text_shellsafe(eff_dest, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
} else if (dest_ret==1 && !xorriso->do_overwrite) {
2007-10-27 22:41:24 +00:00
sprintf(xorriso->info_text, "Renaming may not overwite: %s",
Text_shellsafe(eff_dest, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
return(0);
} else if(dest_ret>0) {
ret= Xorriso_rmi(xorriso, NULL, eff_dest, 1|8);
2007-10-27 22:41:24 +00:00
if(ret<=0)
return(0);
2007-11-07 12:37:19 +00:00
if(ret==3) {
sprintf(xorriso->info_text, "User revoked renaming of: %s",
Text_shellsafe(eff_origin, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
return(0);
}
2007-10-27 22:41:24 +00:00
}
/* Ensure existence of destination directory */
strcpy(dir_adr, eff_dest);
cpt= strrchr(dir_adr, '/');
if(cpt==NULL)
cpt= dir_adr+strlen(dir_adr);
*cpt= 0;
if(dir_adr[0]!=0) {
ret= Xorriso_graft_in(xorriso, NULL, dir_adr, 1);
if(ret<=0)
return(ret);
}
2007-10-27 22:41:24 +00:00
/* Move node */
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
dest_dir= (struct iso_tree_node_dir *)
iso_tree_volume_path_to_node(volume,dir_adr);
strcpy(dir_adr, eff_origin);
2007-10-27 22:41:24 +00:00
cpt= strrchr(dir_adr, '/');
if(cpt==NULL)
cpt= dir_adr+strlen(dir_adr);
*cpt= 0;
origin_dir= (struct iso_tree_node_dir *)
iso_tree_volume_path_to_node(volume,dir_adr);
node= iso_tree_volume_path_to_node(volume,eff_origin);
2007-10-27 22:41:24 +00:00
if(dest_dir==NULL || origin_dir==NULL || node==NULL) {
Xorriso_process_msg_queues(xorriso,0);
2007-10-27 22:41:24 +00:00
sprintf(xorriso->info_text,
"Internal error on rename: confirmed node turns out as NULL");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
return(-1);
}
ret= iso_tree_node_take(origin_dir, node);
if(ret==-1) {
Xorriso_process_msg_queues(xorriso,0);
2007-10-27 22:41:24 +00:00
sprintf(xorriso->info_text,
"Internal error on rename: failed to take node");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
return(-1);
}
iso_tree_add_child(dest_dir, node);
leafname= strrchr(eff_dest, '/');
if(leafname==NULL)
leafname= eff_dest;
else
leafname++;
iso_tree_node_set_name(node, leafname);
Xorriso_process_msg_queues(xorriso,0);
2007-10-27 22:41:24 +00:00
return(1);
}
2007-10-28 16:54:29 +00:00
/* @param flag bit0= do not produce info message on success
@return 1=success,
0=was already directory, -1=was other type, -2=other error
*/
int Xorriso_mkdir(struct XorrisO *xorriso, char *path, int flag)
{
int ret;
char eff_path[SfileadrL], sfe[5*SfileadrL];
2007-10-28 16:54:29 +00:00
2007-12-15 18:31:39 +00:00
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 1);
2007-10-28 16:54:29 +00:00
if(ret<0)
return(-2);
if(ret>0) {
sprintf(xorriso->info_text,"-mkdir: Address already existing %s",
Text_shellsafe(eff_path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0,
(ret==2 ? "WARNING" : "SORRY"), 0);
return(-1+(ret==2));
}
2007-12-15 18:31:39 +00:00
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 2);
2007-10-28 16:54:29 +00:00
if(ret<0)
return(-2);
ret= Xorriso_graft_in(xorriso, NULL, eff_path, 1);
if(ret<=0)
return(-2);
if(!(flag&1)) {
sprintf(xorriso->info_text, "Created directory in ISO image: %s\n",
Text_shellsafe(eff_path,sfe,0));
Xorriso_info(xorriso, 0);
}
return(1);
}
/* @param flag bit0= count results rather than storing them
bit1= this is a recursion
bit2= prepend wd (automatically done if wd[0]!=0)
*/
int Xorriso_obtain_pattern_files_i(
struct XorrisO *xorriso, char *wd, struct iso_tree_node_dir *dir,
int *filec, char **filev, int count_limit, off_t *mem,
int *dive_count, int flag)
{
int ret, failed_at;
struct iso_tree_iter *iter= NULL;
struct iso_tree_node *node;
char adr[SfileadrL], *name;
if(!(flag&2))
*dive_count= 0;
else
(*dive_count)++;
ret= Xorriso_check_for_root_pattern(xorriso, filec, filev, count_limit,
mem, (flag&1)|2);
if(ret!=2)
goto ex;
iter= iso_tree_node_children(dir);
if(iter==NULL) {
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;}
}
while((node= iso_tree_iter_next(iter)) != NULL) {
name= (char *) iso_tree_node_get_name(node);
2007-12-21 13:16:49 +00:00
ret= Xorriso_make_abs_adr(xorriso, wd, name, adr, flag&4);
if(ret<=0)
goto ex;
ret= Xorriso_regexec(xorriso, adr, &failed_at, 1);
if(ret) { /* no match */
if(failed_at <= *dive_count) /* no hope for a match */
continue;
if(!LIBISO_ISDIR(node)) {
/* >>> How to deal with softlinks ? */
continue;
}
/* dive deeper */
ret= Xorriso_obtain_pattern_files_i(
xorriso, adr, (struct iso_tree_node_dir *) node,
filec, filev, count_limit, mem, dive_count, flag|2);
if(ret<=0)
goto ex;
} else {
ret= Xorriso_register_matched_adr(xorriso, adr, count_limit,
filec, filev, mem, (flag&1)|2);
if(ret<=0)
goto ex;
}
}
ret= 1;
ex:;
if(flag&2)
(*dive_count)--;
return(ret);
}
/* @param flag bit0= a match count !=1 is a SORRY event
bit1= with bit0 tolerate 0 matches if pattern is a constant
*/
int Xorriso_expand_pattern(struct XorrisO *xorriso,
int num_patterns, char **patterns, int extra_filec,
2007-11-01 19:11:56 +00:00
int *filec, char ***filev, off_t *mem, int flag)
{
int ret, count= 0, abs_adr= 0, i, was_count, was_filec;
int nonconst_mismatches= 0, dive_count= 0;
char sfe[5*SfileadrL];
struct iso_volume *volume;
struct iso_tree_node_dir *dir= NULL, *root_dir;
*filec= 0;
*filev= NULL;
xorriso->search_mode= 3;
xorriso->structured_search= 1;
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
root_dir= iso_volume_get_root(volume);
2007-10-31 10:34:52 +00:00
if(root_dir==NULL) {
Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text,
"While expanding pattern : Cannot obtain root node of ISO image");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
ret= -1; goto ex;
}
for(i= 0; i<num_patterns; i++) {
ret= Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 0);
if(ret<=0)
return(ret);
if(ret==2)
abs_adr= 4;
if(patterns[i][0]=='/' || abs_adr) {
dir= root_dir;
abs_adr= 4;
} else {
/* This is done so late to allow the following:
It is not an error if xorriso->wdi does not exist yet, but one may
not use it as base for relative address searches.
*/
dir= (struct iso_tree_node_dir *)
iso_tree_volume_path_to_node(volume,xorriso->wdi);
if(dir==NULL) {
Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text,
"While expanding pattern %s : Working directory does not exist in ISO image",
Text_shellsafe(patterns[i], sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
ret= 0; goto ex;
}
if(!LIBISO_ISDIR((struct iso_tree_node *) dir)) {
sprintf(xorriso->info_text,
"Working directory path does not lead to a directory in ISO image");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
ret= 0; goto ex;
}
}
/* count the matches */
was_count= count;
ret= Xorriso_obtain_pattern_files_i(xorriso, "", dir, &count, NULL, 0,
mem, &dive_count, 1 | abs_adr);
if(ret<=0)
goto ex;
if(was_count==count && strcmp(patterns[i],"*")!=0 && (flag&3)!=1) {
count++;
Xorriso_eval_nonmatch(xorriso, patterns[i], &nonconst_mismatches, mem, 0);
}
}
ret= Xorriso_check_matchcount(xorriso, count, nonconst_mismatches,
num_patterns, patterns, flag&1);
if(ret<=0)
goto ex;
count+= extra_filec;
mem+= extra_filec*sizeof(char *);
if(count<=0)
{ret= 0; goto ex;}
ret= Xorriso_alloc_pattern_mem(xorriso, *mem, count, filev, 0);
if(ret<=0)
goto ex;
2007-11-01 19:11:56 +00:00
/* now store addresses */
for(i= 0; i<num_patterns; i++) {
ret= Xorriso_prepare_expansion_pattern(xorriso, patterns[i], 0);
if(ret<=0)
return(ret);
if(ret==2)
abs_adr= 4;
was_filec= *filec;
ret= Xorriso_obtain_pattern_files_i(xorriso, "", dir, filec, *filev, count,
mem, &dive_count, abs_adr);
if(ret<=0)
goto ex;
if(was_filec == *filec && strcmp(patterns[i],"*")!=0) {
(*filev)[*filec]= strdup(patterns[i]);
if((*filev)[*filec]==NULL) {
2007-11-01 19:11:56 +00:00
(*mem)= strlen(patterns[i])+1;
Xorriso_no_pattern_memory(xorriso, *mem, 0);
ret= -1; goto ex;
}
(*filec)++;
}
}
ret= 1;
ex:;
if(ret<=0) {
if(filev!=NULL)
Sfile_destroy_argv(&count, filev, 0);
*filec= 0;
}
return(ret);
}
int Xorriso_set_st_mode(struct XorrisO *xorriso, char *in_path,
mode_t mode_and, mode_t mode_or, int flag)
{
mode_t mode= 0;
int ret;
struct iso_tree_node *node;
char sfe[5*SfileadrL], path[SfileadrL];
ret= Xorriso_get_node_by_path(xorriso, in_path, path, &node, 0);
if(ret<=0)
return(ret);
mode= iso_tree_node_get_permissions(node);
mode= (mode & mode_and) | mode_or;
iso_tree_node_set_permissions(node, mode);
iso_tree_node_set_ctime(node, time(NULL));
sprintf(xorriso->info_text,"Permissions now: %-5.5o %s",
mode, Text_shellsafe(path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
xorriso->volset_change_pending= 1;
return(1);
}
int Xorriso_set_uid(struct XorrisO *xorriso, char *in_path, uid_t uid,
int flag)
{
int ret;
struct iso_tree_node *node;
ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
if(ret<=0)
return(ret);
iso_tree_node_set_uid(node, uid);
iso_tree_node_set_ctime(node, time(NULL));
xorriso->volset_change_pending= 1;
return(1);
}
int Xorriso_set_gid(struct XorrisO *xorriso, char *in_path, gid_t gid,
int flag)
{
int ret;
struct iso_tree_node *node;
ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
if(ret<=0)
return(ret);
iso_tree_node_set_gid(node, gid);
iso_tree_node_set_ctime(node, time(NULL));
xorriso->volset_change_pending= 1;
return(1);
}
/* @parm flag bit0= atime, bit1= ctime, bit2= mtime, bit8=no auto ctime */
int Xorriso_set_time(struct XorrisO *xorriso, char *in_path, time_t t,
int flag)
{
int ret;
struct iso_tree_node *node;
ret= Xorriso_get_node_by_path(xorriso, in_path, NULL, &node, 0);
if(ret<=0)
return(ret);
if(flag&1)
iso_tree_node_set_atime(node, t);
if(flag&2)
iso_tree_node_set_ctime(node, t);
if(flag&4)
iso_tree_node_set_mtime(node, t);
if(!(flag&(2|256)))
iso_tree_node_set_ctime(node, time(NULL));
xorriso->volset_change_pending= 1;
return(1);
}
2007-12-21 13:16:49 +00:00
int Xorriso_findi(struct XorrisO *xorriso, struct FindjoB *job,
void *dir_node_generic, char *dir_path,
struct stat *dir_stbuf, int depth, int flag)
{
int ret;
struct iso_tree_iter *iter= NULL;
struct iso_tree_node_dir *dir_node;
struct iso_tree_node *node;
struct iso_volume *volume;
struct stat stbuf;
char *name, path[SfileadrL], sfe[5*SfileadrL];
dir_node= (struct iso_tree_node_dir *) dir_node_generic;
if(dir_node==NULL) {
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
{ret= -1; goto ex;}
2007-12-22 14:39:12 +00:00
ret= Xorriso_make_abs_adr(xorriso, xorriso->wdi, dir_path, path, 1|2|4);
2007-12-21 13:16:49 +00:00
if(ret<=0)
goto ex;
dir_node= (struct iso_tree_node_dir *)
iso_tree_volume_path_to_node(volume, path);
if(dir_node==NULL)
{ret= 0; goto ex;}
ret= Xorriso_fake_stbuf(xorriso, "", dir_stbuf,
(struct iso_tree_node **) &dir_node, 1);
2007-12-22 14:39:12 +00:00
if(ret<=0)
2007-12-21 13:16:49 +00:00
goto ex;
name= strrchr(dir_path, '/');
if(name==NULL)
name= dir_path;
else
name++;
ret= Findjob_test(job, name, NULL, dir_stbuf, depth, 0);
if(ret<0)
goto ex;
if(ret>0) {
sprintf(xorriso->result_line, "%s\n", Text_shellsafe(dir_path, sfe, 0));
Xorriso_result(xorriso, 0);
}
}
if(!LIBISO_ISDIR((struct iso_tree_node *) dir_node))
{ret= 2; goto ex;}
iter= iso_tree_node_children(dir_node);
if(iter==NULL) {
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;}
}
while((node= iso_tree_iter_next(iter)) != NULL && !xorriso->request_to_abort){
name= (char *) iso_tree_node_get_name(node);
ret= Xorriso_make_abs_adr(xorriso, dir_path, name, path, 4);
if(ret<=0)
goto ex;
ret= Xorriso_fake_stbuf(xorriso, "", &stbuf, &node, 1);
if(ret<0)
goto ex;
if(ret==0)
continue;
ret= Findjob_test(job, name, dir_stbuf, &stbuf, depth, 0);
if(ret<0)
goto ex;
if(ret>0) {
sprintf(xorriso->result_line, "%s\n", Text_shellsafe(path, sfe, 0));
Xorriso_result(xorriso, 0);
}
if(S_ISDIR(stbuf.st_mode)) {
ret= Xorriso_findi(xorriso, job, (void *) node, path,
&stbuf, depth+1, flag);
if(ret<0)
goto ex;
}
}
ret= 1;
ex:;
if(iter!=NULL)
iso_tree_iter_free(iter);
return(ret);
}