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

Replaced some large local variables by other means in xorriso/read_run.c

Browse Source
This commit is contained in:
Thomas Schmitt 2011-05-07 16:57:54 +00:00
parent 92976c91f3
commit ec22b0bb30
2 changed files with 187 additions and 119 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

304
libisoburn/trunk/xorriso/read_run.c
View File

@ -59,24 +59,26 @@ int Xorriso_iso_file_open(struct XorrisO *xorriso, char *pathname,
void *node_pt, void **stream, int flag) void *node_pt, void **stream, int flag)
{ {
int ret; int ret;
char eff_path[SfileadrL]; char *eff_path= NULL;
IsoNode *node= NULL; IsoNode *node= NULL;
IsoFile *filenode= NULL; IsoFile *filenode= NULL;
IsoStream *iso_stream= NULL, *input_stream; IsoStream *iso_stream= NULL, *input_stream;
Xorriso_alloc_meM(eff_path, char, SfileadrL);
*stream= NULL; *stream= NULL;
if(flag&1) { if(flag&1) {
node= (IsoNode *) node_pt; node= (IsoNode *) node_pt;
} else { } else {
ret= Xorriso_get_node_by_path(xorriso, pathname, eff_path, &node, 0); ret= Xorriso_get_node_by_path(xorriso, pathname, eff_path, &node, 0);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
} }
if(!LIBISO_ISREG(node)) { if(!LIBISO_ISREG(node)) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Given path does not lead to a regular data file in the image"); "Given path does not lead to a regular data file in the image");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0); {ret= 0; goto ex;}
} }
filenode= (IsoFile *) node; filenode= (IsoFile *) node;
@ -86,7 +88,7 @@ int Xorriso_iso_file_open(struct XorrisO *xorriso, char *pathname,
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Could not obtain source stream of file in the image for reading"); "Could not obtain source stream of file in the image for reading");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0); {ret= 0; goto ex;}
} }
if(flag & 2) { if(flag & 2) {
/* Dig out the most original stream */ /* Dig out the most original stream */
@ -101,14 +103,14 @@ int Xorriso_iso_file_open(struct XorrisO *xorriso, char *pathname,
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"The data production of the file in the image is one-time only"); "The data production of the file in the image is one-time only");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0); {ret= 0; goto ex;}
} }
ret= iso_stream_open(iso_stream); ret= iso_stream_open(iso_stream);
if(ret<0) { if(ret<0) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Could not open data file in the image for reading"); "Could not open data file in the image for reading");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0); {ret= 0; goto ex;}
} }
Xorriso_process_msg_queues(xorriso,0); Xorriso_process_msg_queues(xorriso,0);
*stream= iso_stream; *stream= iso_stream;
@ -125,7 +127,10 @@ int Xorriso_iso_file_open(struct XorrisO *xorriso, char *pathname,
} }
#endif #endif
return(1); ret= 1;
ex:;
Xorriso_free_meM(eff_path);
return(ret);
} }
@ -249,7 +254,6 @@ int Xorriso_restore_properties(struct XorrisO *xorriso, char *disk_path,
uid_t uid; uid_t uid;
gid_t gid; gid_t gid;
struct utimbuf utime_buffer; struct utimbuf utime_buffer;
char sfe[5*SfileadrL];
struct stat stbuf; struct stat stbuf;
size_t num_attrs= 0, *value_lengths= NULL; size_t num_attrs= 0, *value_lengths= NULL;
char **names= NULL, **values= NULL; char **names= NULL, **values= NULL;
@ -257,8 +261,8 @@ int Xorriso_restore_properties(struct XorrisO *xorriso, char *disk_path,
ret= lstat(disk_path, &stbuf); ret= lstat(disk_path, &stbuf);
if(ret==-1) { if(ret==-1) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Cannot obtain properties of disk file %s", "Cannot obtain properties of disk file ");
Text_shellsafe(disk_path, sfe, 0)); Text_shellsafe(disk_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
{ret= 0; goto ex;} {ret= 0; goto ex;}
} }
@ -282,8 +286,8 @@ int Xorriso_restore_properties(struct XorrisO *xorriso, char *disk_path,
values, 0); values, 0);
if(ret < 0) { if(ret < 0) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Cannot change ACL or xattr of disk file %s", "Cannot change ACL or xattr of disk file ");
Text_shellsafe(disk_path, sfe, 0)); Text_shellsafe(disk_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
{ret= 0; goto ex;} {ret= 0; goto ex;}
} }
@ -311,8 +315,8 @@ int Xorriso_restore_properties(struct XorrisO *xorriso, char *disk_path,
ret= chmod(disk_path, mode); ret= chmod(disk_path, mode);
if(ret==-1) { if(ret==-1) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Cannot change access permissions of disk file %s", "Cannot change access permissions of disk file ");
Text_shellsafe(disk_path, sfe, 0)); Text_shellsafe(disk_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
{ret= 0; goto ex;} {ret= 0; goto ex;}
} }
@ -329,8 +333,8 @@ int Xorriso_restore_properties(struct XorrisO *xorriso, char *disk_path,
ret= utime(disk_path,&utime_buffer); ret= utime(disk_path,&utime_buffer);
if(ret==-1) { if(ret==-1) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Cannot change atime, mtime of disk file %s", "Cannot change atime, mtime of disk file ");
Text_shellsafe(disk_path, sfe, 0)); Text_shellsafe(disk_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
{ret= 0; goto ex;} {ret= 0; goto ex;}
} }
@ -350,50 +354,58 @@ int Xorriso_restore_implicit_properties(struct XorrisO *xorriso,
char *full_disk_path, char *disk_path, char *full_img_path, int flag) char *full_disk_path, char *disk_path, char *full_img_path, int flag)
{ {
int ret, nfic, ndc, nfdc, d, i; int ret, nfic, ndc, nfdc, d, i;
char nfi[SfileadrL], nd[SfileadrL], nfd[SfileadrL], *cpt; char *nfi= NULL, *nd= NULL, *nfd= NULL, *cpt;
char sfe[5*SfileadrL];
struct stat stbuf; struct stat stbuf;
IsoNode *node; IsoNode *node;
Xorriso_alloc_meM(nfi, char, SfileadrL);
Xorriso_alloc_meM(nd, char, SfileadrL);
Xorriso_alloc_meM(nfd, char, SfileadrL);
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, full_disk_path, nfd, ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, full_disk_path, nfd,
1|2|4); 1|2|4);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, nd, 1|2); ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, nd, 1|2);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, full_img_path, nfi, ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, full_img_path, nfi,
1|2); 1|2);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
nfdc= Sfile_count_components(nfd, 0); nfdc= Sfile_count_components(nfd, 0);
ndc= Sfile_count_components(nd, 0); ndc= Sfile_count_components(nd, 0);
nfic= Sfile_count_components(nfi, 0); nfic= Sfile_count_components(nfi, 0);
d= nfdc-ndc; d= nfdc-ndc;
if(d<0) if(d<0)
return(-1); {ret= -1; goto ex;}
if(d>nfic) if(d>nfic)
return(0); {ret= 0; goto ex;}
for(i= 0; i<d; i++) { for(i= 0; i<d; i++) {
cpt= strrchr(nfi, '/'); cpt= strrchr(nfi, '/');
if(cpt==NULL) if(cpt==NULL)
return(-1); /* should not happen */ {ret= -1; goto ex;} /* should not happen */
*cpt= 0; *cpt= 0;
} }
if(nfi[0]==0) if(nfi[0]==0)
strcpy(nfi, "/"); strcpy(nfi, "/");
ret= Xorriso_fake_stbuf(xorriso, nfi, &stbuf, &node, 0); ret= Xorriso_fake_stbuf(xorriso, nfi, &stbuf, &node, 0);
if(ret<=0) if(ret<=0)
return(0); {ret= 0; goto ex;}
ret= Xorriso_restore_properties(xorriso, nd, node, ((flag>>1)&3)); ret= Xorriso_restore_properties(xorriso, nd, node, ((flag>>1)&3));
if(ret<=0) if(ret<=0)
return(ret); goto ex;
sprintf(xorriso->info_text, sprintf(xorriso->info_text, "Restored properties for ");
"Restored properties for %s", Text_shellsafe(nd, sfe, 0)); Text_shellsafe(nd, xorriso->info_text, 1);
sprintf(xorriso->info_text+strlen(xorriso->info_text), strcat(xorriso->info_text, " from ");
" from %s", Text_shellsafe(nfi, sfe, 0)); Text_shellsafe(nfi, xorriso->info_text, 1 | 2);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "DEBUG", 0);
return(1); ret= 1;
ex:;
Xorriso_free_meM(nfi);
Xorriso_free_meM(nd);
Xorriso_free_meM(nfd);
return(ret);
} }
@ -414,9 +426,9 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
int flag) int flag)
{ {
int ret= 0, write_fd= -1, wanted, wret, open_flags, l_errno= 0; int ret= 0, write_fd= -1, wanted, wret, open_flags, l_errno= 0;
int target_deleted= 0; int target_deleted= 0, buf_size= 32 * 1024;
char *what= "[unknown filetype]", sfe[5*SfileadrL], sfe2[5*SfileadrL]; char *what= "[unknown filetype]";
char buf[32*1024], type_text[5], temp_path[SfileadrL], *buf_pt; char *buf= NULL, type_text[5], *temp_path= NULL, *buf_pt;
char *link_target, *open_path_pt= NULL; char *link_target, *open_path_pt= NULL;
off_t todo= 0, size, seek_ret, last_p_count= 0, already_done, read_count= 0; off_t todo= 0, size, seek_ret, last_p_count= 0, already_done, read_count= 0;
void *data_stream= NULL; void *data_stream= NULL;
@ -425,6 +437,9 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
struct stat stbuf; struct stat stbuf;
struct utimbuf utime_buffer; struct utimbuf utime_buffer;
Xorriso_alloc_meM(buf, char, buf_size);
Xorriso_alloc_meM(temp_path, char, SfileadrL);
if(LIBISO_ISDIR(node)) { if(LIBISO_ISDIR(node)) {
what= "directory"; what= "directory";
ret= mkdir(disk_path, 0777); ret= mkdir(disk_path, 0777);
@ -443,8 +458,8 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
if(flag&2) { if(flag&2) {
if(ret!=-1 && !S_ISREG(stbuf.st_mode)) { if(ret!=-1 && !S_ISREG(stbuf.st_mode)) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Restore offset demanded. But filesystem path leads to non-data file %s", "Restore offset demanded. But filesystem path leads to non-data file ");
Text_shellsafe(disk_path, sfe, 0)); Text_shellsafe(disk_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
l_errno= 0; l_errno= 0;
goto cannot_restore; goto cannot_restore;
@ -490,14 +505,15 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
l_errno= errno; l_errno= errno;
if(seek_ret == -1) { if(seek_ret == -1) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Cannot address byte %.f in filesystem path %s", "Cannot address byte %.f in filesystem path ",
(double) disk_offset, Text_shellsafe(open_path_pt, sfe, 0)); (double) disk_offset);
Text_shellsafe(open_path_pt, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
goto cannot_restore; goto cannot_restore;
} }
} }
while(todo>0) { while(todo>0) {
wanted= sizeof(buf); wanted= buf_size;
if(wanted>todo) if(wanted>todo)
wanted= todo; wanted= todo;
ret= Xorriso_iso_file_read(xorriso, data_stream, buf, wanted, 0); ret= Xorriso_iso_file_read(xorriso, data_stream, buf, wanted, 0);
@ -509,8 +525,10 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
already_done= (size - todo) / (off_t) 2048; already_done= (size - todo) / (off_t) 2048;
already_done*= (off_t) 2048; already_done*= (off_t) 2048;
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Starting best_effort handling on ISO file %s at byte %.f", "Starting best_effort handling on ISO file ");
Text_shellsafe(img_path, sfe, 0), (double) already_done); Text_shellsafe(img_path, xorriso->info_text, 1);
sprintf(xorriso->info_text + strlen(xorriso->info_text),
" at byte %.f", (double) already_done);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
ret= Xorriso_read_file_data(xorriso, node, img_path, open_path_pt, ret= Xorriso_read_file_data(xorriso, node, img_path, open_path_pt,
already_done, already_done, size - already_done, 2); already_done, already_done, size - already_done, 2);
@ -522,8 +540,8 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
todo= -1; todo= -1;
} }
if(ret <= 0) { if(ret <= 0) {
sprintf(xorriso->info_text, "Cannot read all bytes from ISO file %s", sprintf(xorriso->info_text, "Cannot read all bytes from ISO file ");
Text_shellsafe(img_path, sfe, 0)); Text_shellsafe(img_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
} }
break; break;
@ -553,8 +571,8 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
} }
if(wret != ret) { if(wret != ret) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Cannot write all bytes to disk filesystem path %s", "Cannot write all bytes to disk filesystem path ");
Text_shellsafe(open_path_pt, sfe, 0)); Text_shellsafe(open_path_pt, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
break; break;
} }
@ -571,10 +589,10 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
if(temp_path==open_path_pt && !target_deleted) { if(temp_path==open_path_pt && !target_deleted) {
ret= rename(temp_path, disk_path); ret= rename(temp_path, disk_path);
if(ret==-1) { if(ret==-1) {
sprintf(xorriso->info_text, sprintf(xorriso->info_text, "Cannot rename temporary path ");
"Cannot rename temporary path %s to final disk path %s", Text_shellsafe(temp_path, xorriso->info_text, 1);
Text_shellsafe(temp_path, sfe, 0), strcat(xorriso->info_text, " to final disk path ");
Text_shellsafe(disk_path, sfe2, 0)); Text_shellsafe(disk_path, xorriso->info_text, 1 | 2);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE",0);
unlink(temp_path); unlink(temp_path);
ret= 0; goto ex; ret= 0; goto ex;
@ -594,8 +612,10 @@ int Xorriso_tree_restore_node(struct XorrisO *xorriso, IsoNode *node,
if(xorriso->allow_restore!=2) { if(xorriso->allow_restore!=2) {
ignored:; ignored:;
if(!(flag&4)) { if(!(flag&4)) {
sprintf(xorriso->info_text, "Ignored file type: %s %s = %s", what, sprintf(xorriso->info_text, "Ignored file type: %s ", what);
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0)); Text_shellsafe(img_path, xorriso->info_text, 1);
strcat(xorriso->info_text, " = ");
Text_shellsafe(disk_path, xorriso->info_text, 1 | 2);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
} }
{ret= 2; goto ex;} {ret= 2; goto ex;}
@ -607,8 +627,10 @@ ignored:;
if(dev == (dev_t) 1) { if(dev == (dev_t) 1) {
probably_damaged:; probably_damaged:;
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Most probably damaged device file not restored: mknod %s %s 0 1", "Most probably damaged device file not restored: mknod ");
Text_shellsafe(disk_path, sfe, 0), LIBISO_ISCHR(node) ? "c" : "b"); Text_shellsafe(disk_path, xorriso->info_text, 1);
sprintf(xorriso->info_text + strlen(xorriso->info_text),
" %s 0 1", LIBISO_ISCHR(node) ? "c" : "b");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
ret= 0; goto ex; ret= 0; goto ex;
} }
@ -652,8 +674,8 @@ probably_damaged:;
if(ret==-1) { if(ret==-1) {
cannot_restore:; cannot_restore:;
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Cannot restore %s to disk filesystem: %s", "Cannot restore %s to disk filesystem: ", what);
what, Text_shellsafe(img_path, sfe, 0)); Text_shellsafe(img_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, l_errno, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, l_errno, "FAILURE", 0);
ret= 0; goto ex; ret= 0; goto ex;
} }
@ -671,6 +693,8 @@ ex:;
if(ret <= 0 && xorriso->extract_error_mode == 2 && open_path_pt != NULL) if(ret <= 0 && xorriso->extract_error_mode == 2 && open_path_pt != NULL)
unlink(open_path_pt); unlink(open_path_pt);
} }
Xorriso_free_meM(buf);
Xorriso_free_meM(temp_path);
if(data_stream!=NULL) if(data_stream!=NULL)
Xorriso_iso_file_close(xorriso, &data_stream, 0); Xorriso_iso_file_close(xorriso, &data_stream, 0);
return(ret); return(ret);
@ -689,7 +713,7 @@ int Xorriso_restore_overwrite(struct XorrisO *xorriso,
struct stat *stbuf, int flag) struct stat *stbuf, int flag)
{ {
int ret; int ret;
char sfe[5*SfileadrL], sfe2[5*SfileadrL], type_text[5]; char type_text[5];
Xorriso_process_msg_queues(xorriso,0); Xorriso_process_msg_queues(xorriso,0);
if(xorriso->do_overwrite==1 || if(xorriso->do_overwrite==1 ||
@ -706,18 +730,22 @@ int Xorriso_restore_overwrite(struct XorrisO *xorriso,
if(ret<=0) if(ret<=0)
return(ret); return(ret);
if(ret==3) { if(ret==3) {
sprintf(xorriso->info_text, "User revoked restoring of (ISO) file: %s", sprintf(xorriso->info_text, "User revoked restoring of (ISO) file: ");
Text_shellsafe(img_path, sfe, 0)); Text_shellsafe(img_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "NOTE", 0);
return(3*!!(flag&16)); return(3*!!(flag&16));
} }
return(1); return(1);
} }
Xorriso_msgs_submit(xorriso, 0, nominal_path, 0, "ERRFILE", 0); Xorriso_msgs_submit(xorriso, 0, nominal_path, 0, "ERRFILE", 0);
sprintf(xorriso->info_text, sprintf(xorriso->info_text, "While restoring ");
"While restoring %s : %s exists and may not be overwritten", Text_shellsafe(nominal_path, xorriso->info_text, 1);
Text_shellsafe(nominal_path, sfe, 0), strcmp(nominal_path, path)==0 ? strcat(xorriso->info_text, " : ");
"file object" : Text_shellsafe(path, sfe2, 0)); if(strcmp(nominal_path, path) == 0)
strcat(xorriso->info_text, "file object");
else
Text_shellsafe(path, xorriso->info_text, 1 | 2);
strcat(xorriso->info_text, " exists and may not be overwritten");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0); return(0);
} }
@ -766,21 +794,24 @@ int Xorriso_restore_prefix_hl(struct XorrisO *xorriso, IsoNode *node,
char *disk_path, int node_idx, int flag) char *disk_path, int node_idx, int flag)
{ {
int ret, min_hl, max_hl, i, link_sibling= 0, hflag; int ret, min_hl, max_hl, i, link_sibling= 0, hflag;
char old_path[SfileadrL], img_path[SfileadrL]; char *old_path= NULL, *img_path= NULL;
struct Xorriso_lsT *img_prefixes= NULL, *disk_prefixes= NULL; struct Xorriso_lsT *img_prefixes= NULL, *disk_prefixes= NULL;
Xorriso_alloc_meM(old_path, char, SfileadrL);
Xorriso_alloc_meM(img_path, char, SfileadrL);
ret= Xorriso_search_hardlinks(xorriso, node, &node_idx, &min_hl, &max_hl, ret= Xorriso_search_hardlinks(xorriso, node, &node_idx, &min_hl, &max_hl,
2 | 4); 2 | 4);
if(ret < 0) if(ret < 0)
return(ret); goto ex;
if(ret == 0 || min_hl == max_hl) if(ret == 0 || min_hl == max_hl)
return(0); {ret= 0; goto ex;}
for(i= min_hl; i < node_idx; i++) { for(i= min_hl; i < node_idx; i++) {
link_sibling= 1; link_sibling= 1;
ret= Xorriso_path_from_node(xorriso, xorriso->node_array[i], img_path, 0); ret= Xorriso_path_from_node(xorriso, xorriso->node_array[i], img_path, 0);
if(ret < 0) if(ret < 0)
return(ret); goto ex;
if(ret == 0) if(ret == 0)
continue; /* Node is deleted from tree (Should not happen here) */ continue; /* Node is deleted from tree (Should not happen here) */
hflag= 1; hflag= 1;
@ -796,13 +827,17 @@ int Xorriso_restore_prefix_hl(struct XorrisO *xorriso, IsoNode *node,
ret= Xorriso_make_restore_path(xorriso, &img_prefixes, &disk_prefixes, ret= Xorriso_make_restore_path(xorriso, &img_prefixes, &disk_prefixes,
img_path, old_path, hflag); img_path, old_path, hflag);
if(ret <= 0) if(ret <= 0)
return(ret); goto ex;
ret= Xorriso_restore_make_hl(xorriso, old_path, disk_path, ret= Xorriso_restore_make_hl(xorriso, old_path, disk_path,
!!xorriso->do_auto_chmod); !!xorriso->do_auto_chmod);
if(ret > 0) if(ret > 0)
return(1); {ret= 1; goto ex;}
} }
return(link_sibling << 2); ret= link_sibling << 2;
ex:;
Xorriso_free_meM(old_path);
Xorriso_free_meM(img_path);
return(ret);
} }
@ -862,13 +897,14 @@ int Xorriso_restore_disk_object(struct XorrisO *xorriso,
int ret, i, split_count= 0, partno, total_parts, leaf_is_split= 0; int ret, i, split_count= 0, partno, total_parts, leaf_is_split= 0;
int record_hl_path= 0, node_idx, cannot_register= 0; int record_hl_path= 0, node_idx, cannot_register= 0;
off_t total_bytes, was_byte_count; off_t total_bytes, was_byte_count;
char *part_name, part_path[SfileadrL], *img_path_pt; char *part_name, *part_path= NULL, *img_path_pt;
char sfe[5*SfileadrL], sfe2[5*SfileadrL];
IsoImage *volume; IsoImage *volume;
IsoNode *part_node, *first_part_node= NULL; IsoNode *part_node, *first_part_node= NULL;
struct SplitparT *split_parts= NULL; struct SplitparT *split_parts= NULL;
struct stat stbuf; struct stat stbuf;
Xorriso_alloc_meM(part_path, char, SfileadrL);
ret= Xorriso_get_volume(xorriso, &volume, 0); ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0) if(ret<=0)
goto ex; goto ex;
@ -954,8 +990,10 @@ int Xorriso_restore_disk_object(struct XorrisO *xorriso,
ret= Xorriso_restore_properties(xorriso, disk_path, node, 2 | !!(flag&64)); ret= Xorriso_restore_properties(xorriso, disk_path, node, 2 | !!(flag&64));
if(ret<=0) { if(ret<=0) {
restoring_failed:; restoring_failed:;
sprintf(xorriso->info_text, "Restoring failed: %s = %s", sprintf(xorriso->info_text, "Restoring failed: ");
Text_shellsafe(img_path,sfe,0), Text_shellsafe(disk_path,sfe2,0)); Text_shellsafe(img_path, xorriso->info_text, 1);
strcat(xorriso->info_text, " = ");
Text_shellsafe(disk_path, xorriso->info_text, 1 | 2);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "SORRY", 0);
{ret= 0; goto ex;} {ret= 0; goto ex;}
} }
@ -979,6 +1017,7 @@ went_well:;
ex:; ex:;
if(split_parts!=NULL) if(split_parts!=NULL)
Splitparts_destroy(&split_parts, split_count, 0); Splitparts_destroy(&split_parts, split_count, 0);
Xorriso_free_meM(part_path);
if(ret > 0 && cannot_register) if(ret > 0 && cannot_register)
ret= 0; ret= 0;
return(ret); return(ret);
@ -1361,15 +1400,19 @@ int Xorriso_restore(struct XorrisO *xorriso,
off_t offset, off_t bytes, int flag) off_t offset, off_t bytes, int flag)
{ {
IsoImage *volume; IsoImage *volume;
char path[SfileadrL], *apt, *npt, sfe[5*SfileadrL]; char *path= NULL, *apt, *npt;
IsoNode *node= NULL; IsoNode *node= NULL;
int done= 0, is_dir= 0, ret, source_is_dir, stbuf_ret, hret; int done= 0, is_dir= 0, ret, source_is_dir, stbuf_ret, hret;
int dir_create= 0, node_count= 0, node_register= 0; int dir_create= 0, node_count= 0, node_register= 0, path_size;
int leaf_is_split= 0, source_is_split= 0, new_dir_made= 0; int leaf_is_split= 0, source_is_split= 0, new_dir_made= 0;
struct stat stbuf; struct stat stbuf;
struct PermiteM *perm_stack_mem; struct PermiteM *perm_stack_mem;
perm_stack_mem= xorriso->perm_stack; perm_stack_mem= xorriso->perm_stack;
path_size= SfileadrL;
Xorriso_alloc_meM(path, char, path_size);
switch((flag >> 7) & 3) { switch((flag >> 7) & 3) {
case 1: dir_create= 1; case 1: dir_create= 1;
break; case 2: node_register= 1; break; case 2: node_register= 1;
@ -1397,8 +1440,8 @@ int Xorriso_restore(struct XorrisO *xorriso,
if(ret<=0) if(ret<=0)
goto ex; goto ex;
strncpy(path, disk_path, sizeof(path)-1); strncpy(path, disk_path, path_size - 1);
path[sizeof(path)-1]= 0; path[path_size - 1]= 0;
apt= npt= path; apt= npt= path;
if(!(flag&1)) { if(!(flag&1)) {
@ -1427,8 +1470,8 @@ int Xorriso_restore(struct XorrisO *xorriso,
Xorriso_process_msg_queues(xorriso,0); Xorriso_process_msg_queues(xorriso,0);
Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0); Xorriso_msgs_submit(xorriso, 0, disk_path, 0, "ERRFILE", 0);
sprintf(xorriso->info_text, sprintf(xorriso->info_text,
"Cannot determine attributes of (ISO) source file %s", "Cannot determine attributes of (ISO) source file ");
Text_shellsafe(img_path, sfe, 0)); Text_shellsafe(img_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
ret= 0; goto ex; ret= 0; goto ex;
} }
@ -1536,6 +1579,7 @@ ex:;
2 | !!(flag&64)); 2 | !!(flag&64));
if(hret<=0 && hret<ret) if(hret<=0 && hret<ret)
ret= hret; ret= hret;
Xorriso_free_meM(path);
return(ret); return(ret);
} }
@ -1544,12 +1588,15 @@ int Xorriso_restore_node_array(struct XorrisO *xorriso, int flag)
{ {
int i, ret, was_failure= 0, fret, hflag, stbuf_ret, faulty_family= 0; int i, ret, was_failure= 0, fret, hflag, stbuf_ret, faulty_family= 0;
struct PermiteM *perm_stack_mem; struct PermiteM *perm_stack_mem;
char img_path[SfileadrL], disk_path[SfileadrL]; char *img_path= NULL, *disk_path= NULL;
IsoNode *node; IsoNode *node;
struct Xorriso_lsT *img_prefixes= NULL, *disk_prefixes= NULL; struct Xorriso_lsT *img_prefixes= NULL, *disk_prefixes= NULL;
perm_stack_mem= xorriso->perm_stack; perm_stack_mem= xorriso->perm_stack;
Xorriso_alloc_meM(img_path, char, SfileadrL);
Xorriso_alloc_meM(disk_path, char, SfileadrL);
Xorriso_sort_node_array(xorriso, 0); Xorriso_sort_node_array(xorriso, 0);
disk_path[0]= 0; disk_path[0]= 0;
@ -1639,6 +1686,8 @@ was_problem:;
ret= 1; ret= 1;
ex:; ex:;
Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso, 0); Permstack_pop(&(xorriso->perm_stack), perm_stack_mem, xorriso, 0);
Xorriso_free_meM(img_path);
Xorriso_free_meM(disk_path);
return(ret); return(ret);
} }
@ -1649,45 +1698,52 @@ int Xorriso_paste_in(struct XorrisO *xorriso, char *disk_path,
off_t startbyte, off_t bytecount, char *iso_rr_path, int flag) off_t startbyte, off_t bytecount, char *iso_rr_path, int flag)
{ {
int ret; int ret;
char eff_source[SfileadrL], eff_dest[SfileadrL], sfe[SfileadrL*5]; char *eff_source= NULL, *eff_dest= NULL;
struct stat stbuf; struct stat stbuf;
IsoNode *node; IsoNode *node;
Xorriso_alloc_meM(eff_source, char, SfileadrL);
Xorriso_alloc_meM(eff_dest, char, SfileadrL);
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, eff_dest, ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, disk_path, eff_dest,
2|4); 2|4);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
ret= Xorriso_path_is_excluded(xorriso, disk_path, !(flag&1)); ret= Xorriso_path_is_excluded(xorriso, disk_path, !(flag&1));
if(ret!=0) if(ret!=0)
return(0); {ret= 0; goto ex;}
ret= stat(eff_dest, &stbuf); ret= stat(eff_dest, &stbuf);
if(ret!=-1 && !S_ISREG(stbuf.st_mode)) { if(ret!=-1 && !S_ISREG(stbuf.st_mode)) {
Xorriso_msgs_submit(xorriso, 0, eff_dest, 0, "ERRFILE", 0); Xorriso_msgs_submit(xorriso, 0, eff_dest, 0, "ERRFILE", 0);
sprintf(xorriso->info_text, sprintf(xorriso->info_text, "-paste_in: DISK file ");
"-paste_in: DISK file %s exists and is not a data file", Text_shellsafe(eff_source, xorriso->info_text, 1);
Text_shellsafe(eff_source, sfe, 0)); strcat(xorriso->info_text, " exists and is not a data file");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
return(0); {ret= 0; goto ex;}
} }
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, iso_rr_path, ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, iso_rr_path,
eff_source, 2); eff_source, 2);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
ret= Xorriso_fake_stbuf(xorriso, eff_source, &stbuf, &node, 4); ret= Xorriso_fake_stbuf(xorriso, eff_source, &stbuf, &node, 4);
if(ret<=0) if(ret<=0)
return(0); {ret= 0; goto ex;}
if(!S_ISREG(stbuf.st_mode)) { if(!S_ISREG(stbuf.st_mode)) {
Xorriso_msgs_submit(xorriso, 0, eff_dest, 0, "ERRFILE", 0); Xorriso_msgs_submit(xorriso, 0, eff_dest, 0, "ERRFILE", 0);
sprintf(xorriso->info_text, "-paste_in: ISO file %s is not a data file", sprintf(xorriso->info_text, "-paste_in: ISO file ");
Text_shellsafe(eff_source, sfe, 0)); Text_shellsafe(eff_source, xorriso->info_text, 1);
strcat(xorriso->info_text, " is not a data file");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, errno, "FAILURE", 0);
return(0); {ret= 0; goto ex;}
} }
/* >>> eventually obtain parameters from file name */; /* >>> eventually obtain parameters from file name */;
ret= Xorriso_restore(xorriso, eff_source, eff_dest, startbyte, bytecount, 8); ret= Xorriso_restore(xorriso, eff_source, eff_dest, startbyte, bytecount, 8);
ex:;
Xorriso_free_meM(eff_source);
Xorriso_free_meM(eff_dest);
return(ret); return(ret);
} }
@ -1698,31 +1754,34 @@ int Xorriso_extract_cut(struct XorrisO *xorriso,
{ {
int ret, stbuf_ret, read_raw; int ret, stbuf_ret, read_raw;
double mem_lut= 0.0; double mem_lut= 0.0;
char eff_img_path[SfileadrL], eff_disk_path[SfileadrL], sfe[SfileadrL*5]; char *eff_img_path= NULL, *eff_disk_path= NULL;
IsoImage *volume; IsoImage *volume;
IsoNode *node; IsoNode *node;
Xorriso_alloc_meM(eff_img_path, char, SfileadrL);
Xorriso_alloc_meM(eff_disk_path, char, SfileadrL);
ret= Xorriso_get_volume(xorriso, &volume, 0); ret= Xorriso_get_volume(xorriso, &volume, 0);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi, ret= Xorriso_normalize_img_path(xorriso, xorriso->wdi,
img_path, eff_img_path, 0); img_path, eff_img_path, 0);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
ret= Xorriso_node_from_path(xorriso, volume, eff_img_path, &node, 0); ret= Xorriso_node_from_path(xorriso, volume, eff_img_path, &node, 0);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx, ret= Xorriso_normalize_img_path(xorriso, xorriso->wdx,
disk_path, eff_disk_path, 2 | 4); disk_path, eff_disk_path, 2 | 4);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
Xorriso_pacifier_reset(xorriso, 0); Xorriso_pacifier_reset(xorriso, 0);
mem_lut= xorriso->last_update_time; mem_lut= xorriso->last_update_time;
ret= Xorriso_handle_collision(xorriso, node, img_path, eff_disk_path, ret= Xorriso_handle_collision(xorriso, node, img_path, eff_disk_path,
disk_path, &stbuf_ret, 0); disk_path, &stbuf_ret, 0);
if(ret<=0 || ret==3) if(ret<=0 || ret==3)
return(0); {ret= 0; goto ex;}
/* If it is a non-filtered stream from the ISO image /* If it is a non-filtered stream from the ISO image
and img_offset is a multiple of 2048 and img_offset is a multiple of 2048
@ -1730,10 +1789,11 @@ int Xorriso_extract_cut(struct XorrisO *xorriso,
*/ */
if(!LIBISO_ISREG(node)) { if(!LIBISO_ISREG(node)) {
Xorriso_msgs_submit(xorriso, 0, eff_disk_path, 0, "ERRFILE", 0); Xorriso_msgs_submit(xorriso, 0, eff_disk_path, 0, "ERRFILE", 0);
sprintf(xorriso->info_text, "-extract_cut: ISO file %s is not a data file", sprintf(xorriso->info_text, "-extract_cut: ISO file ");
Text_shellsafe(eff_img_path, sfe, 0)); Text_shellsafe(eff_img_path, xorriso->info_text, 1);
strcat(xorriso->info_text, " is not a data file");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
return(0); {ret= 0; goto ex;}
} }
read_raw= 0; read_raw= 0;
if((img_offset % 2048) == 0) { if((img_offset % 2048) == 0) {
@ -1745,22 +1805,26 @@ int Xorriso_extract_cut(struct XorrisO *xorriso,
ret= Xorriso_read_file_data(xorriso, node, eff_img_path, eff_disk_path, ret= Xorriso_read_file_data(xorriso, node, eff_img_path, eff_disk_path,
img_offset, (off_t) 0, bytes, 0); img_offset, (off_t) 0, bytes, 0);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
} else { } else {
ret= Xorriso_tree_restore_node(xorriso, node, eff_img_path, img_offset, ret= Xorriso_tree_restore_node(xorriso, node, eff_img_path, img_offset,
eff_disk_path, (off_t) 0, bytes, 2 | 8); eff_disk_path, (off_t) 0, bytes, 2 | 8);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
} }
ret= Xorriso_restore_properties(xorriso, eff_disk_path, node, 0); ret= Xorriso_restore_properties(xorriso, eff_disk_path, node, 0);
if(ret<=0) if(ret<=0)
return(ret); goto ex;
if(mem_lut != xorriso->last_update_time) if(mem_lut != xorriso->last_update_time)
Xorriso_pacifier_callback(xorriso, "sectors examined", Xorriso_pacifier_callback(xorriso, "sectors examined",
xorriso->pacifier_count, 0, "", 1); xorriso->pacifier_count, 0, "", 1);
return(1); ret= 1;
ex:;
Xorriso_free_meM(eff_img_path);
Xorriso_free_meM(eff_disk_path);
return(ret);
} }
@ -1775,7 +1839,6 @@ int Xorriso_read_file_data(struct XorrisO *xorriso, IsoNode *node,
int lba, count, blocks, quality, spot, bad_extract= 0; int lba, count, blocks, quality, spot, bad_extract= 0;
off_t size= 0, file_base_bytes= 0, file_processed_bytes= 0, img_adr; off_t size= 0, file_base_bytes= 0, file_processed_bytes= 0, img_adr;
off_t new_file_base_bytes, upto_file_bytes, start_byte= 0; off_t new_file_base_bytes, upto_file_bytes, start_byte= 0;
char sfe[5*SfileadrL];
struct SpotlisT *spotlist= NULL; struct SpotlisT *spotlist= NULL;
struct CheckmediajoB *job= NULL; struct CheckmediajoB *job= NULL;
@ -1793,9 +1856,10 @@ int Xorriso_read_file_data(struct XorrisO *xorriso, IsoNode *node,
0); 0);
if(ret <= 0) { if(ret <= 0) {
Xorriso_process_msg_queues(xorriso,0); Xorriso_process_msg_queues(xorriso,0);
sprintf(xorriso->info_text, sprintf(xorriso->info_text, "File object ");
"File object %s is currently not a data file from the loaded image", Text_shellsafe(img_path, xorriso->info_text, 1);
Text_shellsafe(img_path, sfe, 0)); strcat(xorriso->info_text,
" is currently not a data file from the loaded image");
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
goto ex; goto ex;
} }
@ -1853,8 +1917,8 @@ int Xorriso_read_file_data(struct XorrisO *xorriso, IsoNode *node,
if(ret <= 0) if(ret <= 0)
goto ex; goto ex;
if (ret == 2) { if (ret == 2) {
sprintf(xorriso->info_text, "Attempt aborted to extract data from %s", sprintf(xorriso->info_text, "Attempt aborted to extract data from ");
Text_shellsafe(img_path, sfe, 0)); Text_shellsafe(img_path, xorriso->info_text, 1);
Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0); Xorriso_msgs_submit(xorriso, 0, xorriso->info_text, 0, "FAILURE", 0);
ret= 0; goto ex; ret= 0; goto ex;
} }
@ -1878,9 +1942,10 @@ int Xorriso_read_file_data(struct XorrisO *xorriso, IsoNode *node,
* (off_t) 2048; * (off_t) 2048;
} }
if(i < lba_count) { if(i < lba_count) {
sprintf(xorriso->info_text, "Bad extract : %14.f , %14.f , %s\n", sprintf(xorriso->info_text, "Bad extract : %14.f , %14.f , ",
(double) start_byte, ((double) blocks) * 2048.0, (double) start_byte, ((double) blocks) * 2048.0);
Text_shellsafe(disk_path, sfe, 0)); Text_shellsafe(disk_path, xorriso->info_text, 1);
strcat(xorriso->info_text, "\n");
Xorriso_info(xorriso, 0); Xorriso_info(xorriso, 0);
bad_extract= 1; bad_extract= 1;
} }
@ -1914,14 +1979,16 @@ ex:;
int Xorriso_check_md5(struct XorrisO *xorriso, void *in_node, char *path, int Xorriso_check_md5(struct XorrisO *xorriso, void *in_node, char *path,
int flag) int flag)
{ {
int ret, wanted, rret; int ret, wanted, rret, buffer_size= 64 * 1024;
IsoImage *image; IsoImage *image;
IsoNode *node; IsoNode *node;
IsoFile *file; IsoFile *file;
char node_md5[16], data_md5[16], buffer[64 * 1024]; char node_md5[16], data_md5[16], *buffer= NULL;
void *stream= NULL, *ctx= NULL; void *stream= NULL, *ctx= NULL;
off_t todo; off_t todo;
Xorriso_alloc_meM(buffer, char, 64 * 1024);
node= (IsoNode *) in_node; node= (IsoNode *) in_node;
if(node == NULL) { if(node == NULL) {
ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0); ret= Xorriso_get_node_by_path(xorriso, path, NULL, &node, 0);
@ -1962,10 +2029,10 @@ int Xorriso_check_md5(struct XorrisO *xorriso, void *in_node, char *path,
goto ex; goto ex;
todo= iso_stream_get_size(stream); todo= iso_stream_get_size(stream);
while(todo > 0) { while(todo > 0) {
if(todo < sizeof(buffer)) if(todo < buffer_size)
wanted= todo; wanted= todo;
else else
wanted= sizeof(buffer); wanted= buffer_size;
rret = Xorriso_iso_file_read(xorriso, stream, buffer, wanted, 0); rret = Xorriso_iso_file_read(xorriso, stream, buffer, wanted, 0);
if(rret <= 0) if(rret <= 0)
{ret= -1; goto ex;} {ret= -1; goto ex;}
@ -2013,6 +2080,7 @@ ex:;
Xorriso_iso_file_close(xorriso, &stream, 0); Xorriso_iso_file_close(xorriso, &stream, 0);
if(ctx != NULL) if(ctx != NULL)
iso_md5_end(&ctx, data_md5); iso_md5_end(&ctx, data_md5);
Xorriso_free_meM(buffer);
if(ret < 0) { if(ret < 0) {
if(ret == -2) if(ret == -2)
sprintf(xorriso->result_line, "Aborted at: "); sprintf(xorriso->result_line, "Aborted at: ");

2
libisoburn/trunk/xorriso/xorriso_timestamp.h
View File

@ -1 +1 @@
#define Xorriso_timestamP "2011.05.07.105142" #define Xorriso_timestamP "2011.05.07.165758"