Branching for libisoburn release 0.5.0
This commit is contained in:
277
libisoburn/branches/ZeroFiveZero/test/compare_file.c
Normal file
277
libisoburn/branches/ZeroFiveZero/test/compare_file.c
Normal file
@ -0,0 +1,277 @@
|
||||
/*
|
||||
Compare two copies of a file object in as many aspects as i can imagine
|
||||
to make sense. (E.g.: comparing atime makes no sense.)
|
||||
|
||||
To compare tree /media/dvd and /original/dir :
|
||||
find /media/dvd -exec compare_file '{}' /media/dvd /original/dir ';'
|
||||
|
||||
Copyright 2008 - 2010 Thomas Schmitt, <scdbackup@gmx.net>
|
||||
|
||||
Provided under GPL version 2 or later.
|
||||
|
||||
|
||||
cc -g -o compare_file compare_file.c
|
||||
*/
|
||||
|
||||
#include <ctype.h>
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/stat.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
|
||||
|
||||
/* @param flag bit0= single letters */
|
||||
char *Ftypetxt(mode_t st_mode, int flag)
|
||||
{
|
||||
if(flag&1)
|
||||
goto single_letters;
|
||||
if(S_ISDIR(st_mode))
|
||||
return("directory");
|
||||
else if(S_ISREG(st_mode))
|
||||
return("regular_file");
|
||||
else if(S_ISLNK(st_mode))
|
||||
return("symbolic_link");
|
||||
else if(S_ISBLK(st_mode))
|
||||
return("block_device");
|
||||
else if(S_ISCHR(st_mode))
|
||||
return("char_device");
|
||||
else if(S_ISFIFO(st_mode))
|
||||
return("name_pipe");
|
||||
else if(S_ISSOCK(st_mode))
|
||||
return("unix_socket");
|
||||
return("unknown");
|
||||
single_letters:;
|
||||
if(S_ISDIR(st_mode))
|
||||
return("d");
|
||||
else if(S_ISREG(st_mode))
|
||||
return("-");
|
||||
else if(S_ISLNK(st_mode))
|
||||
return("l");
|
||||
else if(S_ISBLK(st_mode))
|
||||
return("b");
|
||||
else if(S_ISCHR(st_mode))
|
||||
return("c");
|
||||
else if(S_ISFIFO(st_mode))
|
||||
return("p");
|
||||
else if(S_ISSOCK(st_mode))
|
||||
return("s");
|
||||
return("?");
|
||||
}
|
||||
|
||||
|
||||
char *Ftimetxt(time_t t, char timetext[40], int flag)
|
||||
{
|
||||
char *rpt;
|
||||
struct tm tms, *tmpt;
|
||||
static char months[12][4]= { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
|
||||
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
|
||||
|
||||
tmpt= localtime_r(&t, &tms);
|
||||
rpt= timetext;
|
||||
rpt[0]= 0;
|
||||
if(tmpt==0)
|
||||
sprintf(rpt+strlen(rpt), "%12.f", (double) t);
|
||||
else if(time(NULL)-t < 180*86400 && time(NULL)-t >= 0)
|
||||
sprintf(rpt+strlen(rpt), "%3s %2d %2.2d:%2.2d",
|
||||
months[tms.tm_mon], tms.tm_mday, tms.tm_hour, tms.tm_min);
|
||||
else
|
||||
sprintf(rpt+strlen(rpt), "%3s %2d %4.4d",
|
||||
months[tms.tm_mon], tms.tm_mday, 1900+tms.tm_year);
|
||||
return(timetext);
|
||||
}
|
||||
|
||||
|
||||
/* @param flag bit0= compare atime
|
||||
bit1= compare ctime
|
||||
*/
|
||||
int Compare_2_files(char *adr1, char *adr2, char *adrc, int flag)
|
||||
{
|
||||
struct stat s1, s2;
|
||||
int ret, differs= 0, r1, r2, fd1= -1, fd2= -1, i, done;
|
||||
char buf1[4096], buf2[4096], a[4096], ttx1[40], ttx2[40];
|
||||
off_t r1count= 0, r2count= 0, diffcount= 0, first_diff= -1;
|
||||
|
||||
ret= lstat(adr1, &s1);
|
||||
if(ret==-1) {
|
||||
printf("? %s : cannot lstat() : %s\n", adr1, strerror(errno));
|
||||
return(0);
|
||||
}
|
||||
strcpy(a, Ftypetxt(s1.st_mode, 1));
|
||||
strcat(a, " ");
|
||||
if(adrc[0])
|
||||
strcat(a, adrc);
|
||||
else
|
||||
strcat(a, ".");
|
||||
|
||||
ret= lstat(adr2, &s2);
|
||||
if(ret==-1) {
|
||||
printf("? %s : cannot lstat() : %s\n", adr2, strerror(errno));
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Attributes */
|
||||
if(s1.st_mode != s2.st_mode) {
|
||||
if((s1.st_mode&~S_IFMT)!=(s2.st_mode&~S_IFMT))
|
||||
printf("%s : st_mode : %7.7o <> %7.7o\n", a,
|
||||
(unsigned int) (s1.st_mode & ~S_IFMT),
|
||||
(unsigned int) (s2.st_mode & ~S_IFMT));
|
||||
if((s1.st_mode&S_IFMT)!=(s2.st_mode&S_IFMT))
|
||||
printf("%s : type : %s <> %s\n",
|
||||
a, Ftypetxt(s1.st_mode, 0), Ftypetxt(s2.st_mode, 0));
|
||||
differs= 1;
|
||||
}
|
||||
if(s1.st_uid != s2.st_uid) {
|
||||
printf("%s : st_uid : %d <> %d\n", a, s1.st_uid, s2.st_uid);
|
||||
differs= 1;
|
||||
}
|
||||
if(s1.st_gid != s2.st_gid) {
|
||||
printf("%s : st_gid : %d <> %d\n", a, s1.st_gid, s2.st_gid);
|
||||
differs= 1;
|
||||
}
|
||||
if((S_ISCHR(s1.st_mode) && S_ISCHR(s2.st_mode)) ||
|
||||
(S_ISBLK(s1.st_mode) && S_ISBLK(s2.st_mode))) {
|
||||
if(s1.st_rdev != s2.st_rdev) {
|
||||
printf("%s : %s st_rdev : %lu <> %lu\n", a,
|
||||
(S_ISCHR(s1.st_mode) ? "S_IFCHR" : "S_IFBLK"),
|
||||
(unsigned long) s1.st_rdev, (unsigned long) s1.st_rdev);
|
||||
differs= 1;
|
||||
}
|
||||
}
|
||||
if(S_ISREG(s2.st_mode) && s1.st_size != s2.st_size) {
|
||||
printf("%s : st_size : %.f <> %.f diff= %.f\n",
|
||||
a, (double) s1.st_size, (double) s2.st_size,
|
||||
((double) s1.st_size) - (double) s2.st_size);
|
||||
differs= 1;
|
||||
}
|
||||
if(s1.st_mtime != s2.st_mtime) {
|
||||
printf("%s : st_mtime : %s <> %s diff= %.f s\n",
|
||||
a, Ftimetxt(s1.st_mtime, ttx1, 0),
|
||||
Ftimetxt(s2.st_mtime, ttx2, 0),
|
||||
((double) s1.st_mtime) - (double) s2.st_mtime);
|
||||
differs= 1;
|
||||
}
|
||||
if(flag&1) {
|
||||
if(s1.st_atime != s2.st_atime) {
|
||||
printf("%s : st_atime : %s <> %s diff= %.f s\n",
|
||||
a, Ftimetxt(s1.st_atime, ttx1, 0),
|
||||
Ftimetxt(s2.st_atime, ttx2, 0),
|
||||
((double) s1.st_atime) - (double) s2.st_atime);
|
||||
differs= 1;
|
||||
}
|
||||
}
|
||||
if(flag&2) {
|
||||
if(s1.st_ctime != s2.st_ctime) {
|
||||
printf("%s : st_ctime : %s <> %s diff= %.f s\n",
|
||||
a, Ftimetxt(s1.st_ctime, ttx1, 0),
|
||||
Ftimetxt(s2.st_ctime, ttx2, 0),
|
||||
((double) s1.st_ctime) - (double) s2.st_ctime);
|
||||
differs= 1;
|
||||
}
|
||||
}
|
||||
if(S_ISREG(s1.st_mode) && S_ISREG(s2.st_mode)) {
|
||||
fd1= open(adr1, O_RDONLY);
|
||||
if(fd1==-1) {
|
||||
printf("- %s : cannot open() : %s\n", adr1, strerror(errno));
|
||||
return(0);
|
||||
}
|
||||
fd2= open(adr2, O_RDONLY);
|
||||
if(fd2==-1) {
|
||||
printf("- %s : cannot open() : %s\n", adr2, strerror(errno));
|
||||
close(fd1);
|
||||
return(0);
|
||||
}
|
||||
|
||||
/* Content */
|
||||
done= 0;
|
||||
while(!done) {
|
||||
r1= read(fd1, buf1, sizeof(buf1));
|
||||
r2= read(fd2, buf2, sizeof(buf2));
|
||||
if((r1==EOF && r2==EOF) || (r1==0 && r2==0))
|
||||
break;
|
||||
if(r1==EOF || r1==0) {
|
||||
if(r1==EOF)
|
||||
r1= 0;
|
||||
if(s1.st_size > r1count + r1)
|
||||
printf("- %s : early EOF after %.f bytes\n", adr1, (double) r1count);
|
||||
differs= 1;
|
||||
}
|
||||
r1count+= r1;
|
||||
if(r2==EOF || r2<r1) {
|
||||
if(r2==EOF)
|
||||
r2= 0;
|
||||
if(s2.st_size > r2count + r2)
|
||||
printf("- %s : early EOF after %.f bytes\n", adr2, (double) r2count);
|
||||
differs= 1;
|
||||
done= 1;
|
||||
}
|
||||
if(r2>r1) {
|
||||
if(s1.st_size > r1count + r1)
|
||||
printf("- %s : early EOF after %.f bytes\n", adr1, (double) r1count);
|
||||
differs= 1;
|
||||
done= 1;
|
||||
}
|
||||
r2count+= r2;
|
||||
if(r1>r2)
|
||||
r1= r2;
|
||||
for(i= 0; i<r1; i++) {
|
||||
if(buf1[i]!=buf2[i]) {
|
||||
if(first_diff<0)
|
||||
first_diff= i;
|
||||
diffcount++;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(diffcount>0 || r1count!=r2count) {
|
||||
if(first_diff<0)
|
||||
first_diff= (r1count>r2count ? r2count : r1count);
|
||||
printf("%s : %s : differs by at least %.f bytes. First at %.f\n", a,
|
||||
(s1.st_mtime==s2.st_mtime ? "CONTENT":"content"),
|
||||
(double) (diffcount + abs(r1count-r2count)), (double) first_diff);
|
||||
differs= 1;
|
||||
}
|
||||
}
|
||||
if(fd1!=-1)
|
||||
close(fd1);
|
||||
if(fd2!=-1)
|
||||
close(fd2);
|
||||
return(!differs);
|
||||
}
|
||||
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int ret, i, with_ctime= 1;
|
||||
char adr1[4096], adr2[4096], adrc[4096];
|
||||
|
||||
if(argc<4) {
|
||||
fprintf(stderr, "usage: %s path prefix1 prefix2\n", argv[0]);
|
||||
exit(2);
|
||||
}
|
||||
for(i= 4; i<argc; i++) {
|
||||
if(strcmp(argv[i], "-no_ctime")==0)
|
||||
with_ctime= 0;
|
||||
else {
|
||||
fprintf(stderr, "%s : Option not recognized: '%s'\n", argv[0], argv[i]);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
if(strncmp(argv[1], argv[2], strlen(argv[2]))!=0) {
|
||||
fprintf(stderr, "%s: path '%s' does not match prefix1 '%s'\n",
|
||||
argv[0], argv[1], argv[2]);
|
||||
exit(2);
|
||||
}
|
||||
strcpy(adr1, argv[1]);
|
||||
strcpy(adrc, argv[1]+strlen(argv[2]));
|
||||
sprintf(adr2, "%s%s%s",
|
||||
argv[3], (adrc[0]=='/' || adrc[0]==0 ? "" : "/"), adrc);
|
||||
|
||||
ret= Compare_2_files(adr1, adr2, adrc, (with_ctime<<1));
|
||||
exit(ret<=0);
|
||||
}
|
||||
|
||||
312
libisoburn/branches/ZeroFiveZero/test/test.c
Normal file
312
libisoburn/branches/ZeroFiveZero/test/test.c
Normal file
@ -0,0 +1,312 @@
|
||||
/*
|
||||
Little test program for libisoburn.
|
||||
It grows an iso filesystem on a disc.
|
||||
|
||||
Copyright 2007 Vreixo Formoso Lopes <metalpain2002@yahoo.es>
|
||||
and Thomas Schmitt <scdbackup@gmx.net>
|
||||
*/
|
||||
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <getopt.h>
|
||||
#include <err.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
|
||||
#include <libisofs/libisofs.h>
|
||||
#include <libburn/libburn.h>
|
||||
#include "../src/libisoburn.h"
|
||||
|
||||
const char * const optstring = "JRh";
|
||||
extern char *optarg;
|
||||
extern int optind;
|
||||
|
||||
|
||||
/** Activates the usage of function graft_point() rather than
|
||||
plain iso_tree_radd_dir() from libisofs
|
||||
*/
|
||||
#define With_graft_poinT 1
|
||||
|
||||
|
||||
static int graft_point(struct iso_volume *volume, const char *disk_path,
|
||||
const char *img_path, struct iso_tree_radd_dir_behavior *behav)
|
||||
{
|
||||
char path[4096], *apt, *npt;
|
||||
struct iso_tree_node_dir *dir;
|
||||
struct iso_tree_node *node;
|
||||
int done= 0, is_dir= 0;
|
||||
struct stat stbuf;
|
||||
|
||||
strncpy(path, img_path, sizeof(path)-1);
|
||||
path[sizeof(path)-1]= 0;
|
||||
apt= npt= path;
|
||||
|
||||
if(lstat(disk_path, &stbuf) == -1) {
|
||||
fprintf(stderr, "Cannot determine attributes of '%s' : %s (%d)\n",
|
||||
disk_path, (errno > 0 ? strerror(errno) : "unknown error"), errno);
|
||||
return(0);
|
||||
}
|
||||
if(S_ISDIR(stbuf.st_mode))
|
||||
is_dir= 1;
|
||||
else if(!(S_ISREG(stbuf.st_mode) || S_ISLNK(stbuf.st_mode))) {
|
||||
fprintf(stderr, "File object '%s' is of non-supported file type\n",
|
||||
disk_path);
|
||||
return(0);
|
||||
}
|
||||
|
||||
dir= iso_volume_get_root(volume);
|
||||
if(dir==NULL) {
|
||||
fprintf(stderr, "While grafting '%s' : no root node available\n", img_path);
|
||||
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++;
|
||||
continue;
|
||||
}
|
||||
node= iso_tree_volume_path_to_node(volume,path);
|
||||
if(node!=NULL) {
|
||||
if(iso_tree_node_get_type(node)!=LIBISO_NODE_DIR) {
|
||||
fprintf(stderr, "While grafting '%s' : '%s' is not a directory\n",
|
||||
img_path, path);
|
||||
return(0);
|
||||
}
|
||||
dir= (struct iso_tree_node_dir *) node;
|
||||
} else {
|
||||
dir= iso_tree_add_dir(dir, apt);
|
||||
if(dir==NULL) {
|
||||
fprintf(stderr, "While grafting '%s' : could not insert '%s'\n",
|
||||
img_path, path);
|
||||
return(0);
|
||||
}
|
||||
}
|
||||
if(done) {
|
||||
if(is_dir) {
|
||||
iso_tree_radd_dir(dir, disk_path, behav);
|
||||
} else {
|
||||
node= iso_tree_add_node(dir, disk_path);
|
||||
if(node == NULL) {
|
||||
fprintf(stderr, "While grafting '%s'='%s' : libisofs_errno = %d\n",
|
||||
img_path, disk_path, libisofs_errno);
|
||||
}
|
||||
}
|
||||
} else
|
||||
*npt= '/';
|
||||
}
|
||||
fprintf(stderr, "NOTE: added %s '%s'='%s'\n", (is_dir ? "directory" : "node"),
|
||||
img_path, disk_path);
|
||||
return(1);
|
||||
}
|
||||
|
||||
|
||||
static
|
||||
void usage()
|
||||
{
|
||||
printf("test [OPTIONS] DRIVE DIRECTORY\n");
|
||||
}
|
||||
|
||||
static
|
||||
void help()
|
||||
{
|
||||
printf(
|
||||
"Options:\n"
|
||||
" -J Add Joliet support\n"
|
||||
" -R Add Rock Ridge support\n"
|
||||
" -h Print this message\n"
|
||||
);
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
struct burn_drive_info *drives;
|
||||
struct iso_volset *volset;
|
||||
struct burn_drive *drive;
|
||||
struct burn_disc *disc;
|
||||
enum burn_disc_status state;
|
||||
struct isoburn_read_opts ropts;
|
||||
struct isoburn_source_opts sopts;
|
||||
int c;
|
||||
struct iso_tree_radd_dir_behavior behav = {0,0,0};
|
||||
int flags=0;
|
||||
int ret=0, i;
|
||||
int size, free_bytes;
|
||||
char *status_text;
|
||||
|
||||
while ((c = getopt(argc, argv, optstring)) != -1) {
|
||||
switch(c) {
|
||||
case 'h':
|
||||
usage();
|
||||
help();
|
||||
exit(0);
|
||||
break;
|
||||
case 'J':
|
||||
flags |= ECMA119_JOLIET;
|
||||
break;
|
||||
case 'R':
|
||||
flags |= ECMA119_ROCKRIDGE;
|
||||
break;
|
||||
case '?':
|
||||
usage();
|
||||
exit(1);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (argc < optind + 1) {
|
||||
fprintf(stderr, "Please supply device name\n");
|
||||
usage();
|
||||
exit(1);
|
||||
}
|
||||
if (argc < optind + 2) {
|
||||
fprintf(stderr, "Please supply directory to add to disc\n");
|
||||
usage();
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
if (!isoburn_initialize()) {
|
||||
fprintf(stderr, "Can't init libisoburn\n");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* TODO change this. maybe we can add wrapp in libisoburn */
|
||||
iso_msgs_set_severities("NEVER", "DEBUG", "libisofs : ");
|
||||
burn_msgs_set_severities("NEVER", "DEBUG", "libburn : ");
|
||||
burn_set_signal_handling("libisoburn/test/test : ", NULL, 0);
|
||||
|
||||
printf("Growing drive %s\n", argv[optind]);
|
||||
|
||||
if (isoburn_drive_scan_and_grab(&drives, argv[optind], 1) <= 0) {
|
||||
fprintf(stderr,
|
||||
"Can't open device. Are you sure it is a valid drive?\n");
|
||||
exit(1);
|
||||
}
|
||||
drive = drives[0].drive;
|
||||
|
||||
/* check for invalid state */
|
||||
state = isoburn_disc_get_status(drive);
|
||||
if (state != BURN_DISC_BLANK && state != BURN_DISC_APPENDABLE) {
|
||||
fprintf(stderr, "Unsuitable disc status\n");
|
||||
goto exit_cleanup;
|
||||
}
|
||||
|
||||
/* fill read opts */
|
||||
memset(&ropts, sizeof(ropts), 0);
|
||||
ropts.norock = 0;
|
||||
ropts.nojoliet = 0;
|
||||
ropts.preferjoliet = 0;
|
||||
ropts.uid = 0;
|
||||
ropts.gid = 0;
|
||||
ropts.mode = 0555;
|
||||
ropts.pretend_blank= 0;
|
||||
|
||||
if (isoburn_read_volset(drive, &ropts, &volset) <= 0) {
|
||||
fprintf(stderr, "Can't read volset\n");
|
||||
goto exit_cleanup;
|
||||
}
|
||||
|
||||
|
||||
#ifdef With_graft_poinT
|
||||
for (i = optind + 1; i < argc; i++) {
|
||||
if (graft_point(iso_volset_get_volume(volset, 0),
|
||||
argv[i], argv[i], &behav) <= 0) {
|
||||
fprintf(stderr, "Canot graft '%s'\n", argv[optind+1]);
|
||||
goto exit_cleanup;
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
struct iso_tree_node_dir *root;
|
||||
root = iso_volume_get_root(iso_volset_get_volume(volset, 0));
|
||||
/* add a new dir */
|
||||
iso_tree_radd_dir(root, argv[optind+1], &behav);
|
||||
#endif /* ! With_graft_poinT */
|
||||
|
||||
|
||||
sopts.level = 2;
|
||||
sopts.flags = flags;
|
||||
sopts.relaxed_constraints = 0;
|
||||
sopts.copy_eltorito = 1;
|
||||
sopts.no_cache_inodes = 0;
|
||||
sopts.sort_files = 1;
|
||||
sopts.default_mode = 0;
|
||||
sopts.replace_dir_mode = 0;
|
||||
sopts.replace_file_mode = 0;
|
||||
sopts.replace_uid = 0;
|
||||
sopts.replace_gid = 0;
|
||||
sopts.dir_mode = 0555;
|
||||
sopts.file_mode = 0444;
|
||||
sopts.gid = 0;
|
||||
sopts.uid = 0;
|
||||
sopts.input_charset = NULL;
|
||||
sopts.ouput_charset = NULL;
|
||||
|
||||
if (isoburn_prepare_disc(drive, &disc, &sopts) <= 0) {
|
||||
fprintf(stderr, "Can't prepare disc\n");
|
||||
goto volset_cleanup;
|
||||
}
|
||||
|
||||
/* a. write the new image */
|
||||
printf("Adding new data...\n");
|
||||
{
|
||||
struct burn_write_opts *burn_options;
|
||||
struct burn_progress progress;
|
||||
|
||||
burn_options = burn_write_opts_new(drive);
|
||||
burn_drive_set_speed(drive, 0, 0);
|
||||
burn_write_opts_set_underrun_proof(burn_options, 1);
|
||||
|
||||
/* ok, write the new track */
|
||||
isoburn_disc_write(burn_options, disc);
|
||||
burn_write_opts_free(burn_options);
|
||||
|
||||
while (burn_drive_get_status(drive, NULL) == BURN_DRIVE_SPAWNING)
|
||||
usleep(100002);
|
||||
|
||||
while (burn_drive_get_status(drive, &progress)
|
||||
!= BURN_DRIVE_IDLE) {
|
||||
|
||||
printf("Writing: sector %d of %d",
|
||||
progress.sector, progress.sectors);
|
||||
ret = isoburn_get_fifo_status(drive, &size,
|
||||
&free_bytes, &status_text);
|
||||
if (ret > 0 )
|
||||
printf(" [fifo %s, %2d%% fill]", status_text,
|
||||
(int) (100.0 - 100.0 *
|
||||
((double) free_bytes) /
|
||||
(double) size));
|
||||
printf("\n");
|
||||
sleep(1);
|
||||
}
|
||||
}
|
||||
|
||||
/* b. write the new vol desc */
|
||||
printf("Writing the new vol desc...\n");
|
||||
if (isoburn_activate_session(drive) <= 0) {
|
||||
fprintf(stderr, "Ups, new vol desc write failed\n");
|
||||
}
|
||||
|
||||
ret= 0;
|
||||
volset_cleanup:;
|
||||
/*
|
||||
iso_volset_free(volset);
|
||||
*/
|
||||
|
||||
exit_cleanup:;
|
||||
isoburn_drive_release(drive, 0);
|
||||
isoburn_finish();
|
||||
|
||||
exit(ret);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user