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

Implemented oncatenation of split files during -cpx

Browse Source
This commit is contained in:
Thomas Schmitt 2008-05-31 17:40:18 +00:00
parent b9f01ef512
commit 27f8339527
6 changed files with 256 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
xorriso/xorriso.1
View File

@ -1603,7 +1603,7 @@ pseudo-drives or as log files.
But its alter ego, osirrox, is able to extract file objects
from ISO images and to create, overwrite, or delete file objects on disk.
.TP
\fB\-osirrox\fR "on"|"device_files"|"off"
\fB\-osirrox\fR ["on"|"device_files"|"off"][:"concat_split_on"|"concat_split_off"]
Setting "off" disables disk filesystem manipulations. This is the default
unless the program was started with leafname "osirrox". Elsewise
the capability to restore files can be enabled explicitly by -osirrox "on".
@ -1618,6 +1618,11 @@ are ignored during restore operations.
Due to a bug of previous versions, device files from previous sessions might
have been altered to major=0, minor=1. So this combination does not get
restored.
.br
"concat_split_on" is default. It enables restoring of split file directories
as data files if the directory contains a complete collection of -cut_out
part files. With "concat_split_off" such directories are handled as any
other ISO image directory.
.TP
\fB\-cpx\fR iso_rr_path [***] disk_path
Extract single leaf file objects from the ISO image and store them under
@ -1628,6 +1633,10 @@ created. The extracted files get installed in it with the same leafnames.
Missing directory components in disk_path will get created, if possible.
Disk file exclusions are in effect. If this is undesired then perform
-not_mgt "off" first.
.br
Directories are allowed as iso_rr_path only with -osirrox "concat_split_on"
and only if they actually represent a complete collection of -cut_out split
file parts.
.TP
.B Command compatibility emulations:
.PP

93
xorriso/xorriso.c
View File

