Brought burn_stdio_write_track() onto sector_data() for outmost realism

cdrskin/cdrskin_timestamp.h

@@ -1 +1 @@
-#define Cdrskin_timestamP "2007.09.10.110050"
+#define Cdrskin_timestamP "2007.09.12.104626"

libburn/drive.c

@@ -55,6 +55,7 @@ int burn_setup_drive(struct burn_drive *d, char *fname)
 	d->mdata = NULL;
 	d->toc_entry = NULL;
 	d->released = 1;
+	d->stdio_fd = -1;
 	d->status = BURN_DISC_UNREADY;
 	return 1;
 }
@@ -65,13 +66,21 @@ void burn_drive_free_subs(struct burn_drive *d)
 {
 	if (d->idata != NULL)
 		free((void *) d->idata);
+	d->idata = NULL;
 	if (d->mdata != NULL) {
 		burn_mdata_free_subs(d->mdata);
 		free((void *) d->mdata);
 	}
+	d->mdata = NULL;
 	if(d->toc_entry != NULL)
 		free((void *) d->toc_entry);
-	free(d->devname);
+	d->toc_entry = NULL;
+	if (d->devname != NULL)
+		free(d->devname);
+	d->devname = NULL;
+	if (d->stdio_fd >= 0)
+		close (d->stdio_fd);
+	d->stdio_fd = -1;
 }
 
 
@@ -359,14 +368,14 @@ struct burn_drive *burn_drive_finish_enum(struct burn_drive *d)
 	struct burn_drive *t;
 	/* ts A60821
    	<<< debug: for tracing calls which might use open drive fds */
-	int mmc_function_spy(char * text);
+	int mmc_function_spy(struct burn_drive *d, char * text);
 
 	d->drive_role = 1; /* MMC drive */
 
 	t = burn_drive_register(d);
 
 	/* ts A60821 */
-	mmc_function_spy("enumerate_common : -------- doing grab");
+	mmc_function_spy(NULL, "enumerate_common : -------- doing grab");
 
 	/* try to get the drive info */
 	if (t->grab(t)) {
@@ -381,7 +390,7 @@ struct burn_drive *burn_drive_finish_enum(struct burn_drive *d)
 	}
 
 	/* ts A60821 */
-	mmc_function_spy("enumerate_common : ----- would release ");
+	mmc_function_spy(NULL, "enumerate_common : ----- would release ");
 
 	return t;
 }
@@ -1128,8 +1137,8 @@ int burn_drive_grab_dummy(struct burn_drive_info *drive_infos[], char *fname)
 	d= (struct burn_drive *) calloc(1, sizeof(struct burn_drive));
 	if (d == NULL)
 		return 0;
-	d->status = BURN_DISC_EMPTY;
 	burn_setup_drive(d, fname);
+	d->status = BURN_DISC_EMPTY;
 
 	if (fname[0] != 0)
 		d->drive_role = 2;

libburn/libdax_msgs.h

@@ -385,6 +385,7 @@ Range "scdbackup"          :  0x00020000 to 0x0002ffff
  0x00020149 (SORRY,HIGH)   = Unsuitable filetype for pseudo-drive
  0x0002014a (SORRY,HIGH)   = Cannot read desired amount of data
  0x0002014b (SORRY,HIGH)   = Drive is already registered resp. scanned
+ 0x0002014c (FATAL,HIGH)   = Emulated drive caught in SCSI function
 
 
  libdax_audioxtr:

libburn/mmc.c

@@ -172,12 +172,25 @@ static unsigned char MMC_READ_10[] =
 
 static int mmc_function_spy_do_tell = 0;
 
-int mmc_function_spy(char * text)
+int mmc_function_spy(struct burn_drive *d, char * text)
 {
-
 	if (mmc_function_spy_do_tell)
 		fprintf(stderr,"libburn: experimental: mmc_function_spy: %s\n",
 			text);
+	if (d == NULL)
+		return 1;
+	if (d->drive_role != 1) {
+		char msg[4096];
+	
+		sprintf(msg, "Emulated drive caught in SCSI adapter \"%s\"",
+				text);
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+				0x0002014c,
+				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
+				msg, 0, 0);
+		d->cancel = 1;
+		return 0;
+	}
 	return 1;
 }
 
@@ -212,7 +225,8 @@ void mmc_send_cue_sheet(struct burn_drive *d, struct cue_sheet *s)
 	struct command c;
 
 
