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

New option -cut_out

This commit is contained in:
Thomas Schmitt 2008-03-09 14:22:14 +00:00
parent 77300abd94
commit ddc230bcda
7 changed files with 166 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
xorriso/xorriso.1
View File

@ -586,6 +586,30 @@ exist, then iso_rr_path gets deleted.
addressing: Its semantics is similar to -add and thus avoids the pitfalls
inherited from cp -r behavior. Its syntax resembles cp, though.
.TP
\fB\-cut_out\fR disk_path byte_offset byte_count iso_rr_path
WARNING: This option is fewly tested.
Especially it is not coordinated with -compare_r and -update_r.
.br
Map a byte interval of a regular disk file into a regular file in the ISO
image.
This may be necessary if the disk file is larger than a single media, or if
it exceeds the traditional limit of 2 GiB - 2 kiB for old operating systems,
or the limit of 4 GiB - 2 kiB for newer ones.
.br
The clumsy remedy for this limit is to backup file pieces and to concatenate
them at restore time. A well tested chopping size is 2047m.
It is permissible to request a higher byte_count than available. The
resulting file will be truncated to the correct size of a final piece.
To request a byte_offset higher than available yields no file in
the ISO image but a SORRY event.
E.g:
.br
-cut_out disk_file 0 2047m iso_rr_part1
.br
-cut_out disk_file 2047m 2047m iso_rr_part2
.br
-cut_out disk_file 4094m 2047m iso_rr_part3
.TP
\fB\-rm\fR iso_rr_path [***]
Delete the given files from the ISO image.
.br

62
xorriso/xorriso.c
View File