@ -2460,6 +2460,32 @@ int Splitpart__compose(char *adr, int partno, int total_parts,
}
int Splitparts_cmp(const void *v1, const void *v2)
{
struct SplitparT *p1, *p2;
p1= (struct SplitparT *) v1;
p2= (struct SplitparT *) v2;
if(p1->partno>p2->partno)
return(1);
if(p1->partno<p2->partno)
return(-1);
if(p1->offset>p2->offset)
return(1);
if(p1->offset<p2->offset)
return(-1);
return(0);
}
int Splitparts_sort(struct SplitparT *o, int count, int flag)
{
qsort(o, (size_t) count, sizeof(struct SplitparT), Splitparts_cmp);
return(1);
}
/* ---------------------------- End SplitparT ------------------------- */
/* ------------------------------ ExclusionS ------------------------------ */
@ -2795,6 +2821,7 @@ int Xorriso_new(struct XorrisO ** xorriso,char *progname, int flag)
m->patch_isolinux_image= 0;
m->allow_graft_points= 0;
m->allow_restore= 0;
m->do_concat_split= 1;
m->dialog= 0;
m->search_mode= 0;
m->structured_search= 1;
@ -3902,10 +3929,12 @@ int Xorriso_status(struct XorrisO *xorriso, char *filter, FILE *fp, int flag)
Xorriso_status_result(xorriso,filter,fp,flag&2);
}
is_default= (xorriso->allow_restore==0);
sprintf(line,"-osirrox %s\n",
xorriso->allow_restore ? xorriso->allow_restore==2 ? "device_files" : "on"
: "off");
is_default= (xorriso->allow_restore==0 && xorriso->do_concat_split==1);
sprintf(line,"-osirrox %s:%s\n",
xorriso->allow_restore ? xorriso->allow_restore==2 ?
"device_files" : "on" : "off",
xorriso->do_concat_split ? "concat_split_on" : "concat_split_off");
if(!(is_default && no_defaults))
Xorriso_status_result(xorriso,filter,fp,flag&2);
@ -4644,7 +4673,7 @@ int Xorriso_compare_2_files(struct XorrisO *xorriso, char *disk_adr,
&offset, &bytes, &total_bytes, 0);
strcpy(part_path, iso_adr);
if(Sfile_add_to_path(part_path, part_name, 0)<=0) {
Xorriso_much_too_long(xorriso, strlen(iso_adr)+strlen(part_path)+1,
Xorriso_much_too_long(xorriso, strlen(iso_adr)+strlen(part_name)+1,
2);
{ret= -1; goto ex;}
}
@ -8693,6 +8722,14 @@ int Xorriso_option_cpx(struct XorrisO *xorriso, int argc, char **argv,
char **optv= NULL;
struct stat stbuf;
ret= Xorriso_cpmv_args(xorriso, "-cpx", argc, argv, idx,
&optc, &optv, eff_dest, 1|4);
if(ret<=0)
goto ex;
if(ret==2) {
is_dir= 1;
strcpy(dest_dir, eff_dest);
}
if(!xorriso->allow_restore) {
sprintf(xorriso->info_text,
"-cpx: image-to-disk copies are not enabled by option -osirrox");
@ -8705,14 +8742,6 @@ int Xorriso_option_cpx(struct XorrisO *xorriso, int argc, char **argv,
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
ret= 0; goto ex;
}
ret= Xorriso_cpmv_args(xorriso, "-cpx", argc, argv, idx,
&optc, &optv, eff_dest, 1|4);
if(ret<=0)
goto ex;
if(ret==2) {
is_dir= 1;
strcpy(dest_dir, eff_dest);
}
/* Perform copying */
Xorriso_pacifier_reset(xorriso, 0);
@ -8726,11 +8755,19 @@ int Xorriso_option_cpx(struct XorrisO *xorriso, int argc, char **argv,
if(ret==-1)
goto problem_handler;
if(S_ISDIR(stbuf.st_mode)) {
/* only allow directories if they actually represent split data files */
ret= 0;
if(xorriso->do_concat_split)
ret= Xorriso_is_split(xorriso, eff_origin, NULL, 2);
if(ret<0)
goto problem_handler;
if(ret==0) {
sprintf(xorriso->info_text, "-cpx: May not copy directory %s",
Text_shellsafe(eff_origin, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
ret= 0; goto problem_handler;
}
}
if(is_dir) {
ret= Sfile_leafname(eff_origin, leafname, 0);
@ -9684,8 +9721,8 @@ int Xorriso_option_help(struct XorrisO *xorriso, int flag)
" -compare_r disk_path iso_rr_path ",
" Like -compare but affecting all files below directories.",
"",
"Restore options (copying file objects from ISO image to disk filesystem):",
" -osirrox \"on\"|\"device_files\"|\"off\"",
"Restore options which copy file objects from ISO image to disk filesystem:",
" -osirrox \"on\"|\"device_files\"|\"off\":\"concat_split_on\"|\"concat_split_off\"",
" By default \"off\" the inverse operation of xorriso from ISO",
" image to disk filesystem is disabled. \"on\" allows xorriso",
" to create, overwrite, delete files in the disk filesystem.",
@ -10567,17 +10604,35 @@ ex:;
/* Option -osirrox "on"|"off" */
int Xorriso_option_osirrox(struct XorrisO *xorriso, char *mode, int flag)
{
if(strcmp(mode, "off")==0)
int l;
char *npt, *cpt;
npt= cpt= mode;
for(cpt= mode; npt!=NULL; cpt= npt+1) {
npt= strchr(cpt,':');
if(npt==NULL)
l= strlen(cpt);
else
l= npt-cpt;
if(l==0 && mode[0]!=0)
goto unknown_mode;
if(strncmp(cpt, "off", l)==0)
xorriso->allow_restore= 0;
else if(strcmp(mode, "device_files")==0)
else if(strncmp(cpt, "device_files", l)==0)
xorriso->allow_restore= 2;
else if(strcmp(mode, "on")==0 || mode[0]==0)
else if(strncmp(cpt, "on", l)==0 || mode[0]==0)
xorriso->allow_restore= 1;
else if(strncmp(cpt, "concat_split_on", l)==0)
xorriso->do_concat_split= 1;
else if(strncmp(cpt, "concat_split_off", l)==0)
xorriso->do_concat_split= 0;
else {
sprintf(xorriso->info_text, "-osirrox: unknown mode '%s'", mode);
unknown_mode:;
sprintf(xorriso->info_text, "-osirrox: unknown mode '%s'", cpt);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0);
}
}
sprintf(xorriso->info_text,
"%s copying of file objects from ISO image to disk filesystem\n",
xorriso->allow_restore ? "Enabled" : "Disabled");

5
xorriso/xorriso_private.h
View File

@ -161,6 +161,9 @@ struct XorrisO { /* the global context of xorriso */
int allow_graft_points;
int allow_restore; /* 0= disallowed, 1=allowed, 2=device files allowed */
int do_concat_split; /* 1= restore complete split file directories as
regular files
*/
int dialog;
@ -534,6 +537,8 @@ int Splitpart__parse(char *name, int *partno, int *total_parts,
int Splitpart__compose(char *adr, int partno, int total_parts,
off_t offset, off_t bytes, off_t total_bytes, int flag);
int Splitparts_sort(struct SplitparT *o, int count, int flag);
struct LstrinG {
char *text;
struct LstrinG *prev,*next;

2
xorriso/xorriso_timestamp.h
View File

@ -1 +1 @@
#define Xorriso_timestamP "2008.05.27.201513"
#define Xorriso_timestamP "2008.05.31.174045"

223
xorriso/xorrisoburn.c
View File

@ -69,8 +69,6 @@ int Xorriso_tree_graft_node(struct XorrisO *xorriso, IsoImage *volume,
off_t offset, off_t cut_size,
IsoNode **node, int flag);
int Xorriso_is_split(struct XorrisO *xorriso, IsoNode *node, int flag);
#define LIBISO_ISDIR(node) (iso_node_get_type(node) == LIBISO_DIR)
#define LIBISO_ISREG(node) (iso_node_get_type(node) == LIBISO_FILE)
@ -1949,7 +1947,7 @@ cannot_lstat:;
target_is_dir= LIBISO_ISDIR(node);
target_is_split= 0;
if(target_is_dir)
target_is_split= Xorriso_is_split(xorriso, node, 0);
target_is_split= Xorriso_is_split(xorriso, "", (void *) node, 1);
if(!((target_is_dir && !target_is_split) && source_is_dir)) {
Xorriso_process_msg_queues(xorriso,0);
@ -2264,7 +2262,7 @@ int Xorriso_graft_in(struct XorrisO *xorriso, void *boss_iter,
target_is_split= 0;
if(target_is_dir)
target_is_split= Xorriso_is_split(xorriso, node, 0);
target_is_split= Xorriso_is_split(xorriso, "", (void *) node, 1);
if(!((target_is_dir && !target_is_split) && source_is_dir)) {
Xorriso_process_msg_queues(xorriso,0);
@ -2489,9 +2487,10 @@ int Xorriso_restore_properties(struct XorrisO *xorriso, char *disk_path,
}
/* @param flag >>> bit0= cut_out mode : base on leaf parent directory
/* @param flag
bit1= minimal transfer: access permissions only
bit2= keep directory open: keep owner, allow rwx for owner
push to xorriso->perm_stack
*/
int Xorriso_restore_implicit_properties(struct XorrisO *xorriso,
char *full_disk_path, char *disk_path, char *full_img_path, int flag)
@ -2516,10 +2515,7 @@ int Xorriso_restore_implicit_properties(struct XorrisO *xorriso,
nfdc= Sfile_count_components(nfd, 0);
ndc= Sfile_count_components(nd, 0);
nfic= Sfile_count_components(nfi, 0);
/* >>> ??? (flag&1) */
d= nfdc-(flag&1)-ndc;
d= nfdc-ndc;
if(d<0)
return(-1);
if(d>nfic)
@ -2535,38 +2531,48 @@ int Xorriso_restore_implicit_properties(struct XorrisO *xorriso,
ret= Xorriso_fake_stbuf(xorriso, nfi, &stbuf, &node, 0);
if(ret<=0)
return(0);
ret= Xorriso_restore_properties(xorriso, nfd, node, !!(flag&2));
if(flag&4) {
ret= Permstack_push(&(xorriso->perm_stack), nd, &stbuf, 0);
if(ret<=0) {
Xorriso_msgs_submit(xorriso, 0, nfd, 0, "ERRFILE", 0);
strcpy(xorriso->info_text,
"Cannot memorize permissions for disk directory");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FATAL", 0);
return(-1);
}
}
ret= Xorriso_restore_properties(xorriso, nd, node, !!(flag&2));
if(ret<=0)
return(ret);
sprintf(xorriso->info_text,
"Restored properties for %s", Text_shellsafe(nd, sfe, 0));
sprintf(xorriso->info_text+strlen(xorriso->info_text),
" from %s", Text_shellsafe(nfi, sfe, 0));
/* >>> ??? (flag&1) */
if(!((flag&1) && d==0))
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
return(1);
}
/* @param flag bit0= Minimal transfer: access permissions only
bit1= offset and bytes is valid for writing to regular file
bit2= This is not a parameter. Do not report if ignored
bit3= do not restore properties
@return <0 severe error , 0 failure , 1 success ,
2 regularly not installed (disallowed device, UNIX domain socket)
*/
int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
char *img_path, char *disk_path, int flag)
char *img_path, char *disk_path,
off_t offset, off_t bytes, int flag)
{
int ret= 0, write_fd= -1, wanted, wret;
int ret= 0, write_fd= -1, wanted, wret, open_flags;
char *what= "[unknown filetype]", sfe[5*SfileadrL], sfe2[5*SfileadrL];
char buf[32*1024];
char *link_target;
off_t todo, size;
off_t todo, size, seek_ret;
void *data_stream= NULL;
mode_t mode;
dev_t dev= 0;
struct stat stbuf;
if(LIBISO_ISDIR(node)) {
what= "directory";
@ -2577,12 +2583,37 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
/* >>> need to exploit node rather than img_path */
ret= Xorriso_iso_file_open(xorriso, img_path, &data_stream, 0);
if(ret<=0)
goto ex;
write_fd= open(disk_path,O_WRONLY|O_EXCL|O_CREAT);
open_flags= O_WRONLY|O_CREAT;
if(flag&2) {
ret= stat(disk_path, &stbuf);
if(ret!=-1 && !S_ISREG(stbuf.st_mode)) {
sprintf(xorriso->info_text,
"Restore offset demanded. But filesystem path leads to non-data file %s",
Text_shellsafe(disk_path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
goto cannot_restore;
}
}
if(offset==0 || !(flag&2))
open_flags|= O_EXCL;
write_fd= open(disk_path, open_flags, S_IRUSR|S_IWUSR);
if(write_fd==-1)
goto cannot_restore;
if(flag&2) {
todo= size= bytes;
seek_ret= lseek(write_fd, offset, SEEK_SET);
if(seek_ret == -1) {
sprintf(xorriso->info_text,
"Cannot address byte %.f in filesystem path %s",
(double) offset, Text_shellsafe(disk_path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
goto cannot_restore;
}
} else
todo= size= iso_file_get_size((IsoFile *) node);
while(todo>0) {
wanted= sizeof(buf);
@ -2687,7 +2718,7 @@ cannot_restore:;
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
ret= 0; goto ex;
}
if(LIBISO_ISLNK(node))
if((flag&8) || LIBISO_ISLNK(node))
ret= 1;
else
ret= Xorriso_restore_properties(xorriso, disk_path, node, flag&1);
@ -2717,23 +2748,26 @@ int Xorriso_restore(struct XorrisO *xorriso,
{
IsoImage *volume;
char path[SfileadrL], *apt, *npt, sfe[5*SfileadrL], sfe2[5*SfileadrL];
char *img_path_pt;
IsoNode *node= NULL;
int done= 0, is_dir= 0, ret, target_is_dir, source_is_dir, stbuf_ret;
char *img_path_pt, *part_name;
IsoNode *node= NULL, *part_node, *first_part_node;
int done= 0, is_dir= 0, ret, target_is_dir, source_is_dir, stbuf_ret, hret;
int leaf_is_split= 0, source_is_split= 0, split_count, partno, total_parts, i;
off_t offset, bytes, total_bytes;
struct stat stbuf, target_stbuf;
struct PermiteM *perm_stack_mem;
struct SplitparT *split_parts= NULL;
perm_stack_mem= xorriso->perm_stack;
ret= Xorriso_path_is_excluded(xorriso, disk_path, !(flag&4));
if(ret<0)
return(ret);
goto ex;
if(ret>0)
return(3*!!(flag&16));
{ret= 3*!!(flag&16); goto ex;}
ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0)
return(ret);
goto ex;
strncpy(path, disk_path, sizeof(path)-1);
path[sizeof(path)-1]= 0;
@ -2765,17 +2799,11 @@ int Xorriso_restore(struct XorrisO *xorriso,
"Cannot determine attributes of (ISO) source file %s",
Text_shellsafe(img_path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
return(0);
ret= 0; goto ex;
}
#ifdef Osirrox_not_yeT
/* >>> */
int source_is_split= 0;
if(is_dir)
source_is_split= Xorriso_is_split(xorriso, node, 0);
#endif
if(is_dir && xorriso->do_concat_split)
leaf_is_split= Xorriso_identify_split(xorriso, img_path, node,
&split_parts, &split_count, &stbuf, 1|2);
}
for(npt= apt; !done; apt= npt+1) {
npt= strchr(apt, '/');
@ -2792,28 +2820,23 @@ int Xorriso_restore(struct XorrisO *xorriso,
continue;
}
source_is_dir= (is_dir || (flag&1) || !done);
source_is_split= done && leaf_is_split;
stbuf_ret= stat(path, &target_stbuf);
if(stbuf_ret!=-1) {
target_is_dir= S_ISDIR(target_stbuf.st_mode);
#ifdef Osirrox_not_yeT
/* >>> Take into respect source_is_split */
#endif
if((!target_is_dir) && source_is_dir) {
if(!(target_is_dir && (source_is_dir && !source_is_split))) {
Xorriso_process_msg_queues(xorriso,0);
/* handle overwrite situation */
if(xorriso->do_overwrite==1 ||
(xorriso->do_overwrite==2 && !target_is_dir)) {
ret= Xorriso_rmx(xorriso, (off_t) 0, path, 1|8);
if(ret<=0)
return(ret);
goto ex;
if(ret==3) {
sprintf(xorriso->info_text, "User revoked restoring of: %s",
Text_shellsafe(disk_path, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
return(3*!!(flag&16));
{ret= 3*!!(flag&16); goto ex;}
}
stbuf_ret= -1;
goto handle_path_node;
@ -2823,12 +2846,13 @@ int Xorriso_restore(struct XorrisO *xorriso,
"While restoring '%s' : '%s' exists and may not be overwritten",
disk_path, path);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0);
{ret= 0; goto ex;}
}
}
handle_path_node:;
if(stbuf_ret==-1 && source_is_dir) { /* make a directory */
if(stbuf_ret==-1 && (source_is_dir && !source_is_split)) {
/* make a directory */
ret= mkdir(path, 0777);
if(ret==-1) {
Xorriso_process_msg_queues(xorriso,0);
@ -2838,22 +2862,14 @@ handle_path_node:;
sprintf(xorriso->info_text,
"While restoring '%s' : could not insert '%s'", disk_path, path);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0);
{ret= 0; goto ex;}
}
if(!done) {
ret= Permstack_push(&(xorriso->perm_stack), path, &stbuf, 0);
if(ret<=0) {
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
Xorriso_report_iso_error(xorriso, disk_path, ret,
"Cannot memorize permissions for disk directory", 0, "FATAL", 1);
return(-1);
}
/* keep rwx for the owner */
Xorriso_restore_implicit_properties(xorriso, disk_path, path,
img_path, 4);
/* >>> ???(flag&8) */
}
} else if(source_is_dir) {
} else if(source_is_dir && !source_is_split) {
/* >>> If owner: eventually try to obtain rwx-permssions, stack path */;
@ -2864,7 +2880,7 @@ attach_source:;
if(flag&1) {
/* directory was created above */;
} else if(is_dir) {
} else if(is_dir && !source_is_split) {
Xorriso_restore_properties(xorriso, disk_path, node, !!(flag&64));
#ifdef Osirrox_not_yeT
@ -2872,38 +2888,68 @@ attach_source:;
/* >>> */
if(!(flag&32)) {
ret= Xorriso_add_tree(xorriso, dir, img_path, disk_path, NULL,
ret= Xorriso_add_tree(xorriso, dir, img_path, path, NULL,
flag&2);
if(ret<=0)
return(ret);
goto ex;
}
#endif
} else {
if(source_is_split) {
/* map all files in directory img_path into regular file disk_path */
for(i=0 ; i<split_count; i++) {
Splitparts_get(split_parts, i, &part_name, &partno, &total_parts,
&offset, &bytes, &total_bytes, 0);
strcpy(sfe2, img_path);
if(Sfile_add_to_path(sfe2, part_name, 0)<=0) {
Xorriso_much_too_long(xorriso,
strlen(img_path)+strlen(part_name)+1, 2);
goto restoring_failed;
}
ret= Xorriso_node_from_path(xorriso, volume, sfe2, &part_node, 0);
if(ret<=0)
goto restoring_failed;
if(i==0)
first_part_node= part_node;
if(offset+bytes>total_bytes)
bytes= total_bytes-offset;
ret= Xorriso_tree_restore_node(xorriso, part_node, sfe2, path,
offset, bytes,
(!!(flag&64)) | 2 | (flag&4) | 8);
if(ret<=0)
goto restoring_failed;
}
Xorriso_restore_properties(xorriso, path, first_part_node,
!!(flag&64));
break;
#ifdef Osirrox_not_yeT
if(resolve_link) {
} else if(resolve_link) {
ret= Xorriso_resolve_link(xorriso, disk_path, resolved_disk_path, 0);
if(ret<=0)
return(ret);
goto ex;
disk_path_pt= resolved_disk_path;
} else
#endif /* Osirrox_not_yeT */
} else
img_path_pt= img_path;
ret= Xorriso_tree_restore_node(xorriso, node, img_path_pt, path,
(off_t) 0, (off_t) 0,
(flag&4) | !!(flag&64));
if(ret<=0) {
restoring_failed:;
sprintf(xorriso->info_text, "Restoring failed: %s = %s",
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0);
{ret= 0; goto ex;}
}
if(ret==2)
return(3);
{ret= 3; goto ex;}
xorriso->pacifier_count++;
if(xorriso->pacifier_count%100 && !(flag&2))
Xorriso_pacifier_callback(xorriso, "files restored",
@ -2914,13 +2960,16 @@ attach_source:;
*npt= '/';
}
Xorriso_process_msg_queues(xorriso,0);
ret= 1 + (is_dir && !leaf_is_split);
ex:;
/* restore exact access permissions of stacked paths */
ret= Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso,
hret= Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso,
!!(flag&64));
if(ret<=0)
if(hret<=0 && hret<ret)
ret= hret;
if(split_parts!=NULL)
Splitparts_destroy(&split_parts, split_count, 0);
return(ret);
return(1+!!is_dir);
}
@ -5872,16 +5921,18 @@ int Xorriso_iso_file_close(struct XorrisO *xorriso, void **stream, int flag)
/* @param flag bit0= in_node is valid, do not resolve iso_adr
bit1= insist in complete collection of part files
*/
int Xorriso_identify_split(struct XorrisO *xorriso, char *iso_adr,
void *in_node,
struct SplitparT **parts, int *count,
struct stat *total_stbuf, int flag)
{
int ret, i;
int ret, i, incomplete= 0, overlapping= 0;
int partno, total_parts, first_total_parts= -1;
off_t offset, bytes, total_bytes, first_total_bytes= -1, first_bytes= -1;
off_t size;
off_t size, covered;
IsoImage *volume;
IsoDir *dir_node;
IsoDirIter *iter= NULL;
@ -5970,14 +6021,24 @@ cannot_iter:;
goto ex;
}
/* >>> ??? sort list ? */
for(i= 0; i<*count; i++) {
/* >>> check for disjointness */;
}
Splitparts_sort(*parts, *count, 0);
covered= 0;
for(i= 0; i<*count; i++) {
Splitparts_get(*parts, i, &name, &partno, &total_parts, &offset, &bytes,
&total_bytes, 0);
if(offset>covered)
incomplete= 1;
else if(offset<covered)
overlapping= 1;
if(offset+bytes > covered)
covered= offset+bytes;
}
if(total_bytes>covered)
incomplete= 1;
memcpy(total_stbuf, &first_stbuf, sizeof(struct stat));
total_stbuf->st_size= total_bytes;
ret= 1;
ret= !(overlapping || ((flag&2)&&incomplete));
ex:;
if(iter!=NULL)
iso_dir_iter_free(iter);
@ -5985,14 +6046,18 @@ ex:;
}
int Xorriso_is_split(struct XorrisO *xorriso, IsoNode *node, int flag)
/* @param flag bit0= node is valid, do not resolve path
bit1= insist in complete collection of part files
*/
int Xorriso_is_split(struct XorrisO *xorriso, char *path, void *node,
int flag)
{
struct SplitparT *split_parts= NULL;
int split_count= 0, ret;
struct stat stbuf;
ret= Xorriso_identify_split(xorriso, "", (void *) node, &split_parts,
&split_count, &stbuf, 1);
ret= Xorriso_identify_split(xorriso, path, node, &split_parts,
&split_count, &stbuf, flag&1);
if(split_parts!=NULL)
Splitparts_destroy(&split_parts, split_count, 0);
return(ret>0);

10
xorriso/xorrisoburn.h
View File

@ -225,8 +225,14 @@ int Xorriso_identify_split(struct XorrisO *xorriso, char *iso_adr,
struct SplitparT **parts, int *count,
struct stat *total_stbuf, int flag);
/*
@param flag
/* @param flag bit0= node is valid, do not resolve path
bit1= insist in complete collection of part files
*/
int Xorriso_is_split(struct XorrisO *xorriso, char *path, void *node,
int flag);
/* @param flag
>>> bit0= mkdir: graft in as empty directory, not as copy from iso
bit1= do not report copied files
bit2= -follow, -not_*: this is not a command parameter