2007-09-01 18:20:53 +00:00
|
|
|
|
|
|
|
/*
|
2007-09-04 23:03:21 +00:00
|
|
|
cc -g -c \
|
|
|
|
-D_FILE_OFFSET_BITS=64 -D_LARGEFILE_SOURCE=1 -D_LARGEFILE64_SOURCE \
|
|
|
|
burn_wrap.c
|
2007-09-01 18:20:53 +00:00
|
|
|
*/
|
|
|
|
/* libburn wrappers for libisoburn
|
|
|
|
|
|
|
|
Copyright 2007 Thomas Schmitt, <scdbackup@gmx.net>
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <sys/stat.h>
|
2007-09-04 23:03:21 +00:00
|
|
|
#include <fcntl.h>
|
2007-09-01 18:20:53 +00:00
|
|
|
|
|
|
|
|
|
|
|
#include "../libburn/libburn.h"
|
|
|
|
#include "../libisofs/libisofs.h"
|
|
|
|
#include "libisoburn.h"
|
|
|
|
#include "isoburn.h"
|
|
|
|
|
|
|
|
|
|
|
|
/* The global list of isoburn objects. Usually there is only one. */
|
|
|
|
extern struct isoburn *isoburn_list_start; /* in isoburn.c */
|
|
|
|
|
|
|
|
|
|
|
|
int isoburn_initialize(void)
|
|
|
|
{
|
|
|
|
if(!iso_init())
|
|
|
|
return(0);
|
|
|
|
if(!burn_initialize())
|
|
|
|
return(0);
|
|
|
|
isoburn_destroy_all(&isoburn_list_start, 0); /* isoburn_list_start= NULL */
|
|
|
|
|
2007-09-04 23:03:21 +00:00
|
|
|
return(1);
|
2007-09-01 18:20:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** Examine the media and sets appropriate emulation if needed.
|
|
|
|
*/
|
|
|
|
static int isoburn_welcome_media(struct isoburn **o, struct burn_drive *d,
|
|
|
|
int flag)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct burn_multi_caps *caps= NULL;
|
|
|
|
|
|
|
|
ret= burn_disc_get_multi_caps(d, BURN_WRITE_NONE, &caps, 0);
|
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
|
|
|
if(caps->start_adr) { /* set emulation to overwriteable */
|
|
|
|
ret= isoburn_new(o, 0);
|
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
|
|
|
(*o)->emulation_mode= 1;
|
|
|
|
(*o)->drive= d;
|
|
|
|
ret= isoburn_start_emulation(*o, 0);
|
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
|
|
|
}
|
|
|
|
ret= 1;
|
|
|
|
ex:
|
|
|
|
if(caps!=NULL)
|
|
|
|
burn_disc_free_multi_caps(&caps);
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int isoburn_drive_scan_and_grab(struct burn_drive_info *drive_infos[],
|
|
|
|
char* adr, int load)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct stat stbuf;
|
|
|
|
char libburn_drive_adr[BURN_DRIVE_ADR_LEN];
|
|
|
|
struct isoburn *o= NULL;
|
|
|
|
|
|
|
|
ret= burn_drive_convert_fs_adr(adr, libburn_drive_adr);
|
|
|
|
if(ret<0)
|
|
|
|
return(ret);
|
|
|
|
if(ret==0) {
|
|
|
|
if(stat(adr,&stbuf)!=-1) {
|
|
|
|
if(S_ISREG(stbuf.st_mode) || S_ISBLK(stbuf.st_mode)) {
|
2007-09-04 23:03:21 +00:00
|
|
|
ret= burn_drive_grab_dummy(drive_infos, adr);
|
|
|
|
if(ret<=0)
|
|
|
|
return(ret);
|
|
|
|
o->emulation_mode= 2; /* standard i/o */
|
2007-09-01 18:20:53 +00:00
|
|
|
} else {
|
|
|
|
|
|
|
|
/* >>> unsuitable file type */;
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
|
|
|
|
/* >>> file not found */;
|
|
|
|
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ret= burn_drive_scan_and_grab(drive_infos, adr, load);
|
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
2007-09-04 23:03:21 +00:00
|
|
|
ret= isoburn_welcome_media(&o, (*drive_infos)[0].drive, 0);
|
2007-09-01 18:20:53 +00:00
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret= 1;
|
|
|
|
ex:
|
|
|
|
if(ret<=0)
|
|
|
|
isoburn_destroy(&o,0);
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int isoburn_drive_grab(struct burn_drive *drive, int load)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct isoburn *o= NULL;
|
|
|
|
|
|
|
|
ret= burn_drive_grab(drive, load);
|
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
2007-09-04 23:03:21 +00:00
|
|
|
ret= isoburn_welcome_media(&o, drive, 0);
|
2007-09-01 18:20:53 +00:00
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
|
|
|
|
|
|
|
ret= 1;
|
|
|
|
ex:
|
|
|
|
if(ret<=0)
|
|
|
|
isoburn_destroy(&o,0);
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/** Retrieve media emulation and eventual isoburn emulator of drive.
|
|
|
|
@return -1 unsuitable media, 0 generic media, 1 emulated media.
|
|
|
|
*/
|
|
|
|
static int isoburn_find_emulator(struct isoburn **pt,
|
|
|
|
struct burn_drive *drive, int flag)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret= isoburn_find_by_drive(pt, drive, 0);
|
|
|
|
if(ret<=0)
|
|
|
|
return(0);
|
|
|
|
if((*pt)->emulation_mode==-1)
|
|
|
|
return(-1);
|
|
|
|
if((*pt)->emulation_mode==0)
|
|
|
|
return(0);
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
enum burn_disc_status isoburn_disc_get_status(struct burn_drive *drive)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct isoburn *o;
|
|
|
|
|
|
|
|
ret= isoburn_find_emulator(&o, drive, 0);
|
|
|
|
if(ret<0)
|
|
|
|
return(BURN_DISC_UNSUITABLE);
|
|
|
|
if(ret==0)
|
|
|
|
return(burn_disc_get_status(drive));
|
|
|
|
|
|
|
|
/* emulated status */
|
|
|
|
if(o->emulation_mode==-1)
|
|
|
|
return(BURN_DISC_UNSUITABLE);
|
|
|
|
if(o->nwa>0)
|
|
|
|
return(BURN_DISC_APPENDABLE);
|
|
|
|
return(BURN_DISC_BLANK);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void isoburn_disc_erase(struct burn_drive *drive, int fast)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct isoburn *o;
|
|
|
|
|
|
|
|
ret= isoburn_find_emulator(&o, drive, 0);
|
|
|
|
if(ret>0) {
|
|
|
|
if(o->emulation_mode==-1) {
|
2007-09-04 23:03:21 +00:00
|
|
|
/* To cause a negative reply with burn_drive_wrote_well() */
|
|
|
|
burn_drive_cancel(drive);
|
2007-09-01 18:20:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if(o->emulation_mode>0) {
|
|
|
|
ret= isoburn_invalidate_iso(o, 0);
|
2007-09-04 23:03:21 +00:00
|
|
|
if(ret<=0)
|
|
|
|
burn_drive_cancel(drive);
|
2007-09-01 18:20:53 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
burn_disc_erase(drive, fast);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int isoburn_disc_get_msc1(struct burn_drive *d, int *start_lba)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct isoburn *o;
|
|
|
|
|
|
|
|
if(isoburn_disc_get_status(d)!=BURN_DISC_APPENDABLE)
|
|
|
|
return(0);
|
|
|
|
ret= isoburn_find_emulator(&o, d, 0);
|
|
|
|
if(ret<0)
|
|
|
|
return(0);
|
|
|
|
if(ret==0)
|
|
|
|
return(burn_disc_get_msc1(d, start_lba));
|
|
|
|
*start_lba= 0;
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int isoburn_disc_track_lba_nwa(struct burn_drive *d,
|
|
|
|
struct burn_write_opts *opts,
|
|
|
|
int trackno, int *lba, int *nwa)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct isoburn *o;
|
|
|
|
|
|
|
|
ret= isoburn_find_emulator(&o, d, 0);
|
|
|
|
if(ret<0)
|
|
|
|
return(0);
|
|
|
|
if(ret==0)
|
|
|
|
return(burn_disc_track_lba_nwa(d, opts, trackno, lba, nwa));
|
|
|
|
*lba= 0;
|
|
|
|
*nwa= o->nwa;
|
|
|
|
return(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-09-04 23:03:21 +00:00
|
|
|
void isoburn_disc_write(struct burn_write_opts *opts, struct burn_disc *disc)
|
2007-09-01 18:20:53 +00:00
|
|
|
{
|
2007-09-04 23:03:21 +00:00
|
|
|
burn_disc_write(opts, disc);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
#ifdef NIX
|
|
|
|
|
|
|
|
int isoburn_random_access_write(struct burn_drive *d, off_t byte_address,
|
|
|
|
char *data, off_t data_count, int flag)
|
|
|
|
{
|
|
|
|
int ret, mode = O_RDWR | O_LARGEFILE | O_CREAT;
|
2007-09-01 18:20:53 +00:00
|
|
|
struct isoburn *o;
|
|
|
|
|
2007-09-04 23:03:21 +00:00
|
|
|
ret= isoburn_find_emulator(&o, d, 0);
|
2007-09-01 18:20:53 +00:00
|
|
|
if(ret<0)
|
|
|
|
return(0);
|
|
|
|
if(o->emulation_mode==2) {
|
2007-09-04 23:03:21 +00:00
|
|
|
if(flag&1)
|
|
|
|
mode|= O_SYNC;
|
|
|
|
o->stdio_fd= open(o->stdio_path, mode);
|
|
|
|
if(o->stdio_fd==-1) {
|
|
|
|
|
|
|
|
/* >>> cannot open stdio_path */;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
if(lseek(o->stdio_fd, byte_address, SEEK_SET)==-1) {
|
|
|
|
|
|
|
|
/* >>> cannot reach given byte_address */;
|
|
|
|
ret= 0; goto close_stdio;
|
|
|
|
}
|
|
|
|
if(write(o->stdio_fd, data, data_count) != data_count) {
|
|
|
|
|
|
|
|
/* >>> cannot write desired number of bytes */;
|
|
|
|
ret= 0; goto close_stdio;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret= 1;
|
|
|
|
close_stdio:;
|
|
|
|
close(o->stdio_fd); o->stdio_fd= -1;
|
|
|
|
} else if(o->emulation_mode==-1)
|
|
|
|
ret= 0;
|
|
|
|
else
|
|
|
|
ret= burn_random_access_write(d, byte_address, data, data_count, flag);
|
|
|
|
return(ret);
|
|
|
|
}
|
|
|
|
|
2007-09-01 18:20:53 +00:00
|
|
|
|
2007-09-04 23:03:21 +00:00
|
|
|
int burn_read_data(struct burn_drive *d, off_t byte_address,
|
|
|
|
char data[], off_t data_size, off_t *data_count, int flag)
|
|
|
|
{
|
|
|
|
int ret, mode = O_RDONLY | O_LARGEFILE;
|
|
|
|
off_t count, todo;
|
|
|
|
struct isoburn *o;
|
|
|
|
|
|
|
|
ret= isoburn_find_emulator(&o, d, 0);
|
|
|
|
if(ret<0)
|
2007-09-01 18:20:53 +00:00
|
|
|
return(0);
|
2007-09-04 23:03:21 +00:00
|
|
|
if(o->emulation_mode==2) {
|
|
|
|
o->stdio_fd= open(o->stdio_path, mode);
|
|
|
|
if(o->stdio_fd==-1) {
|
2007-09-01 18:20:53 +00:00
|
|
|
|
2007-09-04 23:03:21 +00:00
|
|
|
/* >>> cannot open stdio_path */;
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
if(lseek(o->stdio_fd, byte_address, SEEK_SET)==-1) {
|
|
|
|
|
|
|
|
/* >>> cannot reach given byte_address */;
|
|
|
|
ret= 0; goto close_stdio;
|
|
|
|
}
|
|
|
|
for(todo= data_size; todo>0; ) {
|
|
|
|
count= read(o->stdio_fd, data+(data_size-todo), todo);
|
|
|
|
if(count<=0)
|
|
|
|
break;
|
|
|
|
todo-= count;
|
|
|
|
}
|
|
|
|
if(todo>0) {
|
|
|
|
|
|
|
|
/* >>> cannot read desired number of bytes */;
|
|
|
|
ret= 0; goto close_stdio;
|
|
|
|
}
|
|
|
|
ret= 1;
|
|
|
|
close_stdio:;
|
|
|
|
close(o->stdio_fd); o->stdio_fd= -1;
|
|
|
|
} else if(o->emulation_mode==-1)
|
|
|
|
ret= 0;
|
|
|
|
else
|
|
|
|
ret= burn_read_data(d, byte_address, data, data_size, data_count, flag);
|
|
|
|
return(ret);
|
2007-09-01 18:20:53 +00:00
|
|
|
}
|
|
|
|
|
2007-09-04 23:03:21 +00:00
|
|
|
#endif /* NIX */
|
|
|
|
|
2007-09-01 18:20:53 +00:00
|
|
|
|
|
|
|
void isoburn_drive_release(struct burn_drive *drive, int eject)
|
|
|
|
{
|
2007-09-04 23:03:21 +00:00
|
|
|
int ret;
|
2007-09-01 18:20:53 +00:00
|
|
|
struct isoburn *o;
|
|
|
|
|
|
|
|
ret= isoburn_find_emulator(&o, drive, 0);
|
|
|
|
if(ret<0)
|
|
|
|
return;
|
|
|
|
if(o!=NULL)
|
|
|
|
isoburn_destroy(&o, 0);
|
|
|
|
burn_drive_release(drive, eject);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void isoburn_finish(void)
|
|
|
|
{
|
|
|
|
isoburn_destroy_all(&isoburn_list_start, 0);
|
|
|
|
burn_finish();
|
|
|
|
iso_finish();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int isoburn_needs_emulation(struct burn_drive *drive)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct isoburn *o;
|
|
|
|
enum burn_disc_status s;
|
|
|
|
|
|
|
|
s= isoburn_disc_get_status(drive);
|
|
|
|
if(s!=BURN_DISC_BLANK && s!=BURN_DISC_APPENDABLE)
|
|
|
|
return(-1);
|
|
|
|
ret= isoburn_find_emulator(&o, drive, 0);
|
|
|
|
if(ret<0)
|
|
|
|
return(-1);
|
|
|
|
if(ret>0)
|
|
|
|
if(o->emulation_mode>0)
|
|
|
|
return(1);
|
|
|
|
return(0);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void isoburn_write_opts_set_start_byte(struct burn_write_opts *opts,
|
|
|
|
off_t value)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct isoburn *o;
|
|
|
|
struct burn_drive *drive;
|
|
|
|
struct burn_multi_caps *caps= NULL;
|
|
|
|
|
|
|
|
drive= burn_write_opts_get_drive(opts);
|
|
|
|
ret= isoburn_find_emulator(&o, drive, 0);
|
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
|
|
|
ret= burn_disc_get_multi_caps(drive, BURN_WRITE_NONE, &caps, 0);
|
|
|
|
if(ret<=0)
|
|
|
|
goto ex;
|
|
|
|
o->min_start_byte= value;
|
|
|
|
if(value % caps->start_alignment)
|
|
|
|
value+= caps->start_alignment - (value % caps->start_alignment);
|
|
|
|
o->nwa= value/2048;
|
|
|
|
burn_write_opts_set_start_byte(opts, value);
|
|
|
|
ex:
|
|
|
|
if(caps!=NULL)
|
|
|
|
burn_disc_free_multi_caps(&caps);
|
|
|
|
}
|
|
|
|
|
|
|
|
|