mad_status MADSysLoad( const char *path, mad_client_routines *cli,
mad_imp_routines **imp, mad_sys_handle *sys_hdl )
{
dig_fhandle fid;
imp_header *mad;
mad_init_func *init_func;
mad_status status;
fid = DIGLoader( Open )( path, strlen( path ), "mad", NULL, 0 );
if( fid == DIG_NIL_HANDLE ) {
return( MS_ERR | MS_FOPEN_FAILED );
}
mad = ReadInImp( fid );
DIGLoader( Close )( fid );
status = MS_ERR | MS_INVALID_MAD;
if( mad != NULL ) {
#ifdef __WATCOMC__
if( mad->sig == MADSIG ) {
#endif
init_func = (mad_init_func *)mad->init_rtn;
if( init_func != NULL && (*imp = init_func( &status, cli )) != NULL ) {
*sys_hdl = (mad_sys_handle)mad;
return( MS_OK );
}
#ifdef __WATCOMC__
}
#endif
DIGCli( Free )( (void *)mad );
}
return( status );
}
char *LoadTrap( const char *parms, char *buff, trap_version *trap_ver )
{
FILE *fp;
trap_file_header __far *head;
char filename[256];
char *p;
char chr;
if( parms == NULL || *parms == '\0' )
parms = DEFAULT_TRP_NAME;
p = filename;
for( ; (chr = *parms) != '\0'; parms++ ) {
if( chr == TRAP_PARM_SEPARATOR ) {
parms++;
break;
}
*p++ = chr;
}
#ifdef USE_FILENAME_VERSION
*p++ = ( USE_FILENAME_VERSION / 10 ) + '0';
*p++ = ( USE_FILENAME_VERSION % 10 ) + '0';
#endif
*p = '\0';
fp = DIGLoader( Open )( filename, p - filename, DEFAULT_TRP_EXT, NULL, 0 );
if( fp == NULL ) {
sprintf( buff, "%s '%s'", TC_ERR_CANT_LOAD_TRAP, filename );
return( buff );
}
p = ReadInTrap( fp );
DIGLoader( Close )( fp );
sprintf( buff, "%s '%s'", TC_ERR_CANT_LOAD_TRAP, filename );
if( p == NULL ) {
if( (p = SetTrapHandler()) != NULL || (p = CopyEnv()) != NULL ) {
strcpy( buff, p );
} else {
strcpy( buff, TC_ERR_WRONG_TRAP_VERSION );
head = EXTENDER_RM2PM( TrapMem.rm, 0 );
if( head->sig == TRAP_SIGNATURE ) {
PMData->initfunc.s.offset = head->init;
PMData->reqfunc.s.offset = head->req;
PMData->finifunc.s.offset = head->fini;
PMData->initfunc.s.segment = TrapMem.rm;
PMData->reqfunc.s.segment = TrapMem.rm;
PMData->finifunc.s.segment = TrapMem.rm;
if( CallTrapInit( parms, buff, trap_ver ) ) {
if( TrapVersionOK( *trap_ver ) ) {
TrapVer = *trap_ver;
ReqFunc = DoTrapAccess;
return( NULL );
}
strcpy( buff, TC_ERR_WRONG_TRAP_VERSION );
}
}
}
}
KillTrap();
return( buff );
}
static char *ReadInTrap( dig_ldhandle ldfh )
{
dos_exe_header hdr;
memptr relocbuff[NUM_BUFF_RELOCS];
unsigned relocnb;
unsigned imagesize;
unsigned hdrsize;
rm_call_struct rm_dos_read;
unsigned offset;
if( DIGLoader( Read )( ldfh, &hdr, sizeof( hdr ) ) ) {
return( TC_ERR_CANT_LOAD_TRAP );
}
if( hdr.signature != DOS_SIGNATURE ) {
return( TC_ERR_BAD_TRAP_FILE );
}
hdrsize = hdr.hdr_size * 16;
imagesize = ( hdr.file_size * 0x200 ) - (-hdr.mod_size & 0x1ff) - hdrsize;
TrapMem.dpmi_adr = DPMIAllocateDOSMemoryBlock( _NBPARAS( imagesize ) + hdr.min_16 );
if( TrapMem.segm.pm == 0 ) {
return( TC_ERR_OUT_OF_DOS_MEMORY );
}
DIGLoader( Seek )( ldfh, hdrsize, DIG_ORG );
// DPMI file read to real mode memory
memset( &rm_dos_read, 0, sizeof( rm_dos_read ) );
for( offset = 0; offset < imagesize; offset += (unsigned_16)rm_dos_read.eax ) {
rm_dos_read.ss = RMData.segm.rm;
rm_dos_read.sp = offsetof( rm_data, stack ) + STACK_SIZE;
rm_dos_read.edx = offset;
rm_dos_read.ebx = ldfh;
rm_dos_read.ds = TrapMem.segm.rm;
rm_dos_read.ecx = imagesize - offset;
rm_dos_read.eax = 0x3f00;
relocnb = DPMISimulateRealModeInterrupt( 0x21, 0, 0, &rm_dos_read );
if( (rm_dos_read.flags & 1) || (unsigned_16)rm_dos_read.eax == 0 ) {
return( TC_ERR_CANT_LOAD_TRAP );
}
}
DIGLoader( Seek )( ldfh, hdr.reloc_offset, DIG_ORG );
for( relocnb = NUM_BUFF_RELOCS; hdr.num_relocs > 0; --hdr.num_relocs, ++relocnb ) {
if( relocnb >= NUM_BUFF_RELOCS ) {
if( DIGLoader( Read )( ldfh, relocbuff, sizeof( memptr ) * NUM_BUFF_RELOCS ) ) {
return( TC_ERR_CANT_LOAD_TRAP );
}
relocnb = 0;
}
*(addr_seg __far *)MK_PM( TrapMem.segm.rm + relocbuff[relocnb].s.segment, relocbuff[relocnb].s.offset ) += TrapMem.segm.rm;
}
return( NULL );
}
int PILLSysLoad( const char *path, const pill_client_routines *cli,
link_handle *lh, link_message *msg )
{
FILE *fp;
supp_header *pill;
pill_init_func *init_func;
msg->source = NULL;
msg->id = LM_SYSTEM_ERROR;
fp = DIGLoader( Open )( path, strlen( path ), "pil", NULL, 0 );
if( fp == NULL ) {
msg->data.code = errno;
return( 0 );
}
SuppSegs = NULL;
pill = ReadSupp( fp );
DIGLoader( Close )( fp );
lh->sys = SuppSegs;
#ifdef __WATCOMC__
if( pill == NULL || pill->sig != PILLSIG ) {
#else
if( pill == NULL ) {
#endif
msg->data.code = EINVAL;
PILLSysUnload( lh->sys );
return( 0 );
}
init_func = (pill_init_func *)pill->init_rtn;
lh->rtns = init_func( cli, msg );
if( lh->rtns == NULL ) {
/* don't free DLL yet, we need the message processor */
msg->source = lh;
return( 0 );
}
return( 1 );
}
void PILLSysUnload( link_handle *lh )
{
UnloadSupp( lh->sys );
}
static char *ReadInTrap( FILE *fp )
{
dos_exe_header hdr;
memptr relocbuff[NUM_BUFF_RELOCS];
unsigned relocnb;
unsigned imagesize;
unsigned hdrsize;
if( DIGLoader( Read )( fp, &hdr, sizeof( hdr ) ) ) {
return( TC_ERR_CANT_LOAD_TRAP );
}
if( hdr.signature != DOS_SIGNATURE ) {
return( TC_ERR_BAD_TRAP_FILE );
}
hdrsize = hdr.hdr_size * 16;
imagesize = ( hdr.file_size * 0x200 ) - (-hdr.mod_size & 0x1ff) - hdrsize;
TrapMem = DPMIAllocateDOSMemoryBlock( _NBPARAS( imagesize ) + hdr.min_16 );
if( TrapMem.pm == 0 ) {
return( TC_ERR_OUT_OF_DOS_MEMORY );
}
DIGLoader( Seek )( fp, hdrsize, DIG_ORG );
if( DIGLoader( Read )( fp, (void *)DPMIGetSegmentBaseAddress( TrapMem.pm ), imagesize ) != imagesize ) {
return( TC_ERR_CANT_LOAD_TRAP );
}
DIGLoader( Seek )( fp, hdr.reloc_offset, DIG_ORG );
for( relocnb = NUM_BUFF_RELOCS; hdr.num_relocs > 0; --hdr.num_relocs, ++relocnb ) {
if( relocnb >= NUM_BUFF_RELOCS ) {
if( DIGLoader( Read )( fp, relocbuff, sizeof( memptr ) * NUM_BUFF_RELOCS ) ) {
return( TC_ERR_CANT_LOAD_TRAP );
}
relocnb = 0;
}
*(addr_seg __far *)EXTENDER_RM2PM( TrapMem.rm + relocbuff[relocnb].s.segment, relocbuff[relocnb].s.offset ) += TrapMem.rm;
}
return( NULL );
}
char *LoadTrap( const char *parms, char *buff, trap_version *trap_ver )
{
char *err;
const char *ptr;
dig_ldhandle ldfh;
trap_file_header __far *head;
#ifdef USE_FILENAME_VERSION
char filename[256];
char *p;
#endif
if( parms == NULL || *parms == '\0' ) {
parms = DEFAULT_TRP_NAME;
}
#ifdef USE_FILENAME_VERSION
for( ptr = parms, p = filename; *ptr != '\0' && *ptr != TRAP_PARM_SEPARATOR; ++ptr ) {
*p++ = *ptr;
}
*p++ = ( USE_FILENAME_VERSION / 10 ) + '0';
*p++ = ( USE_FILENAME_VERSION % 10 ) + '0';
*p = '\0';
ldfh = DIGLoader( Open )( filename, p - filename, DEFAULT_TRP_EXT, NULL, 0 );
#else
for( ptr = parms; *ptr != '\0' && *ptr != TRAP_PARM_SEPARATOR; ++ptr ) {
;
}
ldfh = DIGLoader( Open )( parms, ptr - parms, DEFAULT_TRP_EXT, NULL, 0 );
#endif
if( ldfh == DIGLD_NIL_HANDLE ) {
sprintf( buff, TC_ERR_CANT_LOAD_TRAP, parms );
return( buff );
}
err = ReadInTrap( ldfh );
DIGLoader( Close )( ldfh );
sprintf( buff, TC_ERR_CANT_LOAD_TRAP, parms );
if( err == NULL ) {
if( (err = SetTrapHandler()) != NULL || (err = CopyEnv()) != NULL ) {
strcpy( buff, err );
} else {
strcpy( buff, TC_ERR_WRONG_TRAP_VERSION );
head = MK_PM( TrapMem.segm.rm, 0 );
if( head->sig == TRAP_SIGNATURE ) {
PMData->initfunc.s.offset = head->init;
PMData->reqfunc.s.offset = head->req;
PMData->finifunc.s.offset = head->fini;
PMData->initfunc.s.segment = TrapMem.segm.rm;
PMData->reqfunc.s.segment = TrapMem.segm.rm;
PMData->finifunc.s.segment = TrapMem.segm.rm;
parms = ptr;
if( *parms != '\0' )
++parms;
if( CallTrapInit( parms, buff, trap_ver ) ) {
if( TrapVersionOK( *trap_ver ) ) {
TrapVer = *trap_ver;
ReqFunc = DoTrapAccess;
return( NULL );
}
strcpy( buff, TC_ERR_WRONG_TRAP_VERSION );
}
}
}
}
KillTrap();
return( buff );
}
