static void dump_cd_sect (char *tb)
{
unsigned char buf[128];
int i,j;
unsigned char *p,*q,c;
q=tb;
for (i=0; i<32 && debug_level('C')>5; i++) { /* 32x64 */
p=buf;
for (j=0; j<64; j++) {
c=*q++;
*p++ = (isprint(c)? c:'.');
}
C_printf("%03x[%s]\n",i*64,buf);
}
q=tb;
for (i=0; i<64 && debug_level('C')>8; i++) { /* 64x32 */
p=buf;
for (j=0; j<4; j++) {
p+=sprintf(p,":%02x%02x%02x%02x%02x%02x%02x%02x",q[0],q[1],q[2],
q[3],q[4],q[5],q[6],q[7]);
q+=8;
}
C_printf("%03x%s\n",i*32,buf);
}
}
static int namecomp(const char *name1, size_t len1, const char *name2,
size_t len2)
{
if (len1 > 1 && name1[len1 - 1] == '.')
len1--;
C_printf("MSCDEX: %zu %.*s\n", len1, (int)len1, name1);
if (len1 == len2 && memcmp(name1, name2, len1) == 0) {
C_printf("MSCDEX: Get DirEntry : Found : %s\n", name1);
return 1;
}
return 0;
}
static int logging_ioctl(int fd, unsigned int cmd, void *arg)
{
int rval;
int err;
if (debug_level('C')>5)
C_printf("CDROM: ioctl %#x\n", cmd);
rval = ioctl(fd, cmd, arg);
err = errno;
if (rval == -1) {
C_printf("CDROM: err %s\n", strerror(errno));
errno = err;
}
return rval;
}
static void cdrom_reset(void)
{
/* after a disk change a new read access will
return an error. In order to unlock this condition
the drive must be reopened.
Does someone know a better way? */
C_printf("CDROM: cdrom reset\n");
close (cdrom_fd);
cdrom_fd = open (path_cdrom, O_RDONLY | O_NONBLOCK);
if (cdrom_fd >= 0) ioctl (cdrom_fd, CDROMRESET, NULL);
}
static int fill_buffer(int copyFlag, Bit32u buffer, unsigned char *readBuf,
unsigned entryLength)
{
// TO DO : name gefunden, Daten in den Buffer kopieren
if (copyFlag) {
Bit8u writeBuf[256];
C_printf
("MSCDEX: GetDirEntry: Copyflag structure not entirely "
"accurate maybe\n");
if (entryLength > 256)
return MSCDEX_ERROR_BAD_FORMAT;
// 00h BYTE length of XAR in Logical Block Numbers
writeBuf[0] = readBuf[1];
// 01h DWORD Logical Block Number of file start
memcpy(&writeBuf[1], &readBuf[0x2], 4);
// 05h WORD size of disk in logical blocks
writeBuf[5] = 0;
writeBuf[6] = 8;
// 07h DWORD file length in bytes
memcpy(&writeBuf[7], &readBuf[0xa], 4);
// 0bh DWORD date and time
memcpy(&writeBuf[0xb], &readBuf[0x12], 7);
// 12h BYTE bit flags
writeBuf[0x12] = readBuf[0x19];
// 13h BYTE interleave size
writeBuf[0x13] = readBuf[0x1a];
// 14h BYTE interleave skip factor
writeBuf[0x14] = readBuf[0x1b];
// 15h WORD volume set sequence number
memcpy(&writeBuf[0x15], &readBuf[0x1c], 2);
writeBuf[0x17] = readBuf[0x20];
memcpy(&writeBuf[0x18], &readBuf[21],
readBuf[0x20] <= 38 ? readBuf[0x20] : 38);
MEMCPY_2DOS(buffer, writeBuf, 0x18 + 40);
} else {
// Direct copy
MEMCPY_2DOS(buffer, readBuf, entryLength);
}
return 1; /* ISO 9660 */
}
void
#line 268 "./cwebdir/ctang-w2c.ch"
output_defs P1H(void)
#line 608 "./cwebdir/ctangle.w"
{
sixteen_bits a;
push_level(NULL);
for(cur_text= text_info+1;cur_text<text_ptr;cur_text++)
if(cur_text->text_link==0){
cur_byte= cur_text->tok_start;
cur_end= (cur_text+1)->tok_start;
C_printf("%s","#define ");
out_state= normal;
protect= 1;
while(cur_byte<cur_end){
a= *cur_byte++;
if(cur_byte==cur_end&&a=='\n')break;
if(out_state==verbatim&&a!=string&&a!=constant&&a!='\n')
C_putc(a);
else if(a<0200)out_char(a);
else{
a= (a-0200)*0400+*cur_byte++;
if(a<024000){
cur_val= a;out_char(identifier);
}
else if(a<050000){confusion("macro defs have strange char");}
else{
cur_val= a-050000;cur_section= cur_val;out_char(section_number);
}
}
}
protect= 0;
flush_buffer();
}
pop_level(0);
}
void mem_report (void)
{
const struct mem_head *m;
unsigned num;
C_printf ("~0 Max memory at one time: %u bytes.\n", (unsigned int)mem_max);
C_printf (" Total # of allocations: %u.\n", (unsigned int)mem_allocs);
C_printf (" Total # of frees: %u.\n", (unsigned int)mem_frees);
if (!mem_list)
C_printf (" No un-freed memory.\n");
for (m = mem_list, num = 0; m; m = m->next, num++)
{
C_printf (" Un-freed memory 0x%p at %s (%u)\n", m+1, m->file, m->line);
if (num > 20)
{
C_printf (" ..and more.\n");
break;
}
}
}
void cdrom_helper(unsigned char *req_buf, unsigned char *transfer_buf,
unsigned int dos_transfer_buf)
{
unsigned int Sector_plus_150,Sector;
struct cdrom_msf cdrom_msf;
struct cdrom_subchnl cdrom_subchnl;
struct cdrom_tochdr cdrom_tochdr;
struct cdrom_tocentry cdrom_tocentry;
struct cdrom_volctrl cdrom_volctrl;
int n, err;
cdrom_subchnl.cdsc_format = CDROM_MSF;
IndexCd=(int)((HI(ax) & 0xC0)>>6);
HI(ax) = HI(ax) & 0x3F;
if ((cdu33a) && (cdrom_fd < 0)) {
cdrom_fd = open (path_cdrom, O_RDONLY | O_NONBLOCK);
if (cdrom_fd < 0) {
switch (HI(ax)) {
case 0x09: /* media changed request */
LO(bx) = 1; /* media changed */
LO(ax) = 0;
return;
case 0x0A: /* device status request */
LWORD(ebx) = audio_status.status | 0x800; /* no disc */
LO(ax) = 0;
return;
}
LO(ax) = 1; /* for other requests return with error */
return ;
}
}
switch (HI(ax)) {
case 0x01: /* NOTE: you can't see XA data disks if bit 10 of status
* is cleared, MSCDEX will test it and skip XA entries!
* Actually the entries skipped must have this pattern:
* xxxx1xxx xxxxxxxx 0x58 0x41
* and the mscdex 2.25 code is:
* test word ptr [bx+1Eh],400h
* jz [check for XA]
* [return 0 = valid entry]
* [check for XA]
* ...
* cmp word ptr es:[bx+6],4158h 'XA'
* jne [return 0]
* mov ax,es:[bx+4]
* and ax,8
* [return ax]
*/
audio_status.status = 0x00000710; /* see function 0x0A below */
audio_status.paused_bit = 0;
audio_status.media_changed = 0;
audio_status.volume0 = 0xFF;
audio_status.volume1 = 0xFF;
audio_status.volume2 = 0;
audio_status.volume3 = 0;
audio_status.outchan0 = 0;
audio_status.outchan1 = 1;
audio_status.outchan2 = 2;
audio_status.outchan3 = 3;
cdrom_fd = open (path_cdrom, O_RDONLY | O_NONBLOCK);
err = errno;
if (cdrom_fd < 0) {
C_printf("CDROM: cdrom open (%s) failed: %s\n",
path_cdrom, strerror(err));
LO(ax) = 0;
if ((err == EIO) || (err==ENOMEDIUM)) {
/* drive which cannot be opened if no
disc is inserted! */
cdu33a = 1;
if (! eject_allowed)
LO(ax) = 1; /* no disk in drive */
}
else LO(ax) = 1; /* no cdrom drive installed */
if (! eject_allowed)
LO(ax) = 1; /* no disk in drive */
}
else {
LO(ax) = 0;
if (! eject_allowed) {
if (ioctl (cdrom_fd, CDROMREADTOCHDR, &cdrom_tochdr))
if (ioctl (cdrom_fd, CDROMREADTOCHDR, &cdrom_tochdr))
LO(ax) = 1;
}
}
break;
case 0x02: /* read long */
if (eject_allowed && ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl) && errno != ENOTTY) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disc in drive */
LO(ax) = 1;
break;
}
else { /* disc in drive */
}
}
if (req_buf == NULL && transfer_buf == NULL) {
req_buf = SEG_ADR((unsigned char *), es, di);
dos_transfer_buf = SEGOFF2LINEAR(REG(ds), LWORD(esi));
}
if (*CALC_PTR(req_buf,MSCD_READ_ADRESSING,u_char) == 1) {
cdrom_msf.cdmsf_min0 = *CALC_PTR(req_buf,MSCD_READ_STARTSECTOR+2,u_char);
cdrom_msf.cdmsf_sec0 = *CALC_PTR(req_buf,MSCD_READ_STARTSECTOR+1,u_char);
cdrom_msf.cdmsf_frame0 = *CALC_PTR(req_buf,MSCD_READ_STARTSECTOR+0,u_char);
Sector = cdrom_msf.cdmsf_min0*60*75+cdrom_msf.cdmsf_sec0*75
+cdrom_msf.cdmsf_frame0-150;
}
else { Sector = *CALC_PTR(req_buf,MSCD_READ_STARTSECTOR,u_long);
}
C_printf("CDROM: reading sector %#x (fmt %d)\n", Sector,
*CALC_PTR(req_buf,MSCD_READ_ADRESSING,u_char));
if ((off_t) -1 == lseek (cdrom_fd, Sector*CD_FRAMESIZE, SEEK_SET)) {
HI(ax) = (errno == EINVAL ? 0x08 : 0x0F);
C_printf("CDROM: lseek failed: %s\n", strerror(errno));
LO(ax) = 1;
} else {
n = *CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE;
if (transfer_buf == NULL) {
n = dos_read (cdrom_fd, dos_transfer_buf, n);
} else {
n = unix_read (cdrom_fd, transfer_buf, n);
}
if ( n < 0 ) {
/* cd must be in drive, reset drive and try again */
cdrom_reset();
if ((off_t) -1 == lseek (cdrom_fd, Sector*CD_FRAMESIZE, SEEK_SET)) {
HI(ax) = (errno == EINVAL ? 0x08 : 0x0F);
C_printf("CDROM: lseek failed: %s\n", strerror(errno));
LO(ax) = 1;
} else {
n = *CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE;
if (transfer_buf == NULL)
n = dos_read (cdrom_fd, dos_transfer_buf, n);
else
n = unix_read (cdrom_fd, transfer_buf, n);
if ( n < 0) {
HI(ax) = (errno == EFAULT ? 0x0A : 0x0F);
C_printf("CDROM: sector read (to %p, len %#x) failed: %s\n",
transfer_buf, *CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE, strerror(errno));
LO(ax) = 1;
} else LO(ax) = 0;
}
}
if (n != *CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE) {
C_printf("CDROM: sector read len %#x got %#x\n",
*CALC_PTR(req_buf,MSCD_READ_NUMSECTORS,u_short)*CD_FRAMESIZE, n);
LO(ax) = 1;
HI(ax) = 0x0F;
} else {
#ifdef CDROM_DEBUG
dump_cd_sect(transfer_buf);
#endif
LO(ax) = 0;
}
}
break;
case 0x03: /* seek */
req_buf = SEG_ADR((unsigned char *), es, di);
if ((off_t)-1 == lseek (cdrom_fd, *CALC_PTR(req_buf,MSCD_SEEK_STARTSECTOR,u_long)*CD_FRAMESIZE, SEEK_SET)) {
C_printf("CDROM: lseek failed: %s\n", strerror(errno));
LO(ax) = 1;
}
break;
case 0x04: /* play */
req_buf = SEG_ADR((unsigned char *), es, di);
if (*CALC_PTR(req_buf,MSCD_PLAY_ADRESSING,u_char) == 1) {
cdrom_msf.cdmsf_min0 = *CALC_PTR(req_buf,MSCD_PLAY_STARTSECTOR+2,u_char);
cdrom_msf.cdmsf_sec0 = *CALC_PTR(req_buf,MSCD_PLAY_STARTSECTOR+1,u_char);
cdrom_msf.cdmsf_frame0 = *CALC_PTR(req_buf,MSCD_PLAY_STARTSECTOR+0,u_char);
Sector_plus_150 = cdrom_msf.cdmsf_min0*60*75+cdrom_msf.cdmsf_sec0*75
+cdrom_msf.cdmsf_frame0;
audio_status.last_StartSector = Sector_plus_150;
}
else { Sector_plus_150 = *CALC_PTR(req_buf,MSCD_PLAY_STARTSECTOR,u_long) + 150;
cdrom_msf.cdmsf_min0 = (Sector_plus_150 / (60*75));
cdrom_msf.cdmsf_sec0 = (Sector_plus_150 % (60*75)) / 75;
cdrom_msf.cdmsf_frame0 = (Sector_plus_150 % (60*75)) % 75;
audio_status.last_StartSector = Sector_plus_150;
}
Sector_plus_150 += *CALC_PTR(req_buf,MSCD_PLAY_NUMSECTORS,u_long);
cdrom_msf.cdmsf_min1 = (Sector_plus_150 / (60*75));
cdrom_msf.cdmsf_sec1 = (Sector_plus_150 % (60*75)) / 75;
cdrom_msf.cdmsf_frame1 = (Sector_plus_150 % (60*75)) % 75;
audio_status.last_EndSector = Sector_plus_150;
audio_status.paused_bit = 0;
if (ioctl (cdrom_fd, CDROMPLAYMSF, &cdrom_msf)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMPLAYMSF, &cdrom_msf)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
LO(ax) = 0;
break;
case 0x05: /* pause (stop) audio */
LO(ax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl) == 0) {
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY) {
audio_status.last_StartSector =
cdrom_subchnl.cdsc_absaddr.msf.minute*60*75
+cdrom_subchnl.cdsc_absaddr.msf.second*75
+cdrom_subchnl.cdsc_absaddr.msf.frame;
ioctl (cdrom_fd, CDROMPAUSE, NULL);
audio_status.paused_bit = 1;
}
else { audio_status.last_StartSector = 0;
audio_status.last_EndSector = 0;
audio_status.paused_bit = 0;
}
}
else { audio_status.last_StartSector = 0;
audio_status.last_EndSector = 0;
audio_status.paused_bit = 0;
audio_status.media_changed = 1;
}
break;
case 0x06: /* resume audio */
LO(ax) = 0;
if (audio_status.paused_bit) {
if (ioctl (cdrom_fd, CDROMRESUME, NULL) == 0) {
audio_status.paused_bit = 0;
HI(ax) = 1;
}
}
else LO(ax) = 1;
break;
case 0x07: /* location of head */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
if (*CALC_PTR(req_buf,MSCD_LOCH_ADRESSING,u_char) == 0) {
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION,u_long)
= cdrom_subchnl.cdsc_absaddr.msf.minute*60*75
+cdrom_subchnl.cdsc_absaddr.msf.second*75
+cdrom_subchnl.cdsc_absaddr.msf.frame-150;
}
else {/* red book adressing */
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION+3,u_char) = 0;
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION+2,u_char) = cdrom_subchnl.cdsc_absaddr.msf.minute;
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION+1,u_char) = cdrom_subchnl.cdsc_absaddr.msf.second;
*CALC_PTR(req_buf,MSCD_LOCH_LOCATION+0,u_char) = cdrom_subchnl.cdsc_absaddr.msf.frame;
}
break;
case 0x08: /* return sectorsize */
LO(ax) = 0;
LWORD(ebx) = CD_FRAMESIZE;
break;
case 0x09: /* media changed */
/* this function will be called from MSCDEX before
each new disk access ! */
HI(ax) = 0; LO(ax) = 0; LO(bx) = 0;
C_printf("CDROM: media changed? %#x\n", audio_status.media_changed);
errno = 0;
if (eject_allowed) {
if ((audio_status.media_changed) ||
ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
if (errno == EIO)
cdrom_reset();
audio_status.media_changed = 0;
LO(bx) = 1; /* media has been changed */
C_printf("CDROM: media changed? yes\n");
ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl);
if (! ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl))
cdrom_reset(); /* disc in drive */
}
else /* media has not changed, check audio status */
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1; /* audio playing in progress */
}
break;
case 0x0A: /* device status */
HI(ax) = 0; LO(ax) = 0;
if (eject_allowed) {
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl))
{ /* no disk in drive */
LWORD(ebx) = audio_status.status | 0x800;
C_printf("CDROM: subch failed: %s\n", strerror(errno));
break;
}
else cdrom_reset();
}
}
/* disk in drive */
LWORD(ebx) = audio_status.status;
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
break;
case 0x0B: /* drive reset */
LO(ax) = 0;
break;
case 0x0C: /* lock/unlock door */
cdrom_reset();
if (LO(bx) == 1)
audio_status.status &= 0xFFFFFFFD;
else audio_status.status |= 0x2;
LO(ax) = 0;
break;
case 0x0D: /* eject */
LO(ax) = 0;
if ((eject_allowed) && (audio_status.status & 0x02)) /* drive unlocked ? */
{
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMEJECT)) {
LO(ax) = errno;
}
}
break;
case 0x0E: /* close tray */
LO(ax) = 0;
if ((eject_allowed) && (audio_status.status & 0x02)) /* drive unlocked ? */
{
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMCLOSETRAY)) {
LO(ax) = errno;
}
}
break;
case 0x0F: /* audio channel control */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
cdrom_volctrl.channel0 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME0, u_char);
cdrom_volctrl.channel1 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME1, u_char);
cdrom_volctrl.channel2 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME2, u_char);
cdrom_volctrl.channel3 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME3, u_char);
audio_status.volume0 = cdrom_volctrl.channel0;
audio_status.volume1 = cdrom_volctrl.channel1;
audio_status.volume2 = cdrom_volctrl.channel2;
audio_status.volume3 = cdrom_volctrl.channel3;
audio_status.outchan0 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME0-1, u_char);
audio_status.outchan1 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME1-1, u_char);
audio_status.outchan2 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME2-1, u_char);
audio_status.outchan3 = *CALC_PTR(req_buf, MSCD_CTRL_VOLUME3-1, u_char);
ioctl (cdrom_fd, CDROMVOLCTRL, &cdrom_volctrl);
break;
case 0x10: /* audio disk info */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMREADTOCHDR, &cdrom_tochdr)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMREADTOCHDR, &cdrom_tochdr)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
req_buf = SEG_ADR((unsigned char *), ds, si);
*CALC_PTR(req_buf,MSCD_DISKINFO_LTN,u_char) = cdrom_tochdr.cdth_trk0;
*CALC_PTR(req_buf,MSCD_DISKINFO_HTN,u_char) = cdrom_tochdr.cdth_trk1;
cdrom_tocentry.cdte_track = CDROM_LEADOUT;
cdrom_tocentry.cdte_format = CDROM_MSF;
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
C_printf ("Fatal cdrom error(audio disk info); read toc header succeeded but following read entry didn't\n");
LO(ax) = 1;
break;
}
#ifdef __linux__
*CALC_PTR(req_buf,MSCD_DISKINFO_LEADOUT+3,u_char) = 0;
*CALC_PTR(req_buf,MSCD_DISKINFO_LEADOUT+2,u_char) = cdrom_tocentry.cdte_addr.msf.minute;
*CALC_PTR(req_buf,MSCD_DISKINFO_LEADOUT+1,u_char) = cdrom_tocentry.cdte_addr.msf.second;
*CALC_PTR(req_buf,MSCD_DISKINFO_LEADOUT+0,u_char) = cdrom_tocentry.cdte_addr.msf.frame;
#endif
break;
case 0x11: /* track info */
req_buf = SEG_ADR((unsigned char *), ds, si);
cdrom_tocentry.cdte_track = *CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKNUM,u_char);
cdrom_tocentry.cdte_format = CDROM_MSF;
C_printf("CDROM: track info, track %d\n", cdrom_tocentry.cdte_track);
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
/* XXX MSCDEX reads beyond the end of existing tracks. Sigh. */
if (errno != EINVAL)
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
if (errno == EIO) {
audio_status.media_changed = 1;
/* no disk in drive */
}
LO(ax) = 1;
break;
}
}
#ifdef __linux__
*CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKPOS+3,u_char) = 0;
*CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKPOS+2,u_char) = cdrom_tocentry.cdte_addr.msf.minute;
*CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKPOS+1,u_char) = cdrom_tocentry.cdte_addr.msf.second;
*CALC_PTR(req_buf,MSCD_TRACKINFO_TRACKPOS+0,u_char) = cdrom_tocentry.cdte_addr.msf.frame;
#endif
*CALC_PTR(req_buf,MSCD_TRACKINFO_CTRL,u_char) = cdrom_tocentry.cdte_ctrl << 4 | 0x20;
LO(ax) = 0;
break;
case 0x12: /* volume size */
cdrom_tocentry.cdte_track = CDROM_LEADOUT;
cdrom_tocentry.cdte_format = CDROM_MSF;
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMREADTOCENTRY, &cdrom_tocentry)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
req_buf = SEG_ADR((unsigned char *), ds, si);
#ifdef __linux__
*CALC_PTR(req_buf,MSCD_GETVOLUMESIZE_SIZE,int) = cdrom_tocentry.cdte_addr.msf.minute*60*75
+cdrom_tocentry.cdte_addr.msf.second*60
+cdrom_tocentry.cdte_addr.msf.frame;
#endif
LO(ax) = 0;
break;
case 0x13: /* q channel */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
*CALC_PTR(req_buf,MSCD_QCHAN_CTRL,u_char) = (cdrom_subchnl.cdsc_adr << 4) + (cdrom_subchnl.cdsc_ctrl);
*CALC_PTR(req_buf,MSCD_QCHAN_TNO,u_char) = cdrom_subchnl.cdsc_trk;
*CALC_PTR(req_buf,MSCD_QCHAN_IND,u_char) = cdrom_subchnl.cdsc_ind;
#ifdef __linux__
*CALC_PTR(req_buf,MSCD_QCHAN_MIN,u_char) = cdrom_subchnl.cdsc_reladdr.msf.minute;
*CALC_PTR(req_buf,MSCD_QCHAN_SEC,u_char) = cdrom_subchnl.cdsc_reladdr.msf.second;
*CALC_PTR(req_buf,MSCD_QCHAN_FRM,u_char) = cdrom_subchnl.cdsc_reladdr.msf.frame;
#endif
*CALC_PTR(req_buf,MSCD_QCHAN_ZERO,u_char) = 0;
*CALC_PTR(req_buf,MSCD_QCHAN_AMIN,u_char) = cdrom_subchnl.cdsc_absaddr.msf.minute;
*CALC_PTR(req_buf,MSCD_QCHAN_ASEC,u_char) = cdrom_subchnl.cdsc_absaddr.msf.second;
*CALC_PTR(req_buf,MSCD_QCHAN_AFRM,u_char) = cdrom_subchnl.cdsc_absaddr.msf.frame;
break;
case 0x14: /* audio status */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
*CALC_PTR(req_buf,MSCD_AUDSTAT_PAUSED,u_short)= audio_status.paused_bit;
*CALC_PTR(req_buf,MSCD_AUDSTAT_START ,u_long) = audio_status.last_StartSector;
*CALC_PTR(req_buf,MSCD_AUDSTAT_END ,u_long) = audio_status.last_EndSector;
break;
case 0x15: /* get audio channel information */
LWORD(eax) = 0;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
audio_status.media_changed = 1;
if (ioctl (cdrom_fd, CDROMSUBCHNL, &cdrom_subchnl)) {
/* no disk in drive */
LO(ax) = 1;
break;
}
}
if (cdrom_subchnl.cdsc_audiostatus == CDROM_AUDIO_PLAY)
HI(ax) = 1;
req_buf = SEG_ADR((unsigned char *), ds, si);
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME0,u_char) = audio_status.volume0;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME1,u_char) = audio_status.volume1;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME2,u_char) = audio_status.volume2;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME3,u_char) = audio_status.volume3;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME0-1,u_char) = audio_status.outchan0;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME1-1,u_char) = audio_status.outchan1;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME2-1,u_char) = audio_status.outchan2;
*CALC_PTR(req_buf,MSCD_AUDCHAN_VOLUME3-1,u_char) = audio_status.outchan3;
break;
default: C_printf ("CDROM: unknown request %#x!\n",HI(ax));
}
static void
#line 285 "./cwebdir/ctang-w2c.ch"
out_char P1C(eight_bits,cur_char)
#line 655 "./cwebdir/ctangle.w"
{
char*j,*k;
restart:
switch(cur_char){
case'\n':if(protect&&out_state!=verbatim)C_putc(' ');
if(protect||out_state==verbatim)C_putc('\\');
flush_buffer();if(out_state!=verbatim)out_state= normal;break;
/*52:*/
#line 719 "./cwebdir/ctangle.w"
case identifier:
if(out_state==num_or_id)C_putc(' ');
j= (cur_val+name_dir)->byte_start;
k= (cur_val+name_dir+1)->byte_start;
while(j<k){
if((unsigned char)(*j)<0200)C_putc(*j);
else C_printf("%s",translit[(unsigned char)(*j)-0200]);
j++;
}
out_state= num_or_id;break;
/*:52*/
#line 662 "./cwebdir/ctangle.w"
;
/*53:*/
#line 732 "./cwebdir/ctangle.w"
case section_number:
if(cur_val> 0)C_printf("/*%d:*/",cur_val);
else if(cur_val<0)C_printf("/*:%d*/",-cur_val);
else if(protect){
cur_byte+= 4;
cur_char= '\n';
goto restart;
}else{
sixteen_bits a;
a= 0400**cur_byte++;
a+= *cur_byte++;
C_printf("\n#line %d \"",a);
cur_val= *cur_byte++;
cur_val= 0400*(cur_val-0200)+*cur_byte++;
for(j= (cur_val+name_dir)->byte_start,k= (cur_val+name_dir+1)->byte_start;
j<k;j++){
if(*j=='\\'||*j=='"')C_putc('\\');
C_putc(*j);
}
C_printf("%s","\"\n");
}
break;
/*:53*/
#line 663 "./cwebdir/ctangle.w"
;
/*49:*/
#line 681 "./cwebdir/ctangle.w"
case plus_plus:C_putc('+');C_putc('+');out_state= normal;break;
case minus_minus:C_putc('-');C_putc('-');out_state= normal;break;
case minus_gt:C_putc('-');C_putc('>');out_state= normal;break;
case gt_gt:C_putc('>');C_putc('>');out_state= normal;break;
case eq_eq:C_putc('=');C_putc('=');out_state= normal;break;
case lt_lt:C_putc('<');C_putc('<');out_state= normal;break;
case gt_eq:C_putc('>');C_putc('=');out_state= normal;break;
case lt_eq:C_putc('<');C_putc('=');out_state= normal;break;
case not_eq:C_putc('!');C_putc('=');out_state= normal;break;
case and_and:C_putc('&');C_putc('&');out_state= normal;break;
case or_or:C_putc('|');C_putc('|');out_state= normal;break;
case dot_dot_dot:C_putc('.');C_putc('.');C_putc('.');out_state= normal;
break;
case colon_colon:C_putc(':');C_putc(':');out_state= normal;break;
case period_ast:C_putc('.');C_putc('*');out_state= normal;break;
case minus_gt_ast:C_putc('-');C_putc('>');C_putc('*');out_state= normal;
break;
/*:49*/
#line 664 "./cwebdir/ctangle.w"
;
case'=':case'>':C_putc(cur_char);C_putc(' ');
out_state= normal;break;
case join:out_state= unbreakable;break;
case constant:if(out_state==verbatim){
out_state= num_or_id;break;
}
if(out_state==num_or_id)C_putc(' ');out_state= verbatim;break;
case string:if(out_state==verbatim)out_state= normal;
else out_state= verbatim;break;
case'/':C_putc('/');out_state= post_slash;break;
case'*':if(out_state==post_slash)C_putc(' ');
default:C_putc(cur_char);out_state= normal;break;
}
}
int mscdex(void)
{
unsigned char *buf = MK_FP32(_ES, _BX);
unsigned long dev;
unsigned seg, strat, intr;
int error;
int i;
char devname[] = "MSCD0001";
if (numDrives == 0)
return 0;
switch (_AL) {
case 0x00: /* install check */
_BX = numDrives;
if (_BX > 0) {
int firstdrive = INT_MAX;
for (i = 0; i < 4; i++) {
if (cd_drives[i] != -1
&& cd_drives[i] < firstdrive)
firstdrive = cd_drives[i];
}
_CX = firstdrive;
}
break;
case 0x01: /* driver info */
for (i = 0; i < 4; i++) {
if (cd_drives[i] != -1) {
/* subunit: always 0 for cdrom.sys */
WRITE_BYTE(buf, 0x00);
devname[7] = i + '1';
WRITE_DWORD(buf + 1, is_dos_device(devname));
buf += 5;
}
};
break;
case 0x02: /* copyright file name */
case 0x03: /* abstract file name */
case 0x04: /* documentation file name */
{
char readbuf[CD_FRAMESIZE];
if (ReadVTOC(_CX, 0x00, readbuf) == 0) {
MEMCPY_2DOS(buf, readbuf + 702 + (_AL - 2) * 37,
37);
WRITE_BYTE(buf + 37, 0);
NOCARRY;
} else {
_AX = MSCDEX_ERROR_UNKNOWN_DRIVE;
CARRY;
}
break;
}
case 0x05: /* read vtoc */
NOCARRY;
error = ReadVTOC(_CX, _DX, buf);
if (error) {
_AL = error;
CARRY;
};
break;
case 0x08: /* read sectors */
NOCARRY;
error = ReadSectors(_CX, (_SI << 16) + _DI, _DX, buf);
if (error) {
_AL = error;
CARRY;
};
break;
case 0x09: /* write sectors - not supported */
_AL = MSCDEX_ERROR_DRIVE_NOT_READY;
CARRY;
break;
case 0x0B: /* CD-ROM drive check */
_AX = 0;
for (i = 0; i < 4; i++)
if (_CX == cd_drives[i]) {
_AX = 1;
break;
}
_BX = 0xadad;
break;
case 0x0C:
_BX = (MSCDEX_VERSION_HIGH << 8) + MSCDEX_VERSION_LOW;
break;
case 0x0D: /* get drives */
for (i = 0; i < 4; i++)
if (cd_drives[i] != -1)
WRITE_BYTE(buf++, cd_drives[i]);
break;
case 0x0F: /* Get directory entry */
CARRY;
_AX =
GetDirectoryEntry(_CL, _CH & 1, buf,
SEGOFF2LINEAR(_SI, _DI));
if (_AX == 0 || _AX == 1)
NOCARRY;
break;
case 0x10:
{
int driver = GetDriver(_CX);
if (driver >= 4)
break;
devname[7] = driver + '1';
dev = is_dos_device(devname);
seg = dev >> 16;
dev = SEGOFF2LINEAR(seg, dev & 0xffff);
strat = READ_WORD(dev + 6);
intr = READ_WORD(dev + 8);
fake_call_to(seg, intr);
fake_call_to(seg, strat);
break;
}
default:
C_printf("unknown mscdex\n");
return 0;
}
return 1;
}
static int GetDirectoryEntry(int drive, int copyFlag, char *pathname,
Bit32u buffer)
{
char searchName[256];
int error, dirSize;
unsigned char defBuffer[CD_FRAMESIZE];
unsigned dirEntrySector, entryLength, index;
char *searchPos = searchName;
size_t searchlen;
/* skip initial \ */
MEMCPY_2UNIX(searchName, pathname + 1, 255);
searchName[255] = '\0';
strupperDOS(searchName);
//strip of tailing . (XCOM APOCALIPSE)
searchlen = strlen(searchName);
if (searchlen > 1 && strcmp(searchName, ".."))
if (searchName[searchlen - 1] == '.')
searchName[searchlen - 1] = 0;
C_printf("MSCDEX: Get DirEntry : Find : %s\n", searchName);
// read vtoc
error = ReadSectors(drive, 16, 1, defBuffer);
if (error)
return error;
// TODO: has to be iso 9660
if (memcmp("CD001", defBuffer + 1, 5) != 0)
return MSCDEX_ERROR_BAD_FORMAT;
// get directory position
dirEntrySector = *(unsigned *)(defBuffer + 156 + 2);
dirSize = *(int *)(defBuffer + 156 + 10);
do {
// Get string part
char *useName = searchPos;
size_t useNameLength;
searchPos = strchr(searchPos, '\\');
if (searchPos) {
useNameLength = searchPos - useName;
searchPos++;
} else
useNameLength = strlen(useName);
while (1) {
error =
ReadSectors(drive, dirEntrySector, 1, defBuffer);
if (error)
return error;
index = 0;
do {
char *entryName, *longername;
unsigned nameLength;
entryLength = defBuffer[index];
C_printf("MSCDEX: entryLength=%u, index=%d\n",
entryLength, index);
if (entryLength == 0)
break;
nameLength = defBuffer[index + 32];
entryName = defBuffer + index + 33;
if (namecomp
(entryName, nameLength, useName,
useNameLength))
break;
/* Xcom Apocalipse searches for MUSIC.
* and expects to find MUSIC;1
* All Files on the CDROM are of the kind
* blah;1
*/
longername = memchr(entryName, ';', nameLength);
if (longername &&
namecomp(entryName, longername - entryName,
useName, useNameLength))
break;
index += entryLength;
} while (index + 33 <= CD_FRAMESIZE);
if (index + 33 <= CD_FRAMESIZE)
break;
// continue search in next sector
dirSize -= 2048;
if (dirSize <= 0)
return 2; // file not found
dirEntrySector++;
}
// directory wechseln
dirEntrySector = *(unsigned *)(defBuffer + index + 2);
dirSize = *(unsigned *)(defBuffer + index + 10);
} while (searchPos);
return fill_buffer(copyFlag, buffer, defBuffer + index, entryLength);
};
