/****************************************************************************
* UTRegister (KERNEL32.@)
*/
BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL,
LPSTR lpszInitName, LPSTR lpszProcName,
FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack,
LPVOID lpBuff )
{
UTINFO *ut;
HMODULE16 hModule16;
FARPROC16 target16, init16;
/* Load 16-bit DLL and get UTProc16 entry point */
if ( (hModule16 = LoadLibrary16( lpsz16BITDLL )) <= 32
|| (target16 = GetProcAddress16( hModule16, lpszProcName )) == 0 )
return FALSE;
/* Allocate UTINFO struct */
RtlAcquirePebLock();
if ( (ut = UTFind( hModule )) != NULL )
ut = NULL;
else
ut = UTAlloc( hModule, hModule16, target16, pfnUT32CallBack );
RtlReleasePebLock();
if ( !ut )
{
FreeLibrary16( hModule16 );
return FALSE;
}
/* Call UTInit16 if present */
if ( lpszInitName
&& (init16 = GetProcAddress16( hModule16, lpszInitName )) != 0 )
{
SEGPTR callback = MapLS( &ut->ut16 );
SEGPTR segBuff = MapLS( lpBuff );
WORD args[4];
DWORD ret;
args[3] = SELECTOROF(callback);
args[2] = OFFSETOF(callback);
args[1] = SELECTOROF(segBuff);
args[0] = OFFSETOF(segBuff);
WOWCallback16Ex( (DWORD)init16, WCB16_PASCAL, sizeof(args), args, &ret );
UnMapLS( segBuff );
UnMapLS( callback );
if (!ret)
{
UTUnRegister( hModule );
return FALSE;
}
}
/* Return 32-bit thunk */
*ppfn32Thunk = (FARPROC) &ut->ut32;
return TRUE;
}
unsigned short hwmon_os2_ioctl(PRP_GENIOCTL p)
{
USHORT rc, v;
PVOID pparm, pdata;
USHORT parm_len, data_len;
pparm=p->ParmPacket;
pdata=p->DataPacket;
parm_len=p->ParmLen;
data_len=p->DataLen;
/* Verify the access to parameter/result data areas */
#ifndef USERMODE
if(p->Function&0x20||p->Function==QPC_CMD_RESET)
{
if(DevHelp_VerifyAccess(SELECTOROF(pdata), data_len, OFFSETOF(pdata),
VERIFY_READWRITE))
return(RC_BUG);
}
if(((p->Function&0x20)==0||p->Function==QPC_CMD_QUERY_HWMON_PARAMS)&&
p->Function!=QPC_CMD_RESET)
{
if(DevHelp_VerifyAccess(SELECTOROF(pparm), parm_len, OFFSETOF(pparm),
VERIFY_READONLY))
return(RC_BUG);
}
#endif
return(hwmon_ioctl(p->Function, pparm, parm_len, pdata, data_len)?RC_BUG:STATUS_DONE);
}
/***********************************************************************
* MZ_Exit
*/
void WINAPI MZ_Exit( CONTEXT86 *context, BOOL cs_psp, WORD retval )
{
if (DOSVM_psp) {
WORD psp_seg = cs_psp ? context->SegCs : DOSVM_psp;
LPBYTE psp_start = (LPBYTE)((DWORD)psp_seg << 4);
PDB16 *psp = (PDB16 *)psp_start;
WORD parpsp = psp->parentPSP; /* check for parent DOS process */
if (parpsp) {
/* retrieve parent's return address */
FARPROC16 retaddr = DOSVM_GetRMHandler(0x22);
/* restore interrupts */
DOSVM_SetRMHandler(0x22, psp->savedint22);
DOSVM_SetRMHandler(0x23, psp->savedint23);
DOSVM_SetRMHandler(0x24, psp->savedint24);
/* FIXME: deallocate file handles etc */
/* free process's associated memory
* FIXME: walk memory and deallocate all blocks owned by process */
DOSMEM_FreeBlock( PTR_REAL_TO_LIN(psp->environment,0) );
DOSMEM_FreeBlock( PTR_REAL_TO_LIN(DOSVM_psp,0) );
/* switch to parent's PSP */
DOSVM_psp = parpsp;
psp_start = (LPBYTE)((DWORD)parpsp << 4);
psp = (PDB16 *)psp_start;
/* now return to parent */
DOSVM_retval = retval;
context->SegCs = SELECTOROF(retaddr);
context->Eip = OFFSETOF(retaddr);
context->SegSs = SELECTOROF(psp->saveStack);
context->Esp = OFFSETOF(psp->saveStack);
return;
} else
TRACE("killing DOS task\n");
}
ExitThread( retval );
}
static void dump_ne_header( const IMAGE_OS2_HEADER *ne )
{
printf( "File header:\n" );
printf( "Linker version: %d.%d\n", ne->ne_ver, ne->ne_rev );
printf( "Entry table: %x len %d\n", ne->ne_enttab, ne->ne_cbenttab );
printf( "Checksum: %08x\n", ne->ne_crc );
printf( "Flags: %04x\n", ne->ne_flags );
printf( "Auto data segment: %x\n", ne->ne_autodata );
printf( "Heap size: %d bytes\n", ne->ne_heap );
printf( "Stack size: %d bytes\n", ne->ne_stack );
printf( "Stack pointer: %x:%04x\n", SELECTOROF(ne->ne_sssp), OFFSETOF(ne->ne_sssp) );
printf( "Entry point: %x:%04x\n", SELECTOROF(ne->ne_csip), OFFSETOF(ne->ne_csip) );
printf( "Number of segments: %d\n", ne->ne_cseg );
printf( "Number of modrefs: %d\n", ne->ne_cmod );
printf( "Segment table: %x\n", ne->ne_segtab );
printf( "Resource table: %x\n", ne->ne_rsrctab );
printf( "Resident name table: %x\n", ne->ne_restab );
printf( "Module table: %x\n", ne->ne_modtab );
printf( "Import table: %x\n", ne->ne_imptab );
printf( "Non-resident table: %x\n", ne->ne_nrestab );
printf( "Exe type: %x\n", ne->ne_exetyp );
printf( "Other flags: %x\n", ne->ne_flagsothers );
printf( "Fast load area: %x-%x\n", ne->ne_pretthunks << ne->ne_align,
(ne->ne_pretthunks+ne->ne_psegrefbytes) << ne->ne_align );
printf( "Expected version: %d.%d\n", HIBYTE(ne->ne_expver), LOBYTE(ne->ne_expver) );
}
int PASCAL WinMain( HANDLE hInstance, HANDLE hPrevInstance,
LPSTR lpszCmdLine, int nCmdShow )
{
TIMERINFO ti;
DWORD beforeTickCountFast, afterTickCountFast;
DWORD beforeTickCountSlow, afterTickCountSlow, i;
BYTE __huge *hpvSrc;
BYTE __huge *hpvDest;
char szBuffer[256];
hpvSrc = GlobalAllocPtr( GMEM_MOVEABLE, BLOCK_SIZE );
hpvDest = GlobalAllocPtr( GMEM_MOVEABLE, BLOCK_SIZE );
if ( !hpvSrc || !hpvDest )
{
MessageBox(0, "Couldn't allocate src/dest segs", 0, MB_OK);
return 0;
}
// Call the 32 bit function once without timing it to let it switch
// to a 32 bit segment.
memcpy32( SELECTOROF(hpvDest), OFFSETOF(hpvDest),
SELECTOROF(hpvSrc), OFFSETOF(hpvSrc),
BLOCK_SIZE );
ti.dwSize = sizeof(ti);
TimerCount(&ti);
beforeTickCountFast = ti.dwmsThisVM;
// Now call the 32 bit function again, this time timing it.
memcpy32( SELECTOROF(hpvDest), OFFSETOF(hpvDest),
SELECTOROF(hpvSrc), OFFSETOF(hpvSrc),
BLOCK_SIZE );
TimerCount( &ti );
afterTickCountFast = ti.dwmsThisVM;
TimerCount(&ti);
beforeTickCountSlow = ti.dwmsThisVM;
for ( i=0; i < BLOCK_SIZE; i++)
*hpvDest++ = *hpvSrc++;
TimerCount( &ti );
afterTickCountSlow = ti.dwmsThisVM;
wsprintf(szBuffer,
"32 bit move: %lu milliseconds\r\n"
"huge pointer move: %lu milliseconds",
afterTickCountFast - beforeTickCountFast,
afterTickCountSlow - beforeTickCountSlow);
MessageBox( 0, szBuffer, "MIX1632 - Matt Pietrek 1994", MB_OK );
return 0;
}
/* Called when the daemon is initializing. Lock exchange buffers.
This had better not fail, because we do not recover gracefully from
errors. */
static APIRET daemonStarted(PSETXCHGBUFFERS pxchg)
{
APIRET rc;
PAGELIST pagelist[17];
ULONG cPages;
/* Lock the request buffer. */
rc = DevHelp_VMLock(
VMDHL_WRITE | VMDHL_LONG,
pxchg->linRequest,
sizeof(FSREQUEST),
virtToLin(pagelist),
virtToLin(&ahvmlock[0]),
&cPages);
if (rc) return ERROR_STUBFSD_INIT_FAILED;
/* Map the request buffer to a 16:16 address. */
rc = DevHelp_LinToGDTSelector(
SELECTOROF(pRequest),
pxchg->linRequest,
sizeof(FSREQUEST));
if (rc) return ERROR_STUBFSD_INIT_FAILED;
/* Lock the data buffer. */
rc = DevHelp_VMLock(
VMDHL_WRITE | VMDHL_LONG,
pxchg->linData,
sizeof(FSDATA),
virtToLin(pagelist),
virtToLin(&ahvmlock[1]),
&cPages);
if (rc) return ERROR_STUBFSD_INIT_FAILED;
/* Map the data buffer to a 16:16 address. */
rc = DevHelp_LinToGDTSelector(
SELECTOROF(pFSData),
pxchg->linData,
sizeof(FSDATA));
if (rc) return ERROR_STUBFSD_INIT_FAILED;
pidDaemon = queryCurrentPid();
/* Set up the semaphores. */
rc = FSH_SEMSET(&semRqAvail);
if (rc) return rc;
rc = FSH_SEMCLEAR(&semSerialize);
if (rc) return rc;
}
/***********************************************************************
* TaskNext (TOOLHELP.64)
*/
BOOL16 WINAPI TaskNext16( TASKENTRY *lpte )
{
TDB *pTask;
INSTANCEDATA *pInstData;
TRACE_(toolhelp)("(%p): task=%04x\n", lpte, lpte->hNext );
if (!lpte->hNext) return FALSE;
/* make sure that task and hInstance are valid (skip initial Wine task !) */
while (1) {
pTask = TASK_GetPtr( lpte->hNext );
if (!pTask || pTask->magic != TDB_MAGIC) return FALSE;
if (pTask->hInstance)
break;
lpte->hNext = pTask->hNext;
}
pInstData = MapSL( MAKESEGPTR( GlobalHandleToSel16(pTask->hInstance), 0 ) );
lpte->hTask = lpte->hNext;
lpte->hTaskParent = pTask->hParent;
lpte->hInst = pTask->hInstance;
lpte->hModule = pTask->hModule;
lpte->wSS = SELECTOROF( pTask->teb->WOW32Reserved );
lpte->wSP = OFFSETOF( pTask->teb->WOW32Reserved );
lpte->wStackTop = pInstData->stacktop;
lpte->wStackMinimum = pInstData->stackmin;
lpte->wStackBottom = pInstData->stackbottom;
lpte->wcEvents = pTask->nEvents;
lpte->hQueue = pTask->hQueue;
lstrcpynA( lpte->szModule, pTask->module_name, sizeof(lpte->szModule) );
lpte->wPSPOffset = 0x100; /*??*/
lpte->hNext = pTask->hNext;
return TRUE;
}
static void alarm_init(void)
{
PFNSIGHANDLER pfnPrev;
USHORT pfAction;
PIDINFO pid;
bAlarmInit = TRUE;
if (!DosAllocSeg( ALARM_STACK, (PSEL) &selAlarmStack, SEG_NONSHARED ))
{
OFFSETOF(pbAlarmStack) = ALARM_STACK - 2;
SELECTOROF(pbAlarmStack) = selAlarmStack;
/* Create the thread */
if (DosCreateThread( alarm_thread, &tidAlarm, pbAlarmStack ))
{
fprintf(stderr,"Alarm thread failed to start.\n");
exit(1);
}
/* Setup the signal handler for Process Flag A */
if (DosSetSigHandler(AlarmSignal,&pfnPrev,&pfAction,SIGA_ACCEPT,SIG_PFLG_A))
{
fprintf(stderr,"SigHandler Failed to install.\n");
exit(1);
}
/* Save main process ID, we'll need it for triggering the signal */
DosGetPID(&pid);
pidMain = pid.pid;
}
else
exit(1);
}
//--------------------------------- StrmSetup ----------------------------------
ULONG StrmSetup(DDCMDSETUP* packet)
{
ULONG rc=-1;
struct stream_instance* psi=Strm_Find_SI(0,packet->hStream);
if(psi)
{
struct open_instance* poi=Strm_Find_OI(psi->ulSysFileNum);
if(poi)
{
SETUP_PARM* psu;
DevVirtToLin(SELECTOROF(packet->pSetupParm)
,OFFSETOF(packet->pSetupParm)
,(LINEAR*)&psu);
cur_streams[psi->devNo-1]=psi; // Make this the current stream instance
psi->ulSHTime=psu->ulStreamTime;
psi->ulTime=psu->ulStreamTime;
{
ULONG ms=getMS();
psi->ulSTime_Base=ms;
psi->ulTime_Delta=ms;
}
psu->ulFlags=1;
rc=0;
}
}
return rc;
}
/***********************************************************************
* NE_CreateSegment
*/
BOOL NE_CreateSegment( NE_MODULE *pModule, int segnum )
{
SEGTABLEENTRY *pSeg = NE_SEG_TABLE( pModule ) + segnum - 1;
int minsize;
unsigned char selflags;
assert( !(pModule->ne_flags & NE_FFLAGS_WIN32) );
if ( segnum < 1 || segnum > pModule->ne_cseg )
return FALSE;
if ( (pModule->ne_flags & NE_FFLAGS_SELFLOAD) && segnum != 1 )
return TRUE; /* selfloader allocates segment itself */
if ( (pSeg->flags & NE_SEGFLAGS_ALLOCATED) && segnum != pModule->ne_autodata )
return TRUE; /* all but DGROUP only allocated once */
minsize = pSeg->minsize ? pSeg->minsize : 0x10000;
if ( segnum == SELECTOROF(pModule->ne_sssp) ) minsize += pModule->ne_stack;
if ( segnum == pModule->ne_autodata ) minsize += pModule->ne_heap;
selflags = (pSeg->flags & NE_SEGFLAGS_DATA) ? WINE_LDT_FLAGS_DATA : WINE_LDT_FLAGS_CODE;
if (pSeg->flags & NE_SEGFLAGS_32BIT) selflags |= WINE_LDT_FLAGS_32BIT;
pSeg->hSeg = GLOBAL_Alloc( NE_Ne2MemFlags(pSeg->flags), minsize, pModule->self, selflags );
if (!pSeg->hSeg) return FALSE;
pSeg->flags |= NE_SEGFLAGS_ALLOCATED;
return TRUE;
}
BOOL setWindowData(HWND hwnd, LPCSTR lpcID, LPVOID lpData)
{
#ifdef WIN32// (sizeof(HANDLE) == 4)
return(SetProp(hwnd, lpcID, (HANDLE)lpData));
#else
char szID1[32];
BOOL bOK;
wsprintf(szID1, "%s.1", lpcID);
bOK=SetProp(hwnd, szID1, (HANDLE)(SELECTOROF(lpData)));
if (bOK) {
char szID2[32];
wsprintf(szID2, "%s.2", lpcID);
bOK=SetProp(hwnd, szID2, (HANDLE)(OFFSETOF(lpData)));
if (!bOK)
RemoveProp(hwnd, szID1);
}
return(bOK);
#endif
}
/*************************************************************************
* VerQueryValue [VER.11]
*/
DWORD WINAPI VerQueryValue16( SEGPTR spvBlock, LPCSTR lpszSubBlock,
SEGPTR *lpspBuffer, UINT16 *lpcb )
{
LPVOID lpvBlock = MapSL( spvBlock );
LPVOID buffer = lpvBlock;
UINT buflen;
DWORD retv;
TRACE("(%p, %s, %p, %p)\n",
lpvBlock, debugstr_a(lpszSubBlock), lpspBuffer, lpcb );
retv = VerQueryValueA( lpvBlock, lpszSubBlock, &buffer, &buflen );
if ( !retv ) return FALSE;
if ( OFFSETOF( spvBlock ) + ((char *) buffer - (char *) lpvBlock) >= 0x10000 )
{
FIXME("offset %08X too large relative to %04X:%04X\n",
(char *) buffer - (char *) lpvBlock, SELECTOROF( spvBlock ), OFFSETOF( spvBlock ) );
return FALSE;
}
if (lpcb) *lpcb = buflen;
*lpspBuffer = (SEGPTR) ((char *) spvBlock + ((char *) buffer - (char *) lpvBlock));
return retv;
}
USHORT NEAR NotifyFLT (NPU npU, UCHAR CardEvent)
{
NPIORB_CHANGE_UNITSTATUS npTI = (NPIORB_CHANGE_UNITSTATUS)&InitIORB;
NPA npA = npU->npA;
PUNITINFO pUI;
pUI = npU->pUnitInfoF;
if (SELECTOROF(pUI) == NULL) return (1);
clrmem (npTI, sizeof(*npTI));
npTI->iorbh.Length = sizeof(IORB_CHANGE_UNITSTATUS);
npTI->iorbh.UnitHandle = (USHORT)(pUI->UnitHandle);
npTI->iorbh.CommandCode = IOCC_UNIT_CONTROL;
npTI->iorbh.CommandModifier = IOCM_CHANGE_UNITSTATUS;
npTI->iorbh.RequestControl = IORB_ASYNC_POST | IORB_DISABLE_RETRY;
npTI->UnitStatus = (npU->Flags & UCBF_NOTPRESENT ? 0 : US_PRESENT)
| (npU->Flags & UCBF_BM_DMA ? US_BM_READ | US_BM_WRITE : 0)
| (CardEvent ? US_PORT_UPDATE : 0);
npTI->pIdentifyData = (NPIDENTIFYDATA)ScratchBuf + npU->UnitIndex;
npTI->BasePort = DATAREG;
npTI->StatusPort = DEVCTLREG;
npTI->IRQLevel = npA->IRQLevel;
return (Execute ((UCHAR)pUI->FilterADDHandle, (NPIORB)npTI));
}
/***********************************************************************
* NE_InitDLL
*
* Call the DLL initialization code
*/
static BOOL NE_InitDLL( NE_MODULE *pModule )
{
SEGTABLEENTRY *pSegTable;
WORD hInst, ds, heap;
CONTEXT context;
pSegTable = NE_SEG_TABLE( pModule );
if (!(pModule->ne_flags & NE_FFLAGS_LIBMODULE) ||
(pModule->ne_flags & NE_FFLAGS_WIN32)) return TRUE; /*not a library*/
/* Call USER signal handler for Win3.1 compatibility. */
NE_CallUserSignalProc( pModule->self, USIG16_DLL_LOAD );
if (!SELECTOROF(pModule->ne_csip)) return TRUE; /* no initialization code */
/* Registers at initialization must be:
* cx heap size
* di library instance
* ds data segment if any
* es:si command line (always 0)
*/
memset( &context, 0, sizeof(context) );
NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
context.Ecx = heap;
context.Edi = hInst;
context.SegDs = ds;
context.SegEs = ds; /* who knows ... */
context.SegFs = wine_get_fs();
context.SegGs = wine_get_gs();
context.SegCs = SEL(pSegTable[SELECTOROF(pModule->ne_csip)-1].hSeg);
context.Eip = OFFSETOF(pModule->ne_csip);
context.Ebp = OFFSETOF(getWOW32Reserved()) + FIELD_OFFSET(STACK16FRAME,bp);
pModule->ne_csip = 0; /* Don't initialize it twice */
TRACE_(dll)("Calling LibMain for %.*s, cs:ip=%04x:%04x ds=%04x di=%04x cx=%04x\n",
*((BYTE*)pModule + pModule->ne_restab),
(char *)pModule + pModule->ne_restab + 1,
context.SegCs, context.Eip, context.SegDs,
LOWORD(context.Edi), LOWORD(context.Ecx) );
WOWCallback16Ex( 0, WCB16_REGS, 0, NULL, (DWORD *)&context );
return TRUE;
}
static void DOSDEV_DoReq(void*req, DWORD dev)
{
REQUEST_HEADER *hdr = (REQUEST_HEADER *)req;
DOS_DEVICE_HEADER *dhdr;
CONTEXT86 ctx;
char *phdr;
dhdr = PTR_REAL_TO_LIN(SELECTOROF(dev),OFFSETOF(dev));
phdr = ((char*)DOSMEM_LOL()) + DOS_DATASEG_OFF(req);
/* copy request to request scratch area */
memcpy(phdr, req, hdr->size);
/* prepare to call device driver */
memset(&ctx, 0, sizeof(ctx));
ctx.EFlags |= V86_FLAG;
/* ES:BX points to request for strategy routine */
ctx.SegEs = HIWORD(DOS_LOLSeg);
ctx.Ebx = DOS_DATASEG_OFF(req);
/* call strategy routine */
ctx.SegCs = SELECTOROF(dev);
ctx.Eip = dhdr->strategy;
DPMI_CallRMProc(&ctx, 0, 0, 0);
/* call interrupt routine */
ctx.SegCs = SELECTOROF(dev);
ctx.Eip = dhdr->interrupt;
DPMI_CallRMProc(&ctx, 0, 0, 0);
/* completed, copy request back */
memcpy(req, phdr, hdr->size);
if (hdr->status & STAT_ERROR) {
switch (hdr->status & STAT_MASK) {
case 0x0F: /* invalid disk change */
/* this error seems to fit the bill */
SetLastError(ERROR_NOT_SAME_DEVICE);
break;
default:
SetLastError((hdr->status & STAT_MASK) + 0x13);
break;
}
}
}
/*************************************************************
* call16_handler
*
* Handler for exceptions occurring in 16-bit code.
*/
static DWORD call16_handler( EXCEPTION_RECORD *record, EXCEPTION_REGISTRATION_RECORD *frame,
CONTEXT *context, EXCEPTION_REGISTRATION_RECORD **pdispatcher )
{
if (record->ExceptionFlags & (EH_UNWINDING | EH_EXIT_UNWIND))
{
/* unwinding: restore the stack pointer in the TEB, and leave the Win16 mutex */
STACK32FRAME *frame32 = (STACK32FRAME *)((char *)frame - offsetof(STACK32FRAME,frame));
NtCurrentTeb()->WOW32Reserved = (void *)frame32->frame16;
_LeaveWin16Lock();
}
else if (record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION ||
record->ExceptionCode == EXCEPTION_PRIV_INSTRUCTION)
{
if (wine_ldt_is_system(context->SegCs))
{
if (fix_selector( context )) return ExceptionContinueExecution;
}
else
{
SEGPTR gpHandler;
DWORD ret = INSTR_EmulateInstruction( record, context );
/*
* Insert check for pending DPMI events. Note that this
* check must be inserted after instructions have been
* emulated because the instruction emulation requires
* original CS:IP and the emulation may change TEB.dpmi_vif.
*/
if(NtCurrentTeb()->dpmi_vif)
insert_event_check( context );
if (ret != ExceptionContinueSearch) return ret;
/* check for Win16 __GP handler */
if ((gpHandler = HasGPHandler16( MAKESEGPTR( context->SegCs, context->Eip ) )))
{
WORD *stack = wine_ldt_get_ptr( context->SegSs, context->Esp );
*--stack = context->SegCs;
*--stack = context->Eip;
if (!IS_SELECTOR_32BIT(context->SegSs))
context->Esp = MAKELONG( LOWORD(context->Esp - 2*sizeof(WORD)),
HIWORD(context->Esp) );
else
context->Esp -= 2*sizeof(WORD);
context->SegCs = SELECTOROF( gpHandler );
context->Eip = OFFSETOF( gpHandler );
return ExceptionContinueExecution;
}
}
}
else if (record->ExceptionCode == EXCEPTION_VM86_STI)
{
insert_event_check( context );
}
return ExceptionContinueSearch;
}
/***********************************************************************
* _hread (KERNEL.349)
*/
LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
{
LONG maxlen;
TRACE("%d %08x %d\n", hFile, (DWORD)buffer, count );
/* Some programs pass a count larger than the allocated buffer */
maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
if (count > maxlen) count = maxlen;
return _lread((HFILE)DosFileHandleToWin32Handle(hFile), MapSL(buffer), count );
}
/* Map a virtual (16:16) pointer to a linear (0:32) pointer. */
LIN virtToLin(void far * p)
{
int rc;
LIN lin;
rc = DevHelp_VirtToLin(
SELECTOROF(p),
OFFSETOF(p),
&lin);
if (rc) PANIC("virtToLin failed!");
return lin;
}
/****************************************************************************
* UTGlue32
*/
static DWORD WINAPI UTGlue32( FARPROC16 target, LPVOID lpBuff, DWORD dwUserDefined,
LPVOID translationList[] )
{
SEGPTR segBuff, *segptrList = NULL;
INT i, nList = 0;
DWORD retv;
WORD args[4];
/* Convert arguments to SEGPTRs */
if ( translationList )
for ( nList = 0; translationList[nList]; nList++ )
;
if ( nList )
{
segptrList = HeapAlloc( GetProcessHeap(), 0, sizeof(SEGPTR)*nList );
if ( !segptrList )
{
FIXME("Unable to allocate segptrList!\n" );
return 0;
}
for ( i = 0; i < nList; i++ )
segptrList[i] = *(SEGPTR *)translationList[i]
= MapLS( *(LPVOID *)translationList[i] );
}
segBuff = MapLS( lpBuff );
/* Call 16-bit routine */
args[3] = SELECTOROF(segBuff);
args[2] = OFFSETOF(segBuff);
args[1] = HIWORD(dwUserDefined);
args[0] = LOWORD(dwUserDefined);
WOWCallback16Ex( (DWORD)target, WCB16_PASCAL, sizeof(args), args, &retv );
/* Free temporary selectors */
UnMapLS( segBuff );
if ( nList )
{
for ( i = 0; i < nList; i++ )
UnMapLS( segptrList[i] );
HeapFree( GetProcessHeap(), 0, segptrList );
}
return retv;
}
/**********************************************************************
* DOSVM_HardwareInterruptRM
*
* Emulate call to interrupt handler in real mode.
*
* Either calls directly builtin handler or pushes interrupt frame to
* stack and changes instruction pointer to interrupt handler.
*/
void DOSVM_HardwareInterruptRM( CONTEXT86 *context, BYTE intnum )
{
FARPROC16 handler = DOSVM_GetRMHandler( intnum );
/* check if the call goes to an unhooked interrupt */
if (SELECTOROF(handler) == 0xf000)
{
/* if so, call it directly */
TRACE( "builtin interrupt %02x has been invoked "
"(through vector %02x)\n",
OFFSETOF(handler)/DOSVM_STUB_RM, intnum );
DOSVM_CallBuiltinHandler( context, OFFSETOF(handler)/DOSVM_STUB_RM );
}
else
{
/* the interrupt is hooked, simulate interrupt in DOS space */
WORD flag = LOWORD( context->EFlags );
TRACE( "invoking hooked interrupt %02x at %04x:%04x\n",
intnum, SELECTOROF(handler), OFFSETOF(handler) );
/* Copy virtual interrupt flag to pushed interrupt flag. */
if (context->EFlags & VIF_MASK)
flag |= IF_MASK;
else
flag &= ~IF_MASK;
PUSH_WORD16( context, flag );
PUSH_WORD16( context, context->SegCs );
PUSH_WORD16( context, LOWORD( context->Eip ));
context->SegCs = SELECTOROF( handler );
context->Eip = OFFSETOF( handler );
/* Clear virtual interrupt flag and trap flag. */
context->EFlags &= ~(VIF_MASK | TF_MASK);
}
}
/***********************************************************************
* SwitchStackBack (KERNEL.109)
*/
void WINAPI SwitchStackBack16( CONTEXT *context )
{
STACK16FRAME *oldFrame, *newFrame;
INSTANCEDATA *pData;
if (!(pData = GlobalLock16(SELECTOROF(NtCurrentTeb()->WOW32Reserved))))
return;
if (!pData->old_ss_sp)
{
WARN("No previous SwitchStackTo\n" );
return;
}
TRACE("restoring stack %04x:%04x\n",
SELECTOROF(pData->old_ss_sp), OFFSETOF(pData->old_ss_sp) );
oldFrame = CURRENT_STACK16;
/* Pop bp from the previous stack */
context->Ebp = (context->Ebp & ~0xffff) | *(WORD *)MapSL(pData->old_ss_sp);
pData->old_ss_sp += sizeof(WORD);
/* Switch back to the old stack */
NtCurrentTeb()->WOW32Reserved = (void *)(pData->old_ss_sp - sizeof(STACK16FRAME));
context->SegSs = SELECTOROF(pData->old_ss_sp);
context->Esp = OFFSETOF(pData->old_ss_sp) - sizeof(DWORD); /*ret addr*/
pData->old_ss_sp = 0;
/* Build a stack frame for the return */
newFrame = CURRENT_STACK16;
newFrame->frame32 = oldFrame->frame32;
newFrame->module_cs = oldFrame->module_cs;
newFrame->callfrom_ip = oldFrame->callfrom_ip;
newFrame->entry_ip = oldFrame->entry_ip;
}
DWORD DOSDEV_FindCharDevice(char*name)
{
SEGPTR cur_ptr = MAKESEGPTR(HIWORD(DOS_LOLSeg), FIELD_OFFSET(DOS_LISTOFLISTS,NUL_dev));
DOS_DEVICE_HEADER *cur = PTR_REAL_TO_LIN(SELECTOROF(cur_ptr),OFFSETOF(cur_ptr));
char dname[8];
int cnt;
/* get first 8 characters */
/* if less than 8 characters, pad with spaces */
for (cnt=0; name[cnt] && cnt<8; cnt++)
dname[cnt]=name[cnt];
while(cnt<8) dname[cnt++] = ' ';
/* search for char devices with the right name */
while (cur &&
((!(cur->attr & ATTR_CHAR)) ||
memcmp(cur->name,dname,8))) {
cur_ptr = cur->next_dev;
if (cur_ptr == NONEXT) cur=NULL;
else cur = PTR_REAL_TO_LIN(SELECTOROF(cur_ptr),OFFSETOF(cur_ptr));
}
return cur_ptr;
}
static void NE_CallDllEntryPoint( NE_MODULE *pModule, DWORD dwReason )
{
WORD hInst, ds, heap;
FARPROC16 entryPoint;
if (!(pModule->ne_flags & NE_FFLAGS_LIBMODULE)) return;
if (!(pModule->ne_flags & NE_FFLAGS_BUILTIN) && pModule->ne_expver < 0x0400) return;
if (!(entryPoint = GetProcAddress16( pModule->self, "DllEntryPoint" ))) return;
NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
TRACE_(dll)( "Calling %s DllEntryPoint, cs:ip=%04x:%04x\n",
NE_MODULE_NAME( pModule ),
SELECTOROF(entryPoint), OFFSETOF(entryPoint) );
if ( pModule->ne_flags & NE_FFLAGS_BUILTIN )
{
WinNEEntryProc entryProc = (WinNEEntryProc)((ENTRYPOINT16 *)MapSL( (SEGPTR)entryPoint ))->target;
entryProc( dwReason, hInst, ds, heap, 0, 0 );
}
else
{
CONTEXT context;
WORD args[8];
memset( &context, 0, sizeof(context) );
context.SegDs = ds;
context.SegEs = ds; /* who knows ... */
context.SegFs = wine_get_fs();
context.SegGs = wine_get_gs();
context.SegCs = HIWORD(entryPoint);
context.Eip = LOWORD(entryPoint);
context.Ebp = OFFSETOF(getWOW32Reserved()) + FIELD_OFFSET(STACK16FRAME,bp);
args[7] = HIWORD(dwReason);
args[6] = LOWORD(dwReason);
args[5] = hInst;
args[4] = ds;
args[3] = heap;
args[2] = 0; /* HIWORD(dwReserved1) */
args[1] = 0; /* LOWORD(dwReserved1) */
args[0] = 0; /* wReserved2 */
WOWCallback16Ex( 0, WCB16_REGS, sizeof(args), args, (DWORD *)&context );
}
}
/*************************************************************************
* RunDLL_CallEntry16
*
* Only exported from shell32 on Windows, probably imported
* from shell through the 16/32 thunks.
*/
void WINAPI RunDLL_CallEntry16( DWORD proc, HWND hwnd, HINSTANCE inst, LPCSTR cmdline, INT cmdshow )
{
WORD args[5];
SEGPTR cmdline_seg;
TRACE( "proc %x hwnd %p inst %p cmdline %s cmdshow %d\n",
proc, hwnd, inst, debugstr_a(cmdline), cmdshow );
cmdline_seg = MapLS( cmdline );
args[4] = HWND_16(hwnd);
args[3] = MapHModuleLS(inst);
args[2] = SELECTOROF(cmdline_seg);
args[1] = OFFSETOF(cmdline_seg);
args[0] = cmdshow;
WOWCallback16Ex( proc, WCB16_PASCAL, sizeof(args), args, NULL );
UnMapLS( cmdline_seg );
}
/**@external ResourceManager
* Constructor for RM object.
* @notes Creates a "driver" node for this device driver, but does not
* allocate resources.
*/
ResourceManager::ResourceManager(ULONG pciId)
{
APIRET rc;
DRIVERSTRUCT DriverStruct;
PSEL p;
PGINFOSEG pGIS = 0;
/* Warp version level, bus type, machine ID, and much other information is
* readily available. Reference the RM ADD sample in the DDK for code.
*
* Create a "driver" struct for this driver. This must ALWAYS be the
* first true RM call executed, as it attaches the Resource Manager
* library and performs setup for the other RM calls.
*/
_fmemset( (PVOID) &DriverStruct, 0, sizeof(DriverStruct) );
DriverStruct.DrvrName = (PSZ) "SBLIVE16.SYS"; /* ### IHV */
DriverStruct.DrvrDescript = (PSZ) "SoundBlaster Live!"; /* ### IHV */
DriverStruct.VendorName = (PSZ) "Creative Labs"; /* ### IHV */
DriverStruct.MajorVer = CMVERSION_MAJOR; //rmbase.h /* ### IHV */
DriverStruct.MinorVer = CMVERSION_MINOR; //rmbase.h /* ### IHV */
DriverStruct.Date.Year = 2000; /* ### IHV */
DriverStruct.Date.Month = 2; /* ### IHV */
DriverStruct.Date.Day = 1; /* ### IHV */
DriverStruct.DrvrType = DRT_AUDIO;
DriverStruct.DrvrSubType = 0;
DriverStruct.DrvrCallback = NULL;
rc = RMCreateDriver( &DriverStruct, &_hDriver );
if( rc == RMRC_SUCCESS )
_state = rmDriverCreated;
else {
_state = rmDriverFailed;
_hDriver = 0;
}
// Build a pointer to the Global Information Segment.
rc = DevHelp_GetDOSVar( DHGETDOSV_SYSINFOSEG, 0, (PPVOID)&p );
if (rc) {
_rmDetection = FALSE;
}
else {
SELECTOROF(pGIS) = *p;
_rmDetection =
( (pGIS->uchMajorVersion > 20) ||
((pGIS->uchMajorVersion == 20) && (pGIS->uchMinorVersion > 30)) );
}
}
static void NE_CallDllEntryPoint( NE_MODULE *pModule, DWORD dwReason )
{
WORD hInst, ds, heap;
FARPROC16 entryPoint;
if (!(pModule->flags & NE_FFLAGS_LIBMODULE)) return;
if (!(pModule->flags & NE_FFLAGS_BUILTIN) && pModule->expected_version < 0x0400) return;
if (!(entryPoint = GetProcAddress16( pModule->self, "DllEntryPoint" ))) return;
NE_GetDLLInitParams( pModule, &hInst, &ds, &heap );
TRACE_(dll)( "Calling %s DllEntryPoint, cs:ip=%04x:%04x\n",
NE_MODULE_NAME( pModule ),
SELECTOROF(entryPoint), OFFSETOF(entryPoint) );
if ( pModule->flags & NE_FFLAGS_BUILTIN )
{
WinNEEntryProc entryProc = (WinNEEntryProc)((ENTRYPOINT16 *)MapSL( (SEGPTR)entryPoint ))->target;
entryProc( dwReason, hInst, ds, heap, 0, 0 );
}
else
{
LPBYTE stack = (LPBYTE)CURRENT_STACK16;
CONTEXT86 context;
memset( &context, 0, sizeof(context) );
context.SegDs = ds;
context.SegEs = ds; /* who knows ... */
context.SegCs = HIWORD(entryPoint);
context.Eip = LOWORD(entryPoint);
context.Ebp = OFFSETOF( NtCurrentTeb()->WOW32Reserved )
+ (WORD)&((STACK16FRAME*)0)->bp;
*(DWORD *)(stack - 4) = dwReason; /* dwReason */
*(WORD *) (stack - 6) = hInst; /* hInst */
*(WORD *) (stack - 8) = ds; /* wDS */
*(WORD *) (stack - 10) = heap; /* wHeapSize */
*(DWORD *)(stack - 14) = 0; /* dwReserved1 */
*(WORD *) (stack - 16) = 0; /* wReserved2 */
wine_call_to_16_regs_short( &context, 16 );
}
}
BOOL CALLBACK IsTVWindowEngine( FPTVWNDINFO fpWndInfo, LPARAM lParam )
{
FPISTVWNDPRIVATEDATA fpPrivateData;
/* Get state of window. */
fpPrivateData = ( FPISTVWNDPRIVATEDATA ) lParam;
/* Show/Hide window. */
if( FindWndInfo( (HTVWNDINFO) GlobalHandle(SELECTOROF(fpWndInfo)), fpPrivateData->hWnd ) )
{
/* Mark it found. */
fpPrivateData->bFound = TRUE;
/* Stop enumerating. */
return FALSE;
}
/* Keep enumerating. */
return TRUE;
}
//////////////////////////
// Deallocate your memory
//////////////////////////
void Dealloc(VOIDPTR pMem)
{
HANDLE hMem;
///////////////////////////////
// Memory debugging code
///////////////////////////////
if (pMem != NULL)
{
hMem = GlobalHandle(SELECTOROF(pMem));
if (hMem != NULL)
{
GlobalUnlock(hMem);
GlobalFree(hMem);
pMem = NULL;
}
}
}
static int DPMI_FreeRMCB( DWORD address )
{
RMCB *CurrRMCB = FirstRMCB;
RMCB *PrevRMCB = NULL;
while (CurrRMCB && (CurrRMCB->address != address))
{
PrevRMCB = CurrRMCB;
CurrRMCB = CurrRMCB->next;
}
if (CurrRMCB)
{
if (PrevRMCB)
PrevRMCB->next = CurrRMCB->next;
else
FirstRMCB = CurrRMCB->next;
DOSMEM_FreeBlock(PTR_REAL_TO_LIN(SELECTOROF(CurrRMCB->address),OFFSETOF(CurrRMCB->address)));
HeapFree(GetProcessHeap(), 0, CurrRMCB);
return 0;
}
return 1;
}
/***********************************************************************
* BITMAP_DeleteObject
*/
static BOOL BITMAP_DeleteObject( HGDIOBJ handle, void *obj )
{
BITMAPOBJ * bmp = obj;
if (bmp->funcs && bmp->funcs->pDeleteBitmap)
bmp->funcs->pDeleteBitmap( handle );
HeapFree( GetProcessHeap(), 0, bmp->bitmap.bmBits );
if (bmp->dib)
{
DIBSECTION *dib = bmp->dib;
if (dib->dsBm.bmBits)
{
if (dib->dshSection)
{
SYSTEM_INFO SystemInfo;
GetSystemInfo( &SystemInfo );
UnmapViewOfFile( (char *)dib->dsBm.bmBits -
(dib->dsOffset % SystemInfo.dwAllocationGranularity) );
}
else if (!dib->dsOffset)
VirtualFree(dib->dsBm.bmBits, 0L, MEM_RELEASE );
}
HeapFree(GetProcessHeap(), 0, dib);
bmp->dib = NULL;
if (bmp->segptr_bits)
{ /* free its selector array */
WORD sel = SELECTOROF(bmp->segptr_bits);
WORD count = (GetSelectorLimit16(sel) / 0x10000) + 1;
int i;
for (i = 0; i < count; i++) FreeSelector16(sel + (i << __AHSHIFT));
}
HeapFree(GetProcessHeap(), 0, bmp->color_table);
}
return GDI_FreeObject( handle, obj );
}