-	mmc_function_spy("mmc_send_cue_sheet");
+	if (mmc_function_spy(d, "mmc_send_cue_sheet") <= 0)
+		return;
 
 	scsi_init_command(&c, MMC_SEND_CUE_SHEET, sizeof(MMC_SEND_CUE_SHEET));
 /*
@@ -242,7 +256,9 @@ int mmc_reserve_track(struct burn_drive *d, off_t size)
 	int lba;
 	char msg[80];
 
-	mmc_function_spy("mmc_reserve_track");
+	if (mmc_function_spy(d, "mmc_reserve_track") <= 0)
+		return 0;
+
 	scsi_init_command(&c, MMC_RESERVE_TRACK, sizeof(MMC_RESERVE_TRACK));
 /*
 	c.oplen = sizeof(MMC_RESERVE_TRACK);
@@ -274,7 +290,8 @@ int mmc_read_track_info(struct burn_drive *d, int trackno, struct buffer *buf,
 {
 	struct command c;
 
-	mmc_function_spy("mmc_read_track_info");
+	if (mmc_function_spy(d, "mmc_read_track_info") <= 0)
+		return 0;
 
 	scsi_init_command(&c, MMC_TRACK_INFO, sizeof(MMC_TRACK_INFO));
 /*
@@ -320,7 +337,8 @@ int mmc_get_nwa(struct burn_drive *d, int trackno, int *lba, int *nwa)
 	int ret, num, alloc_len = 20;
 	unsigned char *data;
 
-	mmc_function_spy("mmc_get_nwa");
+	if (mmc_function_spy(d, "mmc_get_nwa") <= 0)
+		return -1;
 
 	ret = mmc_read_track_info(d, trackno, &buf, alloc_len);
 	if (ret <= 0)
@@ -360,7 +378,8 @@ void mmc_close_disc(struct burn_write_opts *o)
 {
 	struct burn_drive *d;
 
-	mmc_function_spy("mmc_close_disc");
+	if (mmc_function_spy(d, "mmc_close_disc") <= 0)
+		return;
 
 	libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
 			   LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
@@ -381,7 +400,8 @@ void mmc_close_session(struct burn_write_opts *o)
 {
 	struct burn_drive *d;
 
-	mmc_function_spy("mmc_close_session");
+	if (mmc_function_spy(d, "mmc_close_session") <= 0)
+		return;
 
 	libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
 			   LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
@@ -405,7 +425,8 @@ void mmc_close(struct burn_drive *d, int session, int track)
 {
 	struct command c;
 
-	mmc_function_spy("mmc_close");
+	if (mmc_function_spy(d, "mmc_close") <= 0)
+		return;
 
 	scsi_init_command(&c, MMC_CLOSE, sizeof(MMC_CLOSE));
 /*
@@ -429,7 +450,8 @@ void mmc_get_event(struct burn_drive *d)
 	struct command c;
 	int alloc_len= 8;
 
-	mmc_function_spy("mmc_get_event");
+	if (mmc_function_spy(d, "mmc_get_event") <= 0)
+		return;
 
 	scsi_init_command(&c, MMC_GET_EVENT, sizeof(MMC_GET_EVENT));
 /*
@@ -594,7 +616,9 @@ void mmc_write_12(struct burn_drive *d, int start, struct buffer *buf)
 	struct command c;
 	int len;
 
-	mmc_function_spy("mmc_write_12");
+	if (mmc_function_spy(d, "mmc_write_12") <= 0)
+		return;
+
 	len = buf->sectors;
 
 	/* ts A61009 */
@@ -634,11 +658,10 @@ int mmc_write(struct burn_drive *d, int start, struct buffer *buf)
 				O_WRONLY|O_CREAT|O_TRUNC,S_IRUSR|S_IWUSR);
 #endif /* Libburn_log_in_and_out_streaM */
 
-	mmc_function_spy("mmc_write");
+	if (mmc_function_spy(d, "mmc_write") <= 0)
-	pthread_mutex_lock(&d->access_lock);
+		return BE_CANCELLED;
-	cancelled = d->cancel;
-	pthread_mutex_unlock(&d->access_lock);
 
+	cancelled = d->cancel;
 	if (cancelled)
 		return BE_CANCELLED;
 
@@ -713,9 +736,7 @@ int mmc_write(struct burn_drive *d, int start, struct buffer *buf)
 				LIBDAX_MSGS_SEV_FATAL, LIBDAX_MSGS_PRIO_HIGH,
 				msg, 0, 0);
 		}
-		pthread_mutex_lock(&d->access_lock);
 		d->cancel = 1;
-		pthread_mutex_unlock(&d->access_lock);
 		return BE_CANCELLED;
 	} 
 
@@ -780,6 +801,9 @@ int mmc_fake_toc(struct burn_drive *d)
 	unsigned char *tdata, size_data[4], start_data[4];
 	char msg[160];
 
+	if (mmc_function_spy(d, "mmc_fake_toc") <= 0)
+		return -1;
+
 	if (d->last_track_no <= 0 || d->complete_sessions <= 0 ||
 	    d->status == BURN_DISC_BLANK)
 		return 2;
@@ -905,8 +929,6 @@ static int mmc_read_toc_al(struct burn_drive *d, int *alloc_len)
 	int i, bpl= 12, old_alloc_len;
 	unsigned char *tdata;
 
-	mmc_function_spy("mmc_read_toc");
-
 	if (*alloc_len < 4)
 		return 0;
 
