/* Called when Domino loads the filter. Reads a load of config data from
* the registry and elsewhere and displays a banner.
*/
DLLEXPORT unsigned int FilterInit(FilterInitData *filterInitData)
{
jk_open_pool(&cfgPool, NULL, 0); /* empty pool for config data */
if (!ReadInitData())
goto initFailed;
if (!jk_open_file_logger(&logger, logFile, logLevel))
logger = NULL;
if (NULL != tomcatStart && '\0' != *tomcatStart)
{
AddInLogMessageText("Attempting to start Tomcat: %s", NOERROR, tomcatStart);
RunProg(tomcatStart);
}
filterInitData->appFilterVersion = kInterfaceVersion;
filterInitData->eventFlags = kFilterParsedRequest;
strcpy(filterInitData->filterDesc, FILTERDESC);
// Banner
AddInLogMessageText("%s loaded", NOERROR, filterInitData->filterDesc);
return kFilterHandledEvent;
initFailed:
AddInLogMessageText("Error loading %s", NOERROR, FILTERDESC);
return kFilterError;
}
/* Called when the filter is unloaded. Free various resources and
* display a banner.
*/
DLLEXPORT unsigned int TerminateFilter(unsigned int reserved)
{
if (initDone)
{
uri_worker_map_free(&uw_map, logger);
wc_close(logger);
if (logger)
jk_close_file_logger(&logger);
initDone = JK_FALSE;
}
if (NULL != tomcatStop && '\0' != *tomcatStop)
{
AddInLogMessageText("Attempting to stop Tomcat: %s", NOERROR, tomcatStop);
RunProg(tomcatStop);
}
AddInLogMessageText(FILTERDESC " unloaded", NOERROR);
jk_close_pool(&cfgPool);
return kFilterHandledEvent;
}
bool CheckOvl( addr32_ptr start )
/*******************************/
{
struct ovl_header __far *hdr;
hdr = MK_FP( start.segment, start.offset );
if( hdr->signature == OVL_SIGNATURE ) {
hdr->hook = &OvlTrap;
OvlRequest = MK_FP( start.segment, hdr->handler_offset );
RunProg( &TaskRegs, &TaskRegs ); /* init overlay manager */
return( true );
}
return( false );
}
static trap_elen ProgRun( bool step )
{
bool watch386;
prog_go_ret *ret;
ret = GetOutPtr( 0 );
if( Flags.DRsOn ) {
SetSingle386();
} else {
SetSingleStep();
}
if( step ) {
TaskRegs.EFL |= FLG_T;
} else {
watch386 = SetDebugRegs();
if( WatchCount != 0 && !watch386 ) {
if( Flags.DRsOn ) {
SetWatch386( WatchCount, WatchPoints );
} else {
SetWatchPnt( WatchCount, WatchPoints );
}
TaskRegs.EFL |= FLG_T;
}
}
out( "in CS:EIP=" ); out( hex( TaskRegs.CS ) ); out(":" ); out( hex( TaskRegs.EIP ) );
out( " SS:ESP=" ); out( hex( TaskRegs.SS ) ); out(":" ); out( hex( TaskRegs.ESP ) );
out( "\r\n" );
ret->conditions = MapReturn( ClearDebugRegs( RunProg( &TaskRegs, &TaskRegs ) ) );
ret->conditions |= COND_CONFIG;
// out( "cond=" ); out( hex( ret->conditions ) );
out( " CS:EIP=" ); out( hex( TaskRegs.CS ) ); out(":" ); out( hex( TaskRegs.EIP ) );
out( " SS:ESP=" ); out( hex( TaskRegs.SS ) ); out(":" ); out( hex( TaskRegs.ESP ) );
out( "\r\n" );
ret->stack_pointer.segment = TaskRegs.SS;
ret->stack_pointer.offset = TaskRegs.ESP;
ret->program_counter.segment = TaskRegs.CS;
ret->program_counter.offset = TaskRegs.EIP;
TaskRegs.EFL &= ~FLG_T;
WatchCount = 0;
return( sizeof( *ret ) );
}
trap_retval ReqProg_load( void )
{
addr_seg psp;
pblock parmblock;
tiny_ret_t rc;
char *parm;
char *name;
char __far *dst;
char exe_name[128];
char ch;
EXE_TYPE exe;
prog_load_ret *ret;
unsigned len;
ExceptNum = -1;
ret = GetOutPtr( 0 );
memset( &TaskRegs, 0, sizeof( TaskRegs ) );
TaskRegs.EFL = MyFlags() & ~USR_FLAGS;
/* build a DOS command line parameter in our PSP command area */
Flags.BoundApp = FALSE;
psp = DbgPSP();
parm = name = GetInPtr( sizeof( prog_load_req ) );
if( TINY_ERROR( FindFilePath( name, exe_name, DosExtList ) ) ) {
exe_name[0] = '\0';
}
while( *parm++ != '\0' ) {} // skip program name
len = GetTotalSize() - ( parm - name ) - sizeof( prog_load_req );
if( len > 126 )
len = 126;
dst = MK_FP( psp, CMD_OFFSET + 1 );
for( ; len > 0; --len ) {
ch = *parm++;
if( ch == '\0' ) {
if( len == 1 )
break;
ch = ' ';
}
*dst++ = ch;
}
*dst = '\r';
*(byte __far *)MK_FP( psp, CMD_OFFSET ) = FP_OFF( dst ) - ( CMD_OFFSET + 1 );
parmblock.envstring = 0;
parmblock.commandln.segment = psp;
parmblock.commandln.offset = CMD_OFFSET;
parmblock.fcb01.segment = psp;
parmblock.fcb02.segment = psp;
parmblock.fcb01.offset = 0x5C;
parmblock.fcb02.offset = 0x6C;
exe = CheckEXEType( exe_name );
if( EXEhandle != 0 ) {
TinyClose( EXEhandle );
EXEhandle = 0;
}
switch( exe ) {
case EXE_RATIONAL_386:
ret->err = ERR_RATIONAL_EXE;
return( sizeof( *ret ) );
case EXE_PHARLAP_SIMPLE:
ret->err = ERR_PHARLAP_EXE;
return( sizeof( *ret ) );
}
SegmentChain = 0;
BoundAppLoading = FALSE;
rc = DOSLoadProg( exe_name, &parmblock );
if( TINY_OK( rc ) ) {
TaskRegs.SS = parmblock.startsssp.segment;
/* for some insane reason DOS returns a starting SP two less then
normal */
TaskRegs.ESP = parmblock.startsssp.offset + 2;
TaskRegs.CS = parmblock.startcsip.segment;
TaskRegs.EIP = parmblock.startcsip.offset;
psp = DOSTaskPSP();
} else {
psp = TinyAllocBlock( TinyAllocBlock( 0xffff ) );
TinyFreeBlock( psp );
TaskRegs.SS = psp + 0x10;
TaskRegs.ESP = 0xfffe;
TaskRegs.CS = psp + 0x10;
TaskRegs.EIP = 0x100;
}
TaskRegs.DS = psp;
TaskRegs.ES = psp;
if( TINY_OK( rc ) ) {
if( Flags.NoOvlMgr || !CheckOvl( parmblock.startcsip ) ) {
if( exe == EXE_OS2 ) {
opcode_type __far *loc_brk_opcode;
BoundAppLoading = TRUE;
RunProg( &TaskRegs, &TaskRegs );
loc_brk_opcode = MK_FP(TaskRegs.CS, TaskRegs.EIP);
if( *loc_brk_opcode == BRKPOINT ) {
*loc_brk_opcode = saved_opcode;
}
BoundAppLoading = FALSE;
rc = TinyOpen( exe_name, TIO_READ_WRITE );
if( TINY_OK( rc ) ) {
EXEhandle = TINY_INFO( rc );
SeekEXEset( StartByte );
WriteEXE( saved_opcode );
TinySetFileStamp( EXEhandle, EXETime, EXEDate );
TinyClose( EXEhandle );
EXEhandle = 0;
Flags.BoundApp = TRUE;
}
}
}
}
ret->err = TINY_ERROR( rc ) ? TINY_INFO( rc ) : 0;
ret->task_id = psp;
ret->flags = 0;
ret->mod_handle = 0;
return( sizeof( *ret ) );
}
