/**************************************************************************** * 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 ); }