@@ -1073,6 +1095,9 @@ void mmc_read_toc(struct burn_drive *d)
 {
 	int alloc_len = 4, ret;
 
+	if (mmc_function_spy(d, "mmc_read_toc") <= 0)
+		return;
+
 	ret = mmc_read_toc_al(d, &alloc_len);
 /*
 	fprintf(stderr,
@@ -1100,7 +1125,8 @@ int mmc_read_multi_session_c1(struct burn_drive *d, int *trackno, int *start)
 	struct burn_track **tracks;
 	struct burn_toc_entry toc_entry;
 
-	mmc_function_spy("mmc_read_multi_session_c1");
+	if (mmc_function_spy(d, "mmc_read_multi_session_c1") <= 0)
+		return 0;
 
 	/* First try to evaluate the eventually loaded TOC before issueing
 	   a MMC command. This search obtains the first track of the last
@@ -1187,9 +1213,9 @@ static int mmc_read_disc_info_al(struct burn_drive *d, int *alloc_len)
 
 	mmc_get_configuration(d);
 
+/* ts A70910 : found this as condition for mmc_function_spy() which went up
 	if (*alloc_len < 2)
-
+*/
-	mmc_function_spy("mmc_read_disc_info");
 
 	scsi_init_command(&c, MMC_GET_DISC_INFO, sizeof(MMC_GET_DISC_INFO));
 /*
@@ -1320,6 +1346,9 @@ void mmc_read_disc_info(struct burn_drive *d)
 {
 	int alloc_len = 34, ret;
 
+	if (mmc_function_spy(d, "mmc_read_disc_info") <= 0)
+		return;
+
 	ret = mmc_read_disc_info_al(d, &alloc_len);
 /*
 	fprintf(stderr,"LIBBURN_DEBUG: 51h alloc_len = %d , ret = %d\n",
@@ -1348,7 +1377,8 @@ void mmc_read_atip(struct burn_drive *d)
 	                   4234, 5646, 7056, 8468, -12, -13, -14, -15};
 	               /*    24,   32,   40,   48,   -,   -,   -,   - */
 
-	mmc_function_spy("mmc_read_atip");
+	if (mmc_function_spy(d, "mmc_read_atip") <= 0)
+		return;
 
 	scsi_init_command(&c, MMC_GET_ATIP, sizeof(MMC_GET_ATIP));
 /*
@@ -1504,7 +1534,8 @@ void mmc_read_sectors(struct burn_drive *d,
 	int errorblock, req;
 	struct command c;
 
-	mmc_function_spy("mmc_read_sectors");
+	if (mmc_function_spy(d, "mmc_read_sectors") <= 0)
+		return;
 
 	/* ts A61009 : to be ensured by callers */
 	/* a ssert(len >= 0); */
@@ -1573,7 +1604,8 @@ void mmc_erase(struct burn_drive *d, int fast)
 {
 	struct command c;
 
-	mmc_function_spy("mmc_erase");
+	if (mmc_function_spy(d, "mmc_erase") <= 0)
+		return;
 
 	scsi_init_command(&c, MMC_BLANK, sizeof(MMC_BLANK));
 /*
@@ -1593,7 +1625,9 @@ void mmc_read_lead_in(struct burn_drive *d, struct buffer *buf)
 	int len;
 	struct command c;
 
-	mmc_function_spy("mmc_read_lead_in");
+	if (mmc_function_spy(d, "mmc_read_lead_in") <= 0)
+		return;
+
 	len = buf->sectors;
 	scsi_init_command(&c, MMC_READ_CD, sizeof(MMC_READ_CD));
 /*
@@ -1619,7 +1653,8 @@ void mmc_perform_opc(struct burn_drive *d)
 {
 	struct command c;
 
-	mmc_function_spy("mmc_perform_opc");
+	if (mmc_function_spy(d, "mmc_perform_opc") <= 0)
+		return;
 
 	scsi_init_command(&c, MMC_SEND_OPC, sizeof(MMC_SEND_OPC));
 /*
@@ -1649,7 +1684,8 @@ int mmc_set_streaming(struct burn_drive *d,
 	char msg[160];
 	unsigned char *pd;
 
-	mmc_function_spy("mmc_set_streaming");
+	if (mmc_function_spy(d, "mmc_set_streaming") <= 0)
+		return 0;
 
 	scsi_init_command(&c, MMC_SET_STREAMING, sizeof(MMC_SET_STREAMING));
 /*
@@ -1731,7 +1767,8 @@ void mmc_set_speed(struct burn_drive *d, int r, int w)
 	int ret, end_lba = 0;
 	struct burn_speed_descriptor *best_sd = NULL;
 
-	mmc_function_spy("mmc_set_speed");
+	if (mmc_function_spy(d, "mmc_set_speed") <= 0)
+		return;
 
 	if (r <= 0 || w <= 0) {
 		/* ts A70712 : now searching for best speed descriptor */
@@ -1851,8 +1888,6 @@ static int mmc_get_configuration_al(struct burn_drive *d, int *alloc_len)
 	d->current_feat21h_link_size = -1;
 	d->current_feat2fh_byte4 = -1;
 
-	mmc_function_spy("mmc_get_configuration");
-
 	scsi_init_command(&c, MMC_GET_CONFIGURATION,
 			 sizeof(MMC_GET_CONFIGURATION));
 /*
@@ -2039,6 +2074,9 @@ void mmc_get_configuration(struct burn_drive *d)
 {
 	int alloc_len = 8, ret;
 
+	if (mmc_function_spy(d, "mmc_get_configuration") <= 0)
+		return;
+
 	/* first command execution to learn Allocation Length */
 	ret = mmc_get_configuration_al(d, &alloc_len);
 /*
@@ -2066,8 +2104,6 @@ static int mmc_read_format_capacities_al(struct burn_drive *d,
 	char msg[160];
 */
 
-	mmc_function_spy("mmc_read_format_capacities");
-
 	if (*alloc_len < 4)
 		return 0;
 
@@ -2204,6 +2240,9 @@ int mmc_read_format_capacities(struct burn_drive *d, int top_wanted)
 {
 	int alloc_len = 4, ret;
 
+	if (mmc_function_spy(d, "mmc_read_format_capacities") <= 0)
+		return 0;
+
 	ret = mmc_read_format_capacities_al(d, &alloc_len, top_wanted);
 /*
 	fprintf(stderr,"LIBBURN_DEBUG: 23h alloc_len = %d , ret = %d\n",
@@ -2220,7 +2259,8 @@ void mmc_sync_cache(struct burn_drive *d)
 {
 	struct command c;
 
-	mmc_function_spy("mmc_sync_cache");
+	if (mmc_function_spy(d, "mmc_sync_cache") <= 0)
+		return;
 
 	scsi_init_command(&c, MMC_SYNC_CACHE, sizeof(MMC_SYNC_CACHE));
 /*
@@ -2262,7 +2302,8 @@ int mmc_read_buffer_capacity(struct burn_drive *d)
 	unsigned char *data;
 	int alloc_len = 12;
 
-	mmc_function_spy("mmc_read_buffer_capacity");
+	if (mmc_function_spy(d, "mmc_read_buffer_capacity") <= 0)
+		return 0;
 
 	scsi_init_command(&c, MMC_READ_BUFFER_CAPACITY,
 			 sizeof(MMC_READ_BUFFER_CAPACITY));
@@ -2328,7 +2369,8 @@ int mmc_format_unit(struct burn_drive *d, off_t size, int flag)
 	char msg[160],descr[80];
 	int full_format_type = 0x00; /* Full Format (or 0x10 for DVD-RW ?) */
 
-	mmc_function_spy("mmc_format_unit");
+	if (mmc_function_spy(d, "mmc_format_unit") <= 0)
+		return 0;
 
 	scsi_init_command(&c, MMC_FORMAT_UNIT, sizeof(MMC_FORMAT_UNIT));
 /*
@@ -2561,8 +2603,6 @@ static int mmc_get_write_performance_al(struct burn_drive *d,
 	/* A61225 : 1 = report about speed descriptors */
 	static int speed_debug = 0;
 
-	mmc_function_spy("mmc_get_write_performance");
-
 	if (d->current_profile <= 0)
 		mmc_get_configuration(d);
 
@@ -2680,6 +2720,9 @@ int mmc_get_write_performance(struct burn_drive *d)
 {
 	int alloc_len = 8, max_descr = 0, ret;
 
+	if (mmc_function_spy(d, "mmc_get_write_performance") <= 0)
+		return 0;
+
 	/* first command execution to learn number of descriptors and 
            dxfer_len */
 	ret = mmc_get_write_performance_al(d, &alloc_len, &max_descr);
@@ -2807,7 +2850,9 @@ int mmc_read_10(struct burn_drive *d, int start,int amount, struct buffer *buf)
 {
 	struct command c;
 
-	mmc_function_spy("mmc_read_10");
+	if (mmc_function_spy(d, "mmc_read_10") <= 0)
+		return -1;
+;
 	if (amount > BUFFER_SIZE / 2048)
 		return -1;
 

libburn/sbc.c

@@ -10,6 +10,13 @@
 #include "spc.h"
 #include "options.h"
 
+
+/* ts A70910
+   debug: for tracing calls which might use open drive fds
+          or for catching SCSI usage of emulated drives. */
+int mmc_function_spy(struct burn_drive *d, char * text);
+
+
 /* spc command set */
 static unsigned char SBC_LOAD[] = { 0x1b, 0, 0, 0, 3, 0 };
 static unsigned char SBC_UNLOAD[] = { 0x1b, 0, 0, 0, 2, 0 };
@@ -19,6 +26,9 @@ void sbc_load(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "load") <= 0)
+		return;
+
 	scsi_init_command(&c, SBC_LOAD, sizeof(SBC_LOAD));
 /*
 	memcpy(c.opcode, SBC_LOAD, sizeof(SBC_LOAD));
@@ -35,6 +45,9 @@ void sbc_eject(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "eject") <= 0)
+		return;
+
 	scsi_init_command(&c, SBC_UNLOAD, sizeof(SBC_UNLOAD));
 /*
 	memcpy(c.opcode, SBC_UNLOAD, sizeof(SBC_UNLOAD));
@@ -51,6 +64,9 @@ int sbc_start_unit(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "start_unit") <= 0)
+		return 0;
+
 	scsi_init_command(&c, SBC_START_UNIT, sizeof(SBC_START_UNIT));
 /*
 	memcpy(c.opcode, SBC_START_UNIT, sizeof(SBC_START_UNIT));

libburn/sg-freebsd.c

@@ -50,8 +50,9 @@ int burn_drive_is_banned(char *device_address);
 
 
 /* ts A60821
-   <<< debug: for tracing calls which might use open drive fds */
+   debug: for tracing calls which might use open drive fds
-int mmc_function_spy(char * text);
+          or for catching SCSI usage of emulated drives. */
+int mmc_function_spy(struct burn_drive *d, char * text);
 
 
 /* ts A61021 : Moved most code from scsi_enumerate_drives under
@@ -390,7 +391,7 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 
 /* ts A60821
    <<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("enumerate_common : -------- doing grab");
+	mmc_function_spy(NULL, "enumerate_common : -------- doing grab");
 
 /* try to get the drive info */
 	if (t->grab(t)) {
@@ -404,7 +405,7 @@ static void enumerate_common(char *fname, int bus_no, int host_no,
 
 /* ts A60821
    <<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("enumerate_common : ----- would release ");
+	mmc_function_spy(NULL, "enumerate_common : ----- would release ");
 
 }
 
@@ -452,7 +453,8 @@ int sg_grab(struct burn_drive *d)
 	int count;
 	struct cam_device *cam;
 
-	mmc_function_spy("sg_grab");
+	if (mmc_function_spy(d, "sg_grab") <= 0)
+		return 0;
 
 	if (burn_drive_is_open(d)) {
 		d->released = 0;
@@ -487,14 +489,15 @@ int sg_grab(struct burn_drive *d)
 
 int sg_release(struct burn_drive *d)
 {
-	mmc_function_spy("sg_release");
+	if (mmc_function_spy(d, "sg_release") <= 0)
+		return 0;
 
 	if (d->cam == NULL) {
 		burn_print(1, "release an ungrabbed drive.  die\n");
 		return 0;
 	}
 
-	mmc_function_spy("sg_release ----------- closing.");
+	mmc_function_spy(NULL, "sg_release ----------- closing.");
 
 	sg_close_drive(d);
 	d->released = 1;
@@ -510,7 +513,7 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	char buf[161];
 	snprintf(buf, sizeof (buf), "sg_issue_command  d->cam=%p d->released=%d",
 		(void*)d->cam, d->released);
-	mmc_function_spy(buf);
+	mmc_function_spy(NULL, buf);
 
 	if (d->cam == NULL) {
 		c->error = 0;

libburn/sg-linux.c

@@ -201,8 +201,9 @@ extern int burn_sg_open_abort_busy;
 
 
 /* ts A60821
-   <<< debug: for tracing calls which might use open drive fds */
+   debug: for tracing calls which might use open drive fds
-int mmc_function_spy(char * text);
+          or for catching SCSI usage of emulated drives. */
+int mmc_function_spy(struct burn_drive *d, char * text);
 
 
 /* ------------------------------------------------------------------------ */
@@ -939,7 +940,8 @@ int sg_grab(struct burn_drive *d)
 
 /* ts A60821
    <<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("sg_grab");
+	if (mmc_function_spy(d, "sg_grab") <= 0)
+		return 0;
 
 
 	/* ts A60813 - A60927
@@ -967,7 +969,7 @@ int sg_grab(struct burn_drive *d)
 
 		/* ts A60821
    		<<< debug: for tracing calls which might use open drive fds */
-		mmc_function_spy("sg_grab ----------- opening");
+		mmc_function_spy(NULL, "sg_grab ----------- opening");
 
 		/* ts A70409 : DDLP-B */
 		/* >>> obtain single lock on d->devname */
@@ -1025,7 +1027,8 @@ int sg_release(struct burn_drive *d)
 {
 	/* ts A60821
    	<<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("sg_release");
+	if (mmc_function_spy(d, "sg_release") <= 0)
+		return 0;
 
 	if (d->fd < 1) {
 		burn_print(1, "release an ungrabbed drive.  die\n");
@@ -1034,7 +1037,7 @@ int sg_release(struct burn_drive *d)
 
 	/* ts A60821
    	<<< debug: for tracing calls which might use open drive fds */
-	mmc_function_spy("sg_release ----------- closing");
+	mmc_function_spy(NULL, "sg_release ----------- closing");
 
 	sg_close_drive(d);
 	return 0;
@@ -1131,7 +1134,7 @@ int sg_issue_command(struct burn_drive *d, struct command *c)
 	char buf[161];
 	sprintf(buf,"sg_issue_command   d->fd= %d  d->released= %d\n",
 		d->fd,d->released);
-	mmc_function_spy(buf);
+	mmc_function_spy(NULL, buf);
 
 #ifdef Libburn_log_sg_commandS
 	/* ts A61030 */

libburn/spc.c

@@ -27,6 +27,11 @@
 #include "libdax_msgs.h"
 extern struct libdax_msgs *libdax_messenger;
 
+/* ts A70910
+   debug: for tracing calls which might use open drive fds
+          or for catching SCSI usage of emulated drives. */
+int mmc_function_spy(struct burn_drive *d, char * text);
+
 
 /* spc command set */
 /* ts A70519 : allocation length byte 3+4 was 0,255 */
@@ -63,6 +68,9 @@ int spc_test_unit_ready_r(struct burn_drive *d, int *key, int *asc, int *ascq)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "test_unit_ready") <= 0)
+		return 0;
+
 	scsi_init_command(&c, SPC_TEST_UNIT_READY,sizeof(SPC_TEST_UNIT_READY));
 /*
 	c.oplen = sizeof(SPC_TEST_UNIT_READY);
@@ -111,6 +119,9 @@ void spc_request_sense(struct burn_drive *d, struct buffer *buf)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "request_sense") <= 0)
+		return;
+
 	scsi_init_command(&c, SPC_REQUEST_SENSE, sizeof(SPC_REQUEST_SENSE));
 	c.retry = 0;
 /*
@@ -130,6 +141,9 @@ int spc_get_erase_progress(struct burn_drive *d)
 {
 	struct buffer b;
 
+	if (mmc_function_spy(d, "get_erase_progress") <= 0)
+		return;
+
 	spc_request_sense(d, &b);
 	return (b.data[16] << 8) | b.data[17];
 }
@@ -140,6 +154,9 @@ void spc_inquiry(struct burn_drive *d)
 	struct burn_scsi_inquiry_data *id;
 	struct command c;
 
+	if (mmc_function_spy(d, "inquiry") <= 0)
+		return;
+
 	scsi_init_command(&c, SPC_INQUIRY, sizeof(SPC_INQUIRY));
 /*
 	memcpy(c.opcode, SPC_INQUIRY, sizeof(SPC_INQUIRY));
@@ -171,6 +188,9 @@ void spc_prevent(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "prevent") <= 0)
+		return;
+
 	scsi_init_command(&c, SPC_PREVENT, sizeof(SPC_PREVENT));
 /*
 	memcpy(c.opcode, SPC_PREVENT, sizeof(SPC_PREVENT));
@@ -186,6 +206,9 @@ void spc_allow(struct burn_drive *d)
 {
 	struct command c;
 
+	if (mmc_function_spy(d, "allow") <= 0)
+		return;
+
 	scsi_init_command(&c, SPC_ALLOW, sizeof(SPC_ALLOW));
 /*
 	memcpy(c.opcode, SPC_ALLOW, sizeof(SPC_ALLOW));
@@ -368,6 +391,9 @@ void spc_sense_caps(struct burn_drive *d)
 {
 	int alloc_len, start_len = 22, ret;
 
+	if (mmc_function_spy(d, "sense_caps") <= 0)
+		return;
+
 	/* first command execution to learn Allocation Length */
 	alloc_len = start_len;
 	ret = spc_sense_caps_al(d, &alloc_len, 1);
@@ -389,6 +415,9 @@ void spc_sense_error_params(struct burn_drive *d)
 	unsigned char *page;
 	struct command c;
 
+	if (mmc_function_spy(d, "sense_error_params") <= 0)
+		return;
+
 	scsi_init_command(&c, SPC_MODE_SENSE, sizeof(SPC_MODE_SENSE));
 /*
 	memcpy(c.opcode, SPC_MODE_SENSE, sizeof(SPC_MODE_SENSE));
@@ -419,6 +448,9 @@ void spc_select_error_params(struct burn_drive *d,
 	struct buffer buf;
 	struct command c;
 
+	if (mmc_function_spy(d, "select_error_params") <= 0)
+		return;
+
 	scsi_init_command(&c, SPC_MODE_SELECT, sizeof(SPC_MODE_SELECT));
 /*
 	memcpy(c.opcode, SPC_MODE_SELECT, sizeof(SPC_MODE_SELECT));
@@ -457,6 +489,9 @@ void spc_sense_write_params(struct burn_drive *d)
 	unsigned char *page;
 	struct command c;
 
+	if (mmc_function_spy(d, "sense_write_params") <= 0)
+		return;
+
 	/* ts A61007 : Done in soft at only caller burn_drive_grab() */
 	/* a ssert(d->mdata->cdr_write || d->mdata->cdrw_write ||
 	       d->mdata->dvdr_write || d->mdata->dvdram_write); */
@@ -514,6 +549,9 @@ void spc_select_write_params(struct burn_drive *d,
 	struct buffer buf;
 	struct command c;
 
+	if (mmc_function_spy(d, "select_write_params") <= 0)
+		return;
+
 	/* ts A61007 : All current callers are safe. */
 	/* a ssert(o->drive == d); */
 
@@ -554,6 +592,9 @@ void spc_select_write_params(struct burn_drive *d,
 
 void spc_getcaps(struct burn_drive *d)
 {
+	if (mmc_function_spy(d, "getcaps") <= 0)
+		return;
+
 	spc_inquiry(d);
 	spc_sense_caps(d);
 	spc_sense_error_params(d);
@@ -573,6 +614,9 @@ void spc_probe_write_modes(struct burn_drive *d)
 	int last_try = 0;
 	struct command c;
 
+	if (mmc_function_spy(d, "spc_probe_write_modes") <= 0)
+		return;
+
 	/* ts A70213 : added pseudo try_write_type 4 to set a suitable mode */
 	while (try_write_type != 5) {
 		burn_print(9, "trying %d, %d\n", try_write_type,

libburn/transport.h

@@ -199,6 +199,8 @@ struct burn_drive
 	/* ts A61106 */
 	int silent_on_scsi_error;
 
+	int stdio_fd;
+
 	int nwa;		/* next writeable address */
 	int alba;		/* absolute lba */
 	int rlba;		/* relative lba in section */

libburn/write.c

@@ -1190,7 +1190,7 @@ int burn_dvd_write_track(struct burn_write_opts *o,
 	}
 
 
-	/* >>> ts A70215 : what about offset padding ? */
+	/* (offset padding is done within sector_data()) */
 
 	burn_disc_init_track_status(o, s, tnum, sectors);
 	for (i = 0; open_ended || i < sectors; i++) {
@@ -1213,7 +1213,7 @@ int burn_dvd_write_track(struct burn_write_opts *o,
 		d->progress.sector++;
 	}
 	
-	/* >>> ts A70215 : what about tail padding ? */
+	/* (tail padding is done in sector_data()) */
 
 	/* Pad up buffer to next full o->obs (usually 32 kB) */
 	if (o->obs_pad && out->bytes > 0 && out->bytes < o->obs) {
@@ -1607,7 +1607,8 @@ early_failure:;
 
 
 /* ts A70904 */
-int burn_stdio_open_write(struct burn_drive *d, off_t start_byte, int flag)
+int burn_stdio_open_write(struct burn_drive *d, off_t start_byte,
+			 int sector_size, int flag)
 {
 
 /* <<< We need _LARGEFILE64_SOURCE defined by the build system.
@@ -1642,7 +1643,7 @@ int burn_stdio_open_write(struct burn_drive *d, off_t start_byte, int flag)
 		close(fd);
 		fd = -1;
 	}
-	d->nwa = start_byte / 2048;
+	d->nwa = start_byte / sector_size;
 	return fd;
 }
 
@@ -1672,31 +1673,179 @@ int burn_stdio_write(int fd, char *buf, int count, struct burn_drive *d,
 			0x00020148,
 			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
 			"Cannot write desired amount of data", errno, 0);
+		d->cancel = 1;
 		return 0;
 	}
 	return count;
 }
 
 
+/* ts A70911
+   If defined this makes stdio run on top of sector_data() rather than
+   own stdio read and write functions. The MMC function pointers d->write()
+   and d->sync_cache() get replaced by stdio substitutes.
+*/
+#define Libburn_stdio_track_by_sector_datA 1
+
+
+#ifdef Libburn_stdio_track_by_sector_datA
+
+/* ts A70910 : to be used as burn_drive.write(), emulating mmc_write() */
+int burn_stdio_mmc_write(struct burn_drive *d, int start, struct buffer *buf)
+{
+	int ret;
+	off_t start_byte;
+
+	if (d->cancel)
+		return BE_CANCELLED;
+	if (d->stdio_fd < 0) {
+
+		/* >>> program error */;
+
+		d->cancel = 1;
+		return BE_CANCELLED;
+	}
+	if (start != d->nwa) {
+		char msg[80];
+
+		start_byte = ((off_t) start) * 
+				(off_t) (buf->bytes / buf->sectors);
+		if (lseek(d->stdio_fd, start_byte, SEEK_SET)==-1) {
+			sprintf(msg, "Cannot address start byte %.f",
+			 	(double) start_byte);
+			libdax_msgs_submit(libdax_messenger, d->global_index,
+				0x00020147,
+				LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+				msg, errno, 0);
+			d->cancel = 1;
+			return BE_CANCELLED;
+		}
+		d->nwa = start;
+	}
+	ret = burn_stdio_write(d->stdio_fd,(char *)buf->data, buf->bytes, d,0);
+	if (ret <= 0)
+		return BE_CANCELLED;
+	d->nwa += buf->sectors;
+	return 0;
+}
+
+
+/* ts A70910 : to be used as burn_drive.write(),
+               emulating mmc_write() with simulated writing. */
+int burn_stdio_mmc_dummy_write(struct burn_drive *d, int start,
+							struct buffer *buf)
+{
+	if (d->cancel)
+		return BE_CANCELLED;
+	d->nwa = start + buf->sectors;
+	return 0;
+}
+
+
+/* ts A70911 */
+/* Flush stdio system buffer to physical device.
+   @param flag bit0= do not report debug message (intermediate sync)
+*/
+int burn_stdio_sync_cache(struct burn_drive *d, int flag)
+{
+	if (d->stdio_fd < 0) {
+
+		/* >>> program error */;
+
+		d->cancel = 1;
+		return 0;
+	}
+	if (!(flag & 1))
+		libdax_msgs_submit(libdax_messenger, -1, 0x00000002,
+			   LIBDAX_MSGS_SEV_DEBUG, LIBDAX_MSGS_PRIO_ZERO,
+			   "syncing cache (stdio fsync)", 0, 0);
+	if (fsync(d->stdio_fd) != 0) {
+		libdax_msgs_submit(libdax_messenger, d->global_index,
+			0x00020148,
+			LIBDAX_MSGS_SEV_SORRY, LIBDAX_MSGS_PRIO_HIGH,
+			"Cannot write desired amount of data", errno, 0);
+		d->cancel = 1;
+		return 0;
+	}
+	return 1;
+}
+
+
+/* ts A70911 : to be used as burn_drive.sync_cache(),
+               emulating mmc_sync_cache() */
+void burn_stdio_mmc_sync_cache(struct burn_drive *d)
+{
+	burn_stdio_sync_cache(d, 0);
+}
+
+
+#endif /* Libburn_stdio_track_by_sector_datA */
+
+
 /* ts A70904 */
 int burn_stdio_write_track(struct burn_write_opts *o, struct burn_session *s,
-				int tnum, int fd, int flag)
+				int tnum, int flag)
 {
-	int open_ended, bufsize, ret, eof_seen = 0, sectors;
+	int open_ended, bufsize, ret, sectors, fd;
 	struct burn_track *t = s->track[tnum];
 	struct burn_drive *d = o->drive;
-	off_t t_size, w_count;
 	char buf[16*2048];
+#ifdef Libburn_stdio_track_by_sector_datA
+	int i, prev_sync_sector = 0;
+	struct buffer *out = d->buffer;
+#else
+	int eof_seen = 0;
+	off_t t_size, w_count;
+#endif
 
 	bufsize = sizeof(buf);
+	fd = d->stdio_fd;
 
 	sectors = burn_track_get_sectors(t);
 	burn_disc_init_track_status(o, s, tnum, sectors);
+	open_ended = burn_track_is_open_ended(t);
+
+#ifdef Libburn_stdio_track_by_sector_datA
+
+	/* attach stdio emulators for mmc_*() functions */
+	if (o->simulate)
+		d->write = burn_stdio_mmc_dummy_write;
+	else
+		d->write = burn_stdio_mmc_write;
+	d->sync_cache = burn_stdio_mmc_sync_cache;
+
+	for (i = 0; open_ended || i < sectors; i++) {
+		/* transact a (CD sized) sector */
+		if (!sector_data(o, t, 0))
+			return 0;			
+		if (open_ended) {
+			d->progress.sectors = sectors = d->progress.sector;
+			if (burn_track_is_data_done(t))
+	break;
+		}
+		d->progress.sector++;
+		/* Flush to disk after each full MB */
+		if (d->progress.sector - prev_sync_sector >= 512) {
+			prev_sync_sector = d->progress.sector;
+			if (!o->simulate)
+				burn_stdio_sync_cache(d, 1);
+		}
+	}
+
+	/* Pad up buffer to next full o->obs (usually 32 kB) */
+	if (o->obs_pad && out->bytes > 0 && out->bytes < o->obs) {
+		memset(out->data + out->bytes, 0, o->obs - out->bytes);
+		out->sectors += (o->obs - out->bytes) / 2048;
+		out->bytes = o->obs;
+	}
+	ret = burn_write_flush(o, t);
+
+#else /* Libburn_stdio_track_by_sector_datA */
+
+	t_size = t->source->get_size(t->source);
 
 	/* >>> write t->offset zeros */;
 
-	open_ended = burn_track_is_open_ended(t);
-	t_size = t->source->get_size(t->source);
 	for(w_count = 0; w_count < t_size || open_ended; w_count += ret) {
 
 
@@ -1730,10 +1879,19 @@ int burn_stdio_write_track(struct burn_write_opts *o, struct burn_session *s,
 			d->progress.sectors = d->progress.sector;
 		t->writecount += ret;
 		t->written_sectors = t->writecount / 2048;
+
+		/* Flush to physical device after each full MB */
+		if (d->progress.sector - prev_sync_sector >= 512) {
+			prev_sync_sector = d->progress.sector;
+			if (!o->simulate)
+				burn_stdio_sync_cache(d, 1);
+		}
 	}
 
 	/* >>> write t->tail zeros */;
 
+#endif
+
 	return 1;
 }
 
@@ -1742,7 +1900,7 @@ int burn_stdio_write_track(struct burn_write_opts *o, struct burn_session *s,
 int burn_stdio_write_sync(struct burn_write_opts *o,
 				 struct burn_disc *disc)
 {
-	int ret, fd = -1;
+	int ret;
 	struct burn_drive *d = o->drive;
 
 	d->needs_close_session = 0;
@@ -1758,12 +1916,15 @@ int burn_stdio_write_sync(struct burn_write_opts *o,
 	d->progress.session = 0;
 	d->progress.tracks = 1;
 
+	/* >>> adjust sector size (2048) to eventual audio or even raw */
 	/* open target file */
-	fd = burn_stdio_open_write(d, o->start_byte, 0);
+	if (d->stdio_fd >= 0)
-	if (fd == -1)
+		close(d->stdio_fd);
+	d->stdio_fd = burn_stdio_open_write(d, o->start_byte, 2048, 0);
+	if (d->stdio_fd == -1)
 		{ret = 0; goto ex;}
 
-	ret = burn_stdio_write_track(o, disc->session[0], 0, fd, 0);
+	ret = burn_stdio_write_track(o, disc->session[0], 0, 0);
 	if (ret <= 0)
 		goto ex;
 
@@ -1773,8 +1934,10 @@ int burn_stdio_write_sync(struct burn_write_opts *o,
 	d->progress.sectors = 0;
 	ret = 1;
 ex:;
-	if (fd != -1)
+	if (d->stdio_fd != -1) {
-		close (fd);
+		close (d->stdio_fd);
+		d->stdio_fd = -1;
+	}
 	/* update media state records */
 	burn_drive_mark_unready(d);
 
@@ -2051,7 +2214,7 @@ int burn_random_access_write(struct burn_drive *d, off_t byte_address,
 		return 0;
 	}
 	if(d->drive_role != 1) {
-		fd = burn_stdio_open_write(d, byte_address, 0);
+		fd = burn_stdio_open_write(d, byte_address, 2048, 0);
 		if (fd == -1)
 			return 0;
 	}