@ -7159,7 +7159,7 @@ int Xorriso_update_interpreter(struct XorrisO *xorriso, void *boss_iter,
if(ret>0) {
deleted= 1;
ret= Xorriso_graft_in(xorriso, boss_iter, disk_path, iso_rr_path,
2|(flag&4));
(off_t) 0, (off_t) 0, 2|(flag&4));
}
sprintf(xorriso->info_text, "Deleted and re-added ");
@ -7173,7 +7173,7 @@ int Xorriso_update_interpreter(struct XorrisO *xorriso, void *boss_iter,
/* iso_adr not existing, size, cannot open iso file, early eof of iso file
content bytes differ */
ret= Xorriso_graft_in(xorriso, boss_iter, disk_path, iso_rr_path,
2|(flag&4));
(off_t) 0, (off_t) 0, 2|(flag&4));
sprintf(xorriso->info_text, "Added/overwrote ");
} else if(compare_result&(4|16|32|256|512|1024)) {
@ -7288,7 +7288,7 @@ int Xorriso_option_add(struct XorrisO *xorriso, int argc, char **argv,
goto problem_handler;
strcpy(source, eff_path);
ret= Xorriso_graft_in(xorriso, NULL, source, target, 0);
ret= Xorriso_graft_in(xorriso, NULL, source, target, (off_t)0, (off_t)0, 0);
if(ret<=0 || xorriso->request_to_abort)
goto problem_handler;
sprintf(xorriso->info_text, "Added to ISO image: %s '%s'='%s'\n",
@ -8052,7 +8052,8 @@ int Xorriso_option_cpri(struct XorrisO *xorriso, int argc, char **argv,
goto problem_handler;
}
}
ret= Xorriso_graft_in(xorriso, NULL, eff_origin, eff_dest, 0);
ret= Xorriso_graft_in(xorriso, NULL, eff_origin, eff_dest,
(off_t) 0, (off_t) 0, 0);
if(ret<=0 || xorriso->request_to_abort)
goto problem_handler;
sprintf(xorriso->info_text, "Added to ISO image: %s '%s'='%s'\n",
@ -8079,15 +8080,37 @@ ex:;
/* Option -cut_out */
int Xorriso_option_cut_out(struct XorrisO *xorriso, char *disk_path,
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag)
char *start, char *count, char *iso_rr_path, int flag)
{
int ret;
double num;
off_t startbyte, bytecount;
fprintf(stderr,
">>> LIBISOFS : would cut out from %s , byte %.f to %.f, and graft as %s",
num= Scanf_io_size(start, 0);
if(num<0 || num > 1.0e18) { /* 10^18 = 10^3 ^ 6 < 2^10 ^ 6 = 2^60 */
sprintf(xorriso->info_text,
"-cut_out: startbyte address negative or much too large (%s)", start);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0);
}
startbyte= num;
num= Scanf_io_size(count, 0);
if(num<=0 || num > 1.0e18) {
sprintf(xorriso->info_text,
"-cut_out: bytecount zero, negative or much too large (%s)", count);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0);
}
bytecount= num;
sprintf(xorriso->info_text,
"-cut_out from %s , byte %.f to %.f, and graft as %s",
disk_path, (double) startbyte, (double) (startbyte+bytecount),
iso_rr_path);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
return(1);
ret= Xorriso_cut_out(xorriso, disk_path, startbyte, bytecount,
iso_rr_path, 0);
return(ret);
}
@ -10258,8 +10281,7 @@ return:
{
int ret, was_dashed, end_ret;
int num1, num2;
double d1, d2;
char *cmd, *arg1, *arg2, *arg4;
char *cmd, *arg1, *arg2;
if(xorriso==NULL)
return(0);
@ -10386,17 +10408,15 @@ next_command:;
ret= Xorriso_option_cpri(xorriso, argc, argv, idx, 0);
} else if(strcmp(cmd,"cut_out")==0) {
(*idx)+= 2;
d1= d2= -1;
sscanf(arg2,"%lf", &d1);
if((*idx)<argc)
sscanf(argv[*idx],"%lf", &d2);
if((*idx)+1<argc)
arg4= argv[(*idx)+1];
else
arg4= "";
(*idx)+= 2;
ret= Xorriso_option_cut_out(xorriso, arg1, (off_t) d1, (off_t) d2, arg4, 0);
(*idx)+= 4;
if((*idx)>argc) {
sprintf(xorriso->info_text,
"-cut_out: Not enough arguments. Needed are: disk_path start count so_rr_path");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
ret= 0;
} else
ret= Xorriso_option_cut_out(xorriso, arg1, arg2,
argv[(*idx)-2], argv[(*idx)-1], 0);
} else if(strcmp(cmd,"dev")==0) {
(*idx)++;

8
xorriso/xorriso.h
View File

@ -233,11 +233,9 @@ int Xorriso_option_compare(struct XorrisO *xorriso, char *disk_path,
int Xorriso_option_cpri( struct XorrisO *xorriso, int argc, char **argv,
int *idx, int flag);
/* >>> not yet implemented
/ * Option -cut_out * /
int Xorriso_option_cut_out(struct XorrisO *xorriso, char *disk_path,
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag);
*/
/* Option -cut_out */
int Xorriso_option_cut_out(struct XorrisO *xorriso, char *disk_path,
char *start, char *count, char *iso_rr_path, int flag);
/* Options -dev , -indev, -outdev */
/* @param flag bit0=use as indev , bit1= use as outdev

3
xorriso/xorriso_private.h
View File

@ -368,6 +368,9 @@ char *Text_shellsafe(char *in_text, char *out_text, int flag);
int Sort_argv(int argc, char **argv, int flag);
/* @param flag bit0= single letters */
char *Ftypetxt(mode_t st_mode, int flag);
struct DirseQ;
int Dirseq_new(struct DirseQ **o, char *adr, int flag);

2
xorriso/xorriso_timestamp.h
View File

@ -1 +1 @@
#define Xorriso_timestamP "2008.03.08.104231"
#define Xorriso_timestamP "2008.03.09.142200"

103
xorriso/xorrisoburn.c
View File

@ -1433,10 +1433,14 @@ int Xorriso_transfer_properties(struct XorrisO *xorriso, struct stat *stbuf,
}
/* Ticket 132 : Workaround for missing feature iso_tree_add_new_node() */
/* Ticket 132 : Former workaround for missing feature iso_tree_add_new_node()
which is now available and gets used here.
@param flag bit3= cut_out_node: offset and size are valid
*/
int Xorriso_tree_graft_node(struct XorrisO *xorriso, IsoImage *volume,
IsoDir *dir, char *disk_path, char *img_name,
char *nominal_source, char *nominal_target,
off_t offset, off_t cut_size,
IsoNode **node, int flag)
{
int ret;
@ -1473,7 +1477,11 @@ int Xorriso_tree_graft_node(struct XorrisO *xorriso, IsoImage *volume,
#else /* Xorriso_workaround_ticket_132 */
ret= iso_tree_add_new_node(volume, dir, img_name, disk_path, node);
if(flag&8)
ret= iso_tree_add_new_cut_out_node(volume, dir, img_name, disk_path,
offset, cut_size, node);
else
ret= iso_tree_add_new_node(volume, dir, img_name, disk_path, node);
#endif /* Xorriso_workaround_ticket_132 */
@ -1691,13 +1699,13 @@ cannot_lstat:;
#ifdef NIX
ret= iso_tree_add_node(volume, dir, srcpt, &node);
if(ret<0) {
Xorriso_report_iso_error(xorriso, stbuf_src, ret,
Xorriso_report_iso_error(xorriso, "", ret,
"Cannot add node to tree", 0, "FAILURE", 1|2);
goto was_problem;
}
#else
ret= Xorriso_tree_graft_node(xorriso, volume, dir, srcpt, img_name,
stbuf_src, img_path,
"", img_path, (off_t) 0, (off_t) 0,
&node, 0);
#endif
}
@ -1835,10 +1843,12 @@ int Xorriso_copy_properties(struct XorrisO *xorriso,
@param flag bit0= mkdir: graft in as empty directory, not as copy from disk
bit1= do not report added files
bit2= -follow: this is not a command parameter
bit3= use offset and cut_size for cut_out_node
@return <=0 = error , 1 = added simple node , 2 = added directory
*/
int Xorriso_graft_in(struct XorrisO *xorriso, void *boss_iter,
char *disk_path, char *img_path, int flag)
char *disk_path, char *img_path,
off_t offset, off_t cut_size, int flag)
{
IsoImage *volume;
char path[SfileadrL], *apt, *npt, *cpt, sfe[5*SfileadrL], sfe2[5*SfileadrL];
@ -2014,11 +2024,6 @@ handle_path_node:;
}
if(done) {
attach_source:;
xorriso->pacifier_count++;
if(xorriso->pacifier_count%100 && !(flag&2))
Xorriso_pacifier_callback(xorriso, "files added",
xorriso->pacifier_count,
xorriso->pacifier_total, "", 0);
if(flag&1) {
/* directory node was created above */;
@ -2051,9 +2056,9 @@ attach_source:;
}
#else
ret= Xorriso_tree_graft_node(xorriso, volume, dir, disk_path_pt, apt,
disk_path, img_path, &node, 0);
disk_path, img_path,
offset, cut_size, &node, flag&8);
if(ret<0) {
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
sprintf(xorriso->info_text, "Grafting failed: %s = %s",
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
@ -2062,6 +2067,12 @@ attach_source:;
#endif
xorriso->volset_change_pending= 1;
iso_node_set_name(node, apt);
xorriso->pacifier_count++;
if(xorriso->pacifier_count%100 && !(flag&2))
Xorriso_pacifier_callback(xorriso, "files added",
xorriso->pacifier_count,
xorriso->pacifier_total, "", 0);
}
} else
*npt= '/';
@ -2071,6 +2082,69 @@ attach_source:;
}
/* @param flag bit0= -follow: disk_path is not a command parameter
*/
int Xorriso_cut_out(struct XorrisO *xorriso, char *disk_path,
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag)
{
int ret;
char eff_source[SfileadrL], eff_dest[SfileadrL], sfe[SfileadrL*5];
struct stat stbuf;
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, eff_source,
2|4);
if(ret<=0)
return(ret);
if(lstat(eff_source, &stbuf)==-1) {
Xorriso_msgs_submit(xorriso, 0, eff_source, 0, "ERRFILE", 0);
sprintf(xorriso->info_text, "-cut_out: Cannot determine type of %s",
Text_shellsafe(eff_source, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
return(0);
}
if((stbuf.st_mode&S_IFMT) == S_IFLNK) {
if(!(xorriso->do_follow_links || (xorriso->do_follow_param && !(flag&1))))
goto unsupported_type;
if(stat(eff_source, &stbuf)==-1) {
Xorriso_msgs_submit(xorriso, 0, eff_source, 0, "ERRFILE", 0);
sprintf(xorriso->info_text,
"-cut_out: Cannot determine link target type of %s",
Text_shellsafe(eff_source, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
return(0);
}
}
if(S_ISREG(stbuf.st_mode)) {
if(stbuf.st_size<startbyte) {
Xorriso_msgs_submit(xorriso, 0, eff_source, 0, "ERRFILE", 0);
sprintf(xorriso->info_text,
"-cut_out: Byte offset %.f larger than file size %.f",
(double) startbyte, (double) stbuf.st_size);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "SORRY", 0);
return(0);
}
} else {
unsupported_type:;
Xorriso_msgs_submit(xorriso, 0, eff_source, 0, "ERRFILE", 0);
sprintf(xorriso->info_text, "-cut_out: Unsupported file type %s with %s",
Ftypetxt(stbuf.st_mode, 0), Text_shellsafe(eff_source, sfe, 0));
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
return(0);
}
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, iso_rr_path, eff_dest,
2|((flag&1)<<2));
if(ret<=0)
return(ret);
ret= Xorriso_graft_in(xorriso, NULL, eff_source, eff_dest,
startbyte, bytecount, 8);
return(ret);
}
int Xorriso_process_msg_queues(struct XorrisO *xorriso, int flag)
{
int ret, error_code= 0, os_errno= 0, count= 0, pass, imgid, tunneled;
@ -3643,7 +3717,8 @@ int Xorriso_rename(struct XorrisO *xorriso, void *boss_iter,
cpt= dir_adr+strlen(dir_adr);
*cpt= 0;
if(dir_adr[0]!=0) {
ret= Xorriso_graft_in(xorriso, boss_iter, NULL, dir_adr, 1);
ret= Xorriso_graft_in(xorriso, boss_iter, NULL, dir_adr,
(off_t) 0, (off_t) 0, 1);
if(ret<=0)
return(ret);
}
@ -3731,7 +3806,7 @@ int Xorriso_mkdir(struct XorrisO *xorriso, char *path, int flag)
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, path, eff_path, 2);
if(ret<0)
return(-2);
ret= Xorriso_graft_in(xorriso, NULL, NULL, eff_path, 1);
ret= Xorriso_graft_in(xorriso, NULL, NULL, eff_path, (off_t) 0, (off_t) 0, 1);
if(ret<=0)
return(-2);
if(!(flag&1)) {

6
xorriso/xorrisoburn.h
View File

@ -47,7 +47,8 @@ int Xorriso_write_session(struct XorrisO *xorriso, int flag);
@return <=0 = error , 1 = added simple node , 2 = added directory
*/
int Xorriso_graft_in(struct XorrisO *xorriso, void *boss_iter,
char *disk_path, char *img_path, int flag);
char *disk_path, char *img_path,
off_t offset, off_t cut_size, int flag);
int Xorriso__text_to_sev(char *severity_name, int *severity_number,int flag);
@ -191,5 +192,8 @@ int Xorriso_iso_file_close(struct XorrisO *xorriso, void **stream, int flag);
int Xorriso_copy_properties(struct XorrisO *xorriso,
char *disk_path, char *img_path, int flag);
int Xorriso_cut_out(struct XorrisO *xorriso, char *disk_path,
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag);
#endif /* Xorrisoburn_includeD */