/******************************************************************************
* BSTR_GetAddr [INTERNAL]
*/
static void* BSTR_GetAddr(BSTR16 in)
{
return in ? MapSL((SEGPTR)in) : 0;
}
/**************************************************************************
* MCI_UnMapMsg16To32W [internal]
*/
static MMSYSTEM_MapType MCI_UnMapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR lParam)
{
switch (wMsg) {
/* case MCI_CAPTURE */
case MCI_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CONFIGURE:
case MCI_COPY:
case MCI_CUE:
case MCI_CUT:
case MCI_DELETE:
case MCI_GETDEVCAPS:
/* case MCI_INDEX: */
/* case MCI_MARK: */
/* case MCI_MONITOR: */
case MCI_PASTE:
case MCI_PAUSE:
case MCI_PLAY:
case MCI_REALIZE:
case MCI_RECORD:
case MCI_RESUME:
case MCI_SEEK:
case MCI_SET:
/* case MCI_SETTIMECODE:*/
/* case MCI_SIGNAL:*/
case MCI_SPIN:
case MCI_STEP:
case MCI_STOP:
/* case MCI_UNDO: */
case MCI_UPDATE:
return MMSYSTEM_MAP_OK;
case MCI_WHERE:
case MCI_FREEZE:
case MCI_UNFREEZE:
case MCI_PUT:
if (lParam) {
LPMCI_DGV_RECT_PARMS mdrp32 = (LPMCI_DGV_RECT_PARMS)lParam;
char *base = (char*)lParam - sizeof(LPMCI_DGV_RECT_PARMS16);
LPMCI_DGV_RECT_PARMS16 mdrp16 = *(LPMCI_DGV_RECT_PARMS16*)base;
mdrp16->dwCallback = mdrp32->dwCallback;
mdrp16->rc.left = mdrp32->rc.left;
mdrp16->rc.top = mdrp32->rc.top;
mdrp16->rc.right = mdrp32->rc.right;
mdrp16->rc.bottom = mdrp32->rc.bottom;
HeapFree(GetProcessHeap(), 0, base);
}
return MMSYSTEM_MAP_OK;
case MCI_STATUS:
if (lParam && (dwFlags & (MCI_DGV_STATUS_REFERENCE | MCI_DGV_STATUS_DISKSPACE))) {
LPMCI_DGV_STATUS_PARMSW mdsp32w = (LPMCI_DGV_STATUS_PARMSW)lParam;
char *base = (char*)lParam - sizeof(LPMCI_DGV_STATUS_PARMS16);
LPMCI_DGV_STATUS_PARMS16 mdsp16 = *(LPMCI_DGV_STATUS_PARMS16*)base;
mdsp16->dwCallback = mdsp32w->dwCallback;
mdsp16->dwReturn = mdsp32w->dwReturn;
mdsp16->dwItem = mdsp32w->dwItem;
mdsp16->dwTrack = mdsp32w->dwTrack;
mdsp16->dwReference = mdsp32w->dwReference;
HeapFree(GetProcessHeap(), 0, (LPVOID)mdsp32w->lpstrDrive);
HeapFree(GetProcessHeap(), 0, base);
}
return MMSYSTEM_MAP_OK;
case MCI_WINDOW:
if (lParam) {
LPMCI_OVLY_WINDOW_PARMSW mowp32w = (LPMCI_OVLY_WINDOW_PARMSW)lParam;
HeapFree(GetProcessHeap(), 0, (LPVOID)mowp32w->lpstrText);
HeapFree(GetProcessHeap(), 0, mowp32w);
}
return MMSYSTEM_MAP_OK;
case MCI_BREAK:
HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
return MMSYSTEM_MAP_OK;
case MCI_ESCAPE:
if (lParam) {
LPMCI_VD_ESCAPE_PARMSW mvep32W = (LPMCI_VD_ESCAPE_PARMSW)lParam;
HeapFree(GetProcessHeap(), 0, (LPVOID)mvep32W->lpstrCommand);
HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
}
return MMSYSTEM_MAP_OK;
case MCI_INFO:
if (lParam) {
LPMCI_INFO_PARMSW mip32w = (LPMCI_INFO_PARMSW)lParam;
char *base = (char*)lParam - sizeof(LPMCI_INFO_PARMS16);
LPMCI_INFO_PARMS16 mip16 = *(LPMCI_INFO_PARMS16*)base;
WideCharToMultiByte(CP_ACP, 0,
mip32w->lpstrReturn, mip32w->dwRetSize / sizeof(WCHAR),
MapSL(mip16->lpstrReturn), mip16->dwRetSize,
NULL, NULL);
HeapFree(GetProcessHeap(), 0, mip32w->lpstrReturn);
HeapFree(GetProcessHeap(), 0, base);
}
return MMSYSTEM_MAP_OK;
case MCI_SYSINFO:
if (lParam) {
MCI_SYSINFO_PARMSW *msip32w = (MCI_SYSINFO_PARMSW *)lParam;
char *base = (char*)lParam - sizeof(MCI_SYSINFO_PARMS16 *);
MCI_SYSINFO_PARMS16 *msip16 = *(MCI_SYSINFO_PARMS16 **)base;
if (dwFlags & MCI_SYSINFO_QUANTITY) {
DWORD *quantity = MapSL(msip16->lpstrReturn);
*quantity = *(DWORD *)msip32w->lpstrReturn;
}
else {
WideCharToMultiByte(CP_ACP, 0,
msip32w->lpstrReturn, msip32w->dwRetSize,
MapSL(msip16->lpstrReturn), msip16->dwRetSize,
NULL, NULL);
}
HeapFree(GetProcessHeap(), 0, msip32w->lpstrReturn);
HeapFree(GetProcessHeap(), 0, base);
}
return MMSYSTEM_MAP_OK;
case MCI_SOUND:
if (lParam) {
LPMCI_SOUND_PARMSW msp32W = (LPMCI_SOUND_PARMSW)lParam;
HeapFree(GetProcessHeap(), 0, (LPVOID)msp32W->lpstrSoundName);
HeapFree(GetProcessHeap(), 0, (LPVOID)lParam);
}
return MMSYSTEM_MAP_OK;
case MCI_OPEN:
case MCI_OPEN_DRIVER:
if (lParam) {
LPMCI_OPEN_PARMSW mop32w = (LPMCI_OPEN_PARMSW)lParam;
char *base = (char*)lParam - sizeof(LPMCI_OPEN_PARMS16);
LPMCI_OPEN_PARMS16 mop16 = *(LPMCI_OPEN_PARMS16*)base;
mop16->wDeviceID = mop32w->wDeviceID;
if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrDeviceType);
if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrElementName);
if( ( dwFlags & MCI_OPEN_ALIAS))
HeapFree(GetProcessHeap(), 0, (LPWSTR)mop32w->lpstrAlias);
if (!HeapFree(GetProcessHeap(), 0, base))
FIXME("bad free line=%d\n", __LINE__);
}
return MMSYSTEM_MAP_OK;
case DRV_LOAD:
case DRV_ENABLE:
case DRV_OPEN:
case DRV_CLOSE:
case DRV_DISABLE:
case DRV_FREE:
case DRV_CONFIGURE:
case DRV_QUERYCONFIGURE:
case DRV_INSTALL:
case DRV_REMOVE:
case DRV_EXITSESSION:
case DRV_EXITAPPLICATION:
case DRV_POWER:
FIXME("This is a hack\n");
return MMSYSTEM_MAP_OK;
default:
FIXME("Map/Unmap internal error on msg=%s\n", MCI_MessageToString(wMsg));
}
return MMSYSTEM_MAP_MSGERROR;
}
/******************************************************************************
* BSTR_Free [INTERNAL]
*/
static void BSTR_Free(BSTR16 in)
{
void *ptr = MapSL( (SEGPTR)in );
UnMapLS( (SEGPTR)in );
HeapFree( GetProcessHeap(), 0, ptr );
}
/*************************************************************************
* DoEnvironmentSubst [SHELL.37]
*
* Replace %KEYWORD% in the str with the value of variable KEYWORD
* from "DOS" environment.
*/
DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
{
LPSTR lpEnv = MapSL(GetDOSEnvironment16());
LPSTR lpBuffer = (LPSTR)HeapAlloc( GetProcessHeap(), 0, length);
LPSTR lpstr = str;
LPSTR lpbstr = lpBuffer;
CharToOemA(str,str);
TRACE("accept %s\n", str);
while( *lpstr && lpbstr - lpBuffer < length )
{
LPSTR lpend = lpstr;
if( *lpstr == '%' )
{
do { lpend++; } while( *lpend && *lpend != '%' );
if( *lpend == '%' && lpend - lpstr > 1 ) /* found key */
{
LPSTR lpKey;
*lpend = '\0';
lpKey = SHELL_FindString(lpEnv, lpstr+1);
if( lpKey ) /* found key value */
{
int l = strlen(lpKey);
if( l > length - (lpbstr - lpBuffer) - 1 )
{
WARN("-- Env subst aborted - string too short\n");
*lpend = '%';
break;
}
strcpy(lpbstr, lpKey);
lpbstr += l;
}
else break;
*lpend = '%';
lpstr = lpend + 1;
}
else break; /* back off and whine */
continue;
}
*lpbstr++ = *lpstr++;
}
*lpbstr = '\0';
if( lpstr - str == strlen(str) )
{
strncpy(str, lpBuffer, length);
length = 1;
}
else
length = 0;
TRACE("-- return %s\n", str);
OemToCharA(str,str);
HeapFree( GetProcessHeap(), 0, lpBuffer);
/* Return str length in the LOWORD
* and 1 in HIWORD if subst was successful.
*/
return (DWORD)MAKELONG(strlen(str), length);
}
/**************************************************************************
* MCI_MapMsg16To32W [internal]
*/
static MMSYSTEM_MapType MCI_MapMsg16To32W(WORD wMsg, DWORD dwFlags, DWORD_PTR* lParam)
{
if (*lParam == 0)
return MMSYSTEM_MAP_OK;
/* FIXME: to add also (with seg/linear modifications to do):
* MCI_LIST, MCI_LOAD, MCI_QUALITY, MCI_RESERVE, MCI_RESTORE, MCI_SAVE
* MCI_SETAUDIO, MCI_SETTUNER, MCI_SETVIDEO
*/
switch (wMsg) {
/* case MCI_CAPTURE */
case MCI_CLOSE:
case MCI_CLOSE_DRIVER:
case MCI_CONFIGURE:
case MCI_COPY:
case MCI_CUE:
case MCI_CUT:
case MCI_DELETE:
case MCI_GETDEVCAPS:
/* case MCI_INDEX: */
/* case MCI_MARK: */
/* case MCI_MONITOR: */
case MCI_PASTE:
case MCI_PAUSE:
case MCI_PLAY:
case MCI_REALIZE:
case MCI_RECORD:
case MCI_RESUME:
case MCI_SEEK:
case MCI_SET:
/* case MCI_SETTIMECODE:*/
/* case MCI_SIGNAL:*/
case MCI_SPIN:
case MCI_STEP:
case MCI_STOP:
/* case MCI_UNDO: */
case MCI_UPDATE:
*lParam = (DWORD)MapSL(*lParam);
return MMSYSTEM_MAP_OK;
case MCI_WHERE:
case MCI_FREEZE:
case MCI_UNFREEZE:
case MCI_PUT:
{
LPMCI_DGV_RECT_PARMS mdrp32 = HeapAlloc(GetProcessHeap(), 0,
sizeof(LPMCI_DGV_RECT_PARMS16) + sizeof(MCI_DGV_RECT_PARMS));
LPMCI_DGV_RECT_PARMS16 mdrp16 = MapSL(*lParam);
if (mdrp32) {
*(LPMCI_DGV_RECT_PARMS16*)(mdrp32) = mdrp16;
mdrp32 = (LPMCI_DGV_RECT_PARMS)((char*)mdrp32 + sizeof(LPMCI_DGV_RECT_PARMS16));
mdrp32->dwCallback = mdrp16->dwCallback;
mdrp32->rc.left = mdrp16->rc.left;
mdrp32->rc.top = mdrp16->rc.top;
mdrp32->rc.right = mdrp16->rc.right;
mdrp32->rc.bottom = mdrp16->rc.bottom;
} else {
return MMSYSTEM_MAP_NOMEM;
}
*lParam = (DWORD)mdrp32;
}
return MMSYSTEM_MAP_OKMEM;
case MCI_STATUS:
{
if (dwFlags & (MCI_DGV_STATUS_REFERENCE | MCI_DGV_STATUS_DISKSPACE)) {
LPMCI_DGV_STATUS_PARMSW mdsp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
sizeof(LPMCI_DGV_STATUS_PARMS16) + sizeof(MCI_DGV_STATUS_PARMSW));
LPMCI_DGV_STATUS_PARMS16 mdsp16 = MapSL(*lParam);
if (mdsp32w) {
*(LPMCI_DGV_STATUS_PARMS16*)(mdsp32w) = mdsp16;
mdsp32w = (LPMCI_DGV_STATUS_PARMSW)((char*)mdsp32w + sizeof(LPMCI_DGV_STATUS_PARMS16));
mdsp32w->dwCallback = mdsp16->dwCallback;
mdsp32w->dwReturn = mdsp16->dwReturn;
mdsp32w->dwItem = mdsp16->dwItem;
mdsp32w->dwTrack = mdsp16->dwTrack;
if (dwFlags & MCI_DGV_STATUS_DISKSPACE)
mdsp32w->lpstrDrive = MCI_strdupAtoW(MapSL(mdsp16->lpstrDrive));
mdsp32w->dwReference = mdsp16->dwReference;
*lParam = (DWORD)mdsp32w;
} else {
return MMSYSTEM_MAP_NOMEM;
}
} else {
*lParam = (DWORD)MapSL(*lParam);
}
}
return MMSYSTEM_MAP_OKMEM;
case MCI_WINDOW:
{
LPMCI_OVLY_WINDOW_PARMSW mowp32w = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MCI_OVLY_WINDOW_PARMSW));
LPMCI_OVLY_WINDOW_PARMS16 mowp16 = MapSL(*lParam);
if (mowp32w) {
mowp32w->dwCallback = mowp16->dwCallback;
mowp32w->hWnd = HWND_32(mowp16->hWnd);
mowp32w->nCmdShow = mowp16->nCmdShow;
if (dwFlags & (MCI_DGV_WINDOW_TEXT | MCI_OVLY_WINDOW_TEXT))
mowp32w->lpstrText = MCI_strdupAtoW(MapSL(mowp16->lpstrText));
} else {
return MMSYSTEM_MAP_NOMEM;
}
*lParam = (DWORD)mowp32w;
}
return MMSYSTEM_MAP_OKMEM;
case MCI_BREAK:
{
LPMCI_BREAK_PARMS mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_BREAK_PARMS));
LPMCI_BREAK_PARMS16 mbp16 = MapSL(*lParam);
if (mbp32) {
mbp32->dwCallback = mbp16->dwCallback;
mbp32->nVirtKey = mbp16->nVirtKey;
mbp32->hwndBreak = HWND_32(mbp16->hwndBreak);
} else {
return MMSYSTEM_MAP_NOMEM;
}
*lParam = (DWORD)mbp32;
}
return MMSYSTEM_MAP_OKMEM;
case MCI_ESCAPE:
{
LPMCI_VD_ESCAPE_PARMSW mvep32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_VD_ESCAPE_PARMSW));
LPMCI_VD_ESCAPE_PARMS16 mvep16 = MapSL(*lParam);
if (mvep32w) {
mvep32w->dwCallback = mvep16->dwCallback;
mvep32w->lpstrCommand = MCI_strdupAtoW(MapSL(mvep16->lpstrCommand));
} else {
return MMSYSTEM_MAP_NOMEM;
}
*lParam = (DWORD)mvep32w;
}
return MMSYSTEM_MAP_OKMEM;
case MCI_INFO:
{
LPMCI_INFO_PARMSW mip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_INFO_PARMSW));
LPMCI_INFO_PARMS16 mip16 = MapSL(*lParam);
/* FIXME this is wrong if device is of type
* MCI_DEVTYPE_DIGITAL_VIDEO, some members are not mapped
*/
if (mip32w) {
*(LPMCI_INFO_PARMS16*)(mip32w) = mip16;
mip32w = (LPMCI_INFO_PARMSW)((char*)mip32w + sizeof(LPMCI_INFO_PARMS16));
mip32w->dwCallback = mip16->dwCallback;
mip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, mip16->dwRetSize * sizeof(WCHAR));
mip32w->dwRetSize = mip16->dwRetSize * sizeof(WCHAR);
} else {
return MMSYSTEM_MAP_NOMEM;
}
*lParam = (DWORD)mip32w;
}
return MMSYSTEM_MAP_OKMEM;
case MCI_OPEN:
case MCI_OPEN_DRIVER:
{
LPMCI_OPEN_PARMSW mop32w = HeapAlloc(GetProcessHeap(), 0, sizeof(LPMCI_OPEN_PARMS16) + sizeof(MCI_OPEN_PARMSW) + 2 * sizeof(DWORD));
LPMCI_OPEN_PARMS16 mop16 = MapSL(*lParam);
if (mop32w) {
*(LPMCI_OPEN_PARMS16*)(mop32w) = mop16;
mop32w = (LPMCI_OPEN_PARMSW)((char*)mop32w + sizeof(LPMCI_OPEN_PARMS16));
mop32w->dwCallback = mop16->dwCallback;
mop32w->wDeviceID = mop16->wDeviceID;
if( ( dwFlags & ( MCI_OPEN_TYPE | MCI_OPEN_TYPE_ID)) == MCI_OPEN_TYPE)
mop32w->lpstrDeviceType = MCI_strdupAtoW(MapSL(mop16->lpstrDeviceType));
else
mop32w->lpstrDeviceType = (LPWSTR) mop16->lpstrDeviceType;
if( ( dwFlags & ( MCI_OPEN_ELEMENT | MCI_OPEN_ELEMENT_ID)) == MCI_OPEN_ELEMENT)
mop32w->lpstrElementName = MCI_strdupAtoW(MapSL(mop16->lpstrElementName));
else
mop32w->lpstrElementName = (LPWSTR) mop16->lpstrElementName;
if( ( dwFlags & MCI_OPEN_ALIAS))
mop32w->lpstrAlias = MCI_strdupAtoW(MapSL(mop16->lpstrAlias));
else
mop32w->lpstrAlias = (LPWSTR) mop16->lpstrAlias;
/* copy extended information if any...
* FIXME: this may seg fault if initial structure does not contain them and
* the reads after msip16 fail under LDT limits...
* NOTE: this should be split in two. First pass, while calling MCI_OPEN, and
* should not take care of extended parameters, and should be used by MCI_Open
* to fetch uDevType. When, this is known, the mapping for sending the
* MCI_OPEN_DRIVER shall be done depending on uDevType.
*/
memcpy(mop32w + 1, mop16 + 1, 2 * sizeof(DWORD));
} else {
return MMSYSTEM_MAP_NOMEM;
}
*lParam = (DWORD)mop32w;
}
return MMSYSTEM_MAP_OKMEM;
case MCI_SYSINFO:
{
MCI_SYSINFO_PARMSW *msip32w = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_OPEN_PARMS16 *) + sizeof(MCI_SYSINFO_PARMSW));
MCI_SYSINFO_PARMS16 *msip16 = MapSL(*lParam);
if (!msip32w)
return MMSYSTEM_MAP_NOMEM;
*(MCI_SYSINFO_PARMS16 **)msip32w = msip16;
msip32w = (MCI_SYSINFO_PARMSW *)((char *)msip32w + sizeof(MCI_OPEN_PARMS16 *));
msip32w->dwCallback = msip16->dwCallback;
msip32w->lpstrReturn = HeapAlloc(GetProcessHeap(), 0, (dwFlags & MCI_SYSINFO_QUANTITY) ?
sizeof(DWORD) :
msip16->dwRetSize * sizeof(WCHAR));
if (!msip32w->lpstrReturn)
{
HeapFree(GetProcessHeap(), 0, msip32w);
return MMSYSTEM_MAP_NOMEM;
}
msip32w->dwRetSize = (dwFlags & MCI_SYSINFO_QUANTITY) ? sizeof(DWORD) : msip16->dwRetSize;
msip32w->dwNumber = msip16->dwNumber;
msip32w->wDeviceType = msip16->wDeviceType;
*lParam = (DWORD)msip32w;
}
return MMSYSTEM_MAP_OKMEM;
case MCI_SOUND:
{
LPMCI_SOUND_PARMSW mbp32 = HeapAlloc(GetProcessHeap(), 0, sizeof(MCI_SOUND_PARMSW));
LPMCI_SOUND_PARMS16 mbp16 = MapSL(*lParam);
if (mbp32) {
mbp32->dwCallback = mbp16->dwCallback;
mbp32->lpstrSoundName = MCI_strdupAtoW(MapSL(mbp16->lpstrSoundName));
} else {
return MMSYSTEM_MAP_NOMEM;
}
*lParam = (DWORD)mbp32;
}
return MMSYSTEM_MAP_OKMEM;
case DRV_LOAD:
case DRV_ENABLE:
case DRV_OPEN:
case DRV_CLOSE:
case DRV_DISABLE:
case DRV_FREE:
case DRV_CONFIGURE:
case DRV_QUERYCONFIGURE:
case DRV_INSTALL:
case DRV_REMOVE:
case DRV_EXITSESSION:
case DRV_EXITAPPLICATION:
case DRV_POWER:
FIXME("This is a hack\n");
return MMSYSTEM_MAP_OK;
default:
FIXME("Don't know how to map msg=%s\n", MCI_MessageToString(wMsg));
}
return MMSYSTEM_MAP_MSGERROR;
}
/***********************************************************************
* CoGetClassObject [COMPOBJ.7]
*
*/
HRESULT WINAPI CoGetClassObject16(
SEGPTR rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo,
SEGPTR riid, SEGPTR ppv)
{
LPVOID *ppvl = MapSL(ppv);
TRACE("CLSID: %s, IID: %s\n", debugstr_guid(MapSL(rclsid)), debugstr_guid(MapSL(riid)));
*ppvl = NULL;
if (pServerInfo) {
FIXME("pServerInfo->name=%s pAuthInfo=%p\n",
debugstr_w(pServerInfo->pwszName), pServerInfo->pAuthInfo);
}
if (CLSCTX_INPROC_SERVER & dwClsContext)
{
char idstr[CHARS_IN_GUID];
char buf_key[CHARS_IN_GUID+19], dllpath[MAX_PATH+1];
LONG dllpath_len = sizeof(dllpath);
HMODULE16 dll;
FARPROC16 DllGetClassObject;
WORD args[6];
DWORD dwRet;
StringFromGUID216(MapSL(rclsid), idstr, CHARS_IN_GUID);
sprintf(buf_key, "CLSID\\%s\\InprocServer", idstr);
if (RegQueryValueA(HKEY_CLASSES_ROOT, buf_key, dllpath, &dllpath_len))
{
ERR("class %s not registered\n", debugstr_guid(MapSL(rclsid)));
return REGDB_E_CLASSNOTREG;
}
dll = LoadLibrary16(dllpath);
if (!dll)
{
ERR("couldn't load in-process dll %s\n", debugstr_a(dllpath));
return E_ACCESSDENIED; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
}
DllGetClassObject = GetProcAddress16(dll, "DllGetClassObject");
if (!DllGetClassObject)
{
ERR("couldn't find function DllGetClassObject in %s\n", debugstr_a(dllpath));
FreeLibrary16(dll);
return CO_E_DLLNOTFOUND;
}
TRACE("calling DllGetClassObject %p\n", DllGetClassObject);
args[5] = SELECTOROF(rclsid);
args[4] = OFFSETOF(rclsid);
args[3] = SELECTOROF(riid);
args[2] = OFFSETOF(riid);
args[1] = SELECTOROF(ppv);
args[0] = OFFSETOF(ppv);
WOWCallback16Ex((DWORD) DllGetClassObject, WCB16_PASCAL, sizeof(args), args, &dwRet);
if (dwRet != S_OK)
{
ERR("DllGetClassObject returned error 0x%08x\n", dwRet);
FreeLibrary16(dll);
return dwRet;
}
return S_OK;
}
FIXME("semi-stub\n");
return E_NOTIMPL;
}
void WINAPI SNOOP16_Entry(FARPROC proc, LPBYTE args, CONTEXT86 *context) {
DWORD ordinal=0;
DWORD entry=(DWORD)MapSL( MAKESEGPTR(context->SegCs,LOWORD(context->Eip)) )-5;
WORD xcs = context->SegCs;
SNOOP16_DLL *dll = firstdll;
SNOOP16_FUN *fun = NULL;
SNOOP16_RETURNENTRIES **rets = &firstrets;
SNOOP16_RETURNENTRY *ret;
unsigned i=0;
int max;
while (dll) {
if (xcs == dll->funhandle) {
fun = (SNOOP16_FUN*)entry;
ordinal = fun-dll->funs;
break;
}
dll=dll->next;
}
if (!dll) {
FIXME("entrypoint 0x%08x not found\n",entry);
return; /* oops */
}
while (*rets) {
for (i=0;i<sizeof((*rets)->entry)/sizeof((*rets)->entry[0]);i++)
if (!(*rets)->entry[i].origreturn)
break;
if (i!=sizeof((*rets)->entry)/sizeof((*rets)->entry[0]))
break;
rets = &((*rets)->next);
}
if (!*rets) {
HANDLE16 hand = GlobalHandleToSel16(GLOBAL_Alloc(GMEM_ZEROINIT,65535,0,WINE_LDT_FLAGS_CODE));
*rets = GlobalLock16(hand);
(*rets)->rethandle = hand;
i = 0; /* entry 0 is free */
}
ret = &((*rets)->entry[i]);
ret->lcall = 0x9a;
ret->snr = MAKELONG(sizeof(SNOOP16_RELAY),xsnr);
ret->origreturn = (FARPROC16)CALLER1REF;
CALLER1REF = MAKELONG((char*)&(ret->lcall)-(char*)((*rets)->entry),(*rets)->rethandle);
ret->dll = dll;
ret->args = NULL;
ret->ordinal = ordinal;
ret->origSP = LOWORD(context->Esp);
context->Eip= LOWORD(fun->origfun);
context->SegCs = HIWORD(fun->origfun);
DPRINTF("%04x:CALL %s.%d: %s(",GetCurrentThreadId(), dll->name,ordinal,fun->name);
if (fun->nrofargs>0) {
max = fun->nrofargs;
if (max>16) max=16;
for (i=max;i--;)
DPRINTF("%04x%s",*(WORD*)((char *) MapSL( MAKESEGPTR(context->SegSs,LOWORD(context->Esp)) )+8+sizeof(WORD)*i),i?",":"");
if (max!=fun->nrofargs)
DPRINTF(" ...");
} else if (fun->nrofargs<0) {
DPRINTF("<unknown, check return>");
ret->args = HeapAlloc(GetProcessHeap(),0,16*sizeof(WORD));
memcpy(ret->args,(LPBYTE)((char *) MapSL( MAKESEGPTR(context->SegSs,LOWORD(context->Esp)) )+8),sizeof(WORD)*16);
}
DPRINTF(") ret=%04x:%04x\n",HIWORD(ret->origreturn),LOWORD(ret->origreturn));
}
/***********************************************************************
* CallNextHookEx (USER.293)
*/
LRESULT WINAPI CallNextHookEx16( HHOOK hhook, INT16 code, WPARAM16 wparam, LPARAM lparam )
{
struct hook16_queue_info *info;
LRESULT ret = 0;
if (!(info = get_hook_info( FALSE ))) return 0;
switch (info->id)
{
case WH_MSGFILTER:
{
MSG16 *msg16 = MapSL(lparam);
MSG msg32;
map_msg_16_to_32( msg16, &msg32 );
ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&msg32 );
break;
}
case WH_GETMESSAGE:
{
MSG16 *msg16 = MapSL(lparam);
MSG msg32;
map_msg_16_to_32( msg16, &msg32 );
ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&msg32 );
map_msg_32_to_16( &msg32, msg16 );
break;
}
case WH_CALLWNDPROC:
{
CWPSTRUCT16 *cwp16 = MapSL(lparam);
LRESULT result;
struct wndproc_hook_params params;
params.hhook = hhook;
params.code = code;
params.wparam = wparam;
ret = WINPROC_CallProc16To32A( wndproc_hook_callback, cwp16->hwnd, cwp16->message,
cwp16->wParam, cwp16->lParam, &result, ¶ms );
break;
}
case WH_CBT:
switch (code)
{
case HCBT_CREATEWND:
{
CBT_CREATEWNDA cbtcw32;
CREATESTRUCTA cs32;
CBT_CREATEWND16 *cbtcw16 = MapSL(lparam);
CREATESTRUCT16 *cs16 = MapSL( (SEGPTR)cbtcw16->lpcs );
cbtcw32.lpcs = &cs32;
cbtcw32.hwndInsertAfter = WIN_Handle32( cbtcw16->hwndInsertAfter );
cs32.lpCreateParams = (LPVOID)cs16->lpCreateParams;
cs32.hInstance = HINSTANCE_32(cs16->hInstance);
cs32.hMenu = HMENU_32(cs16->hMenu);
cs32.hwndParent = WIN_Handle32(cs16->hwndParent);
cs32.cy = cs16->cy;
cs32.cx = cs16->cx;
cs32.y = cs16->y;
cs32.x = cs16->x;
cs32.style = cs16->style;
cs32.lpszName = MapSL( cs16->lpszName );
cs32.lpszClass = MapSL( cs16->lpszClass );
cs32.dwExStyle = cs16->dwExStyle;
ret = CallNextHookEx( hhook, code, HWND_32(wparam), (LPARAM)&cbtcw32 );
cbtcw16->hwndInsertAfter = HWND_16( cbtcw32.hwndInsertAfter );
break;
}
case HCBT_ACTIVATE:
{
CBTACTIVATESTRUCT16 *cas16 = MapSL(lparam);
CBTACTIVATESTRUCT cas32;
cas32.fMouse = cas16->fMouse;
cas32.hWndActive = WIN_Handle32(cas16->hWndActive);
ret = CallNextHookEx( hhook, code, HWND_32(wparam), (LPARAM)&cas32 );
break;
}
case HCBT_CLICKSKIPPED:
{
MOUSEHOOKSTRUCT16 *ms16 = MapSL(lparam);
MOUSEHOOKSTRUCT ms32;
ms32.pt.x = ms16->pt.x;
ms32.pt.y = ms16->pt.y;
/* wHitTestCode may be negative, so convince compiler to do
correct sign extension. Yay. :| */
ms32.wHitTestCode = (INT)(INT16)ms16->wHitTestCode;
ms32.dwExtraInfo = ms16->dwExtraInfo;
ms32.hwnd = WIN_Handle32( ms16->hwnd );
ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&ms32 );
break;
}
case HCBT_MOVESIZE:
{
RECT16 *rect16 = MapSL(lparam);
RECT rect32;
rect32.left = rect16->left;
rect32.top = rect16->top;
rect32.right = rect16->right;
rect32.bottom = rect16->bottom;
ret = CallNextHookEx( hhook, code, HWND_32(wparam), (LPARAM)&rect32 );
break;
}
}
break;
case WH_MOUSE:
{
MOUSEHOOKSTRUCT16 *ms16 = MapSL(lparam);
MOUSEHOOKSTRUCT ms32;
ms32.pt.x = ms16->pt.x;
ms32.pt.y = ms16->pt.y;
/* wHitTestCode may be negative, so convince compiler to do
correct sign extension. Yay. :| */
ms32.wHitTestCode = (INT)((INT16)ms16->wHitTestCode);
ms32.dwExtraInfo = ms16->dwExtraInfo;
ms32.hwnd = WIN_Handle32(ms16->hwnd);
ret = CallNextHookEx( hhook, code, wparam, (LPARAM)&ms32 );
break;
}
case WH_SHELL:
case WH_KEYBOARD:
ret = CallNextHookEx( hhook, code, wparam, lparam );
break;
case WH_HARDWARE:
case WH_FOREGROUNDIDLE:
case WH_CALLWNDPROCRET:
case WH_SYSMSGFILTER:
case WH_JOURNALRECORD:
case WH_JOURNALPLAYBACK:
default:
FIXME("\t[%i] 16to32 translation unimplemented\n", info->id);
ret = CallNextHookEx( hhook, code, wparam, lparam );
break;
}
return ret;
}
/*************************************************************************
* DoEnvironmentSubst [SHELL.37]
*
* Replace %KEYWORD% in the str with the value of variable KEYWORD
* from "DOS" environment. If it is not found the %KEYWORD% is left
* intact. If the buffer is too small, str is not modified.
*
* PARAMS
* str [I] '\0' terminated string with %keyword%.
* [O] '\0' terminated string with %keyword% substituted.
* length [I] size of str.
*
* RETURNS
* str length in the LOWORD and 1 in HIWORD if subst was successful.
*/
DWORD WINAPI DoEnvironmentSubst16(LPSTR str,WORD length)
{
LPSTR lpEnv = MapSL(GetDOSEnvironment16());
LPSTR lpstr = str;
LPSTR lpend;
LPSTR lpBuffer = HeapAlloc( GetProcessHeap(), 0, length);
WORD bufCnt = 0;
WORD envKeyLen;
LPSTR lpKey;
WORD retStatus = 0;
WORD retLength = length;
CharToOemA(str,str);
TRACE("accept %s\n", str);
while( *lpstr && bufCnt <= length - 1 ) {
if ( *lpstr != '%' ) {
lpBuffer[bufCnt++] = *lpstr++;
continue;
}
for( lpend = lpstr + 1; *lpend && *lpend != '%'; lpend++) /**/;
envKeyLen = lpend - lpstr - 1;
if( *lpend != '%' || envKeyLen == 0)
goto err; /* "%\0" or "%%" found; back off and whine */
*lpend = '\0';
lpKey = SHELL_FindString(lpEnv, lpstr+1);
*lpend = '%';
if( lpKey ) {
int l = strlen(lpKey);
if( bufCnt + l > length - 1 )
goto err;
memcpy(lpBuffer + bufCnt, lpKey, l);
bufCnt += l;
} else { /* Keyword not found; Leave the %KEYWORD% intact */
if( bufCnt + envKeyLen + 2 > length - 1 )
goto err;
memcpy(lpBuffer + bufCnt, lpstr, envKeyLen + 2);
bufCnt += envKeyLen + 2;
}
lpstr = lpend + 1;
}
if (!*lpstr && bufCnt <= length - 1) {
memcpy(str,lpBuffer, bufCnt);
str[bufCnt] = '\0';
retLength = bufCnt + 1;
retStatus = 1;
}
err:
if (!retStatus)
WARN("-- Env subst aborted - string too short or invalid input\n");
TRACE("-- return %s\n", str);
OemToCharA(str,str);
HeapFree( GetProcessHeap(), 0, lpBuffer);
return (DWORD)MAKELONG(retLength, retStatus);
}
/***********************************************************************
* lstrcpyn (KERNEL.353)
*/
SEGPTR WINAPI lstrcpyn16( SEGPTR dst, LPCSTR src, INT16 n )
{
if (!lstrcpynA( MapSL(dst), src, n )) return 0;
return dst;
}
/***********************************************************************
* Reserved1 (KERNEL.77)
*/
SEGPTR WINAPI KERNEL_AnsiNext16(SEGPTR current)
{
return (*(char *)MapSL(current)) ? current + 1 : current;
}
/***********************************************************************
* lstrcat (KERNEL.89)
*/
SEGPTR WINAPI lstrcat16( SEGPTR dst, LPCSTR src )
{
/* Windows does not check for NULL pointers here, so we don't either */
strcat( MapSL(dst), src );
return dst;
}
/***********************************************************************
* lstrcpy (KERNEL.88)
*/
SEGPTR WINAPI lstrcpy16( SEGPTR dst, LPCSTR src )
{
if (!lstrcpyA( MapSL(dst), src )) dst = 0;
return dst;
}
/******************************************************************
* MSVIDEO_MapMsg16To32
*
*
*/
static LPVOID MSVIDEO_MapMsg16To32(UINT msg, LPDWORD lParam1, LPDWORD lParam2)
{
LPVOID ret = 0;
TRACE("Mapping %d\n", msg);
switch (msg)
{
case DRV_LOAD:
case DRV_ENABLE:
case DRV_CLOSE:
case DRV_DISABLE:
case DRV_FREE:
case ICM_ABOUT:
case ICM_CONFIGURE:
case ICM_COMPRESS_END:
case ICM_DECOMPRESS_END:
case ICM_DECOMPRESSEX_END:
case ICM_SETQUALITY:
case ICM_DRAW_START_PLAY:
case ICM_DRAW_STOP_PLAY:
case ICM_DRAW_REALIZE:
case ICM_DRAW_RENDERBUFFER:
case ICM_DRAW_END:
break;
case DRV_OPEN:
case ICM_GETDEFAULTQUALITY:
case ICM_GETQUALITY:
case ICM_SETSTATE:
case ICM_DRAW_WINDOW:
case ICM_GETBUFFERSWANTED:
*lParam1 = (DWORD)MapSL(*lParam1);
break;
case ICM_GETINFO:
{
ICINFO *ici = HeapAlloc(GetProcessHeap(), 0, sizeof(ICINFO));
ICINFO16 *ici16;
ici16 = MapSL(*lParam1);
ret = ici16;
ici->dwSize = sizeof(ICINFO);
COPY(ici, fccType);
COPY(ici, fccHandler);
COPY(ici, dwFlags);
COPY(ici, dwVersion);
COPY(ici, dwVersionICM);
MultiByteToWideChar( CP_ACP, 0, ici16->szName, -1, ici->szName, 16 );
MultiByteToWideChar( CP_ACP, 0, ici16->szDescription, -1, ici->szDescription, 128 );
MultiByteToWideChar( CP_ACP, 0, ici16->szDriver, -1, ici->szDriver, 128 );
*lParam1 = (DWORD)(ici);
*lParam2 = sizeof(ICINFO);
}
break;
case ICM_COMPRESS:
{
ICCOMPRESS *icc = HeapAlloc(GetProcessHeap(), 0, sizeof(ICCOMPRESS));
ICCOMPRESS *icc16;
icc16 = MapSL(*lParam1);
ret = icc16;
COPY(icc, dwFlags);
COPYPTR(icc, lpbiOutput);
COPYPTR(icc, lpOutput);
COPYPTR(icc, lpbiInput);
COPYPTR(icc, lpInput);
COPYPTR(icc, lpckid);
COPYPTR(icc, lpdwFlags);
COPY(icc, lFrameNum);
COPY(icc, dwFrameSize);
COPY(icc, dwQuality);
COPYPTR(icc, lpbiPrev);
COPYPTR(icc, lpPrev);
*lParam1 = (DWORD)(icc);
*lParam2 = sizeof(ICCOMPRESS);
}
break;
case ICM_DECOMPRESS:
{
ICDECOMPRESS *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDECOMPRESS));
ICDECOMPRESS *icd16; /* Same structure except for the pointers */
icd16 = MapSL(*lParam1);
ret = icd16;
COPY(icd, dwFlags);
COPYPTR(icd, lpbiInput);
COPYPTR(icd, lpInput);
COPYPTR(icd, lpbiOutput);
COPYPTR(icd, lpOutput);
COPY(icd, ckid);
*lParam1 = (DWORD)(icd);
*lParam2 = sizeof(ICDECOMPRESS);
}
break;
case ICM_COMPRESS_BEGIN:
case ICM_COMPRESS_GET_FORMAT:
case ICM_COMPRESS_GET_SIZE:
case ICM_COMPRESS_QUERY:
case ICM_DECOMPRESS_GET_FORMAT:
case ICM_DECOMPRESS_QUERY:
case ICM_DECOMPRESS_BEGIN:
case ICM_DECOMPRESS_SET_PALETTE:
case ICM_DECOMPRESS_GET_PALETTE:
*lParam1 = (DWORD)MapSL(*lParam1);
*lParam2 = (DWORD)MapSL(*lParam2);
break;
case ICM_DECOMPRESSEX_QUERY:
if ((*lParam2 != sizeof(ICDECOMPRESSEX16)) && (*lParam2 != 0))
WARN("*lParam2 has unknown value %p\n", (ICDECOMPRESSEX16*)*lParam2);
/* FIXME: *lParm2 is meant to be 0 or an ICDECOMPRESSEX16*, but is sizeof(ICDECOMRPESSEX16)
* This is because of ICMessage(). Special case it?
{
LPVOID* addr = HeapAlloc(GetProcessHeap(), 0, 2*sizeof(LPVOID));
addr[0] = MSVIDEO_MapICDEX16To32(lParam1);
if (*lParam2)
addr[1] = MSVIDEO_MapICDEX16To32(lParam2);
else
addr[1] = 0;
ret = addr;
}
break;*/
case ICM_DECOMPRESSEX_BEGIN:
case ICM_DECOMPRESSEX:
ret = MSVIDEO_MapICDEX16To32(lParam1);
*lParam2 = sizeof(ICDECOMPRESSEX);
break;
case ICM_DRAW_BEGIN:
{
ICDRAWBEGIN *icdb = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWBEGIN));
ICDRAWBEGIN16 *icdb16 = MapSL(*lParam1);
ret = icdb16;
COPY(icdb, dwFlags);
icdb->hpal = HPALETTE_32(icdb16->hpal);
icdb->hwnd = HWND_32(icdb16->hwnd);
icdb->hdc = HDC_32(icdb16->hdc);
COPY(icdb, xDst);
COPY(icdb, yDst);
COPY(icdb, dxDst);
COPY(icdb, dyDst);
COPYPTR(icdb, lpbi);
COPY(icdb, xSrc);
COPY(icdb, ySrc);
COPY(icdb, dxSrc);
COPY(icdb, dySrc);
COPY(icdb, dwRate);
COPY(icdb, dwScale);
*lParam1 = (DWORD)(icdb);
*lParam2 = sizeof(ICDRAWBEGIN);
}
break;
case ICM_DRAW_SUGGESTFORMAT:
{
ICDRAWSUGGEST *icds = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAWSUGGEST));
ICDRAWSUGGEST16 *icds16 = MapSL(*lParam1);
ret = icds16;
COPY(icds, dwFlags);
COPYPTR(icds, lpbiIn);
COPYPTR(icds, lpbiSuggest);
COPY(icds, dxSrc);
COPY(icds, dySrc);
COPY(icds, dxDst);
COPY(icds, dyDst);
icds->hicDecompressor = HIC_32(icds16->hicDecompressor);
*lParam1 = (DWORD)(icds);
*lParam2 = sizeof(ICDRAWSUGGEST);
}
break;
case ICM_DRAW:
{
ICDRAW *icd = HeapAlloc(GetProcessHeap(), 0, sizeof(ICDRAW));
ICDRAW *icd16 = MapSL(*lParam1);
ret = icd16;
COPY(icd, dwFlags);
COPYPTR(icd, lpFormat);
COPYPTR(icd, lpData);
COPY(icd, cbData);
COPY(icd, lTime);
*lParam1 = (DWORD)(icd);
*lParam2 = sizeof(ICDRAW);
}
break;
case ICM_DRAW_START:
case ICM_DRAW_STOP:
break;
default:
FIXME("%d is not yet handled. Expect a crash.\n", msg);
}
return ret;
}
/***********************************************************************
* NE_FixupSegmentPrologs
*
* Fixup exported functions prologs of one segment
*/
static void NE_FixupSegmentPrologs(NE_MODULE *pModule, WORD segnum)
{
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
ET_BUNDLE *bundle;
ET_ENTRY *entry;
WORD dgroup, num_entries, sel = SEL(pSegTable[segnum-1].hSeg);
BYTE *pSeg, *pFunc;
TRACE_(module)("(%d);\n", segnum);
if (pSegTable[segnum-1].flags & NE_SEGFLAGS_DATA)
{
pSegTable[segnum-1].flags |= NE_SEGFLAGS_LOADED;
return;
}
if (!pModule->dgroup) return;
if (!(dgroup = SEL(pSegTable[pModule->dgroup-1].hSeg))) return;
pSeg = MapSL( MAKESEGPTR(sel, 0) );
bundle = (ET_BUNDLE *)((BYTE *)pModule+pModule->entry_table);
do {
TRACE_(module)("num_entries: %d, bundle: %p, next: %04x, pSeg: %p\n", bundle->last - bundle->first, bundle, bundle->next, pSeg);
if (!(num_entries = bundle->last - bundle->first))
return;
entry = (ET_ENTRY *)((BYTE *)bundle+6);
while (num_entries--)
{
/*TRACE_(module)("entry: %p, entry->segnum: %d, entry->offs: %04x\n", entry, entry->segnum, entry->offs);*/
if (entry->segnum == segnum)
{
pFunc = ((BYTE *)pSeg+entry->offs);
TRACE_(module)("pFunc: %p, *(DWORD *)pFunc: %08lx, num_entries: %d\n", pFunc, *(DWORD *)pFunc, num_entries);
if (*(pFunc+2) == 0x90)
{
if (*(WORD *)pFunc == 0x581e) /* push ds, pop ax */
{
TRACE_(module)("patch %04x:%04x -> mov ax, ds\n", sel, entry->offs);
*(WORD *)pFunc = 0xd88c; /* mov ax, ds */
}
if (*(WORD *)pFunc == 0xd88c)
{
if ((entry->flags & 2)) /* public data ? */
{
TRACE_(module)("patch %04x:%04x -> mov ax, dgroup [%04x]\n", sel, entry->offs, dgroup);
*pFunc = 0xb8; /* mov ax, */
*(WORD *)(pFunc+1) = dgroup;
}
else
if ((pModule->flags & NE_FFLAGS_MULTIPLEDATA)
&& (entry->flags & 1)) /* exported ? */
{
TRACE_(module)("patch %04x:%04x -> nop, nop\n", sel, entry->offs);
*(WORD *)pFunc = 0x9090; /* nop, nop */
}
}
}
}
entry++;
}
} while ( (bundle->next)
&& (bundle = ((ET_BUNDLE *)((BYTE *)pModule + bundle->next))) );
}
void WINAPI VXD_Win32s( CONTEXT86 *context )
{
switch (AX_reg(context))
{
case 0x0000: /* Get Version */
/*
* Input: None
*
* Output: EAX: LoWord: Win32s Version (1.30)
* HiWord: VxD Version (200)
*
* EBX: Build (172)
*
* ECX: ??? (1)
*
* EDX: Debugging Flags
*
* EDI: Error Flag
* 0 if OK,
* 1 if VMCPD VxD not found
*/
TRACE("GetVersion()\n");
context->Eax = VXD_WinVersion() | (200 << 16);
context->Ebx = 0;
context->Ecx = 0;
context->Edx = 0;
context->Edi = 0;
/*
* If this is the first time we are called for this process,
* hack the memory image of WIN32S16 so that it doesn't try
* to access the GDT directly ...
*
* The first code segment of WIN32S16 (version 1.30) contains
* an unexported function somewhere between the exported functions
* SetFS and StackLinearToSegmented that tries to find a selector
* in the LDT that maps to the memory image of the LDT itself.
* If it succeeds, it stores this selector into a global variable
* which will be used to speed up execution by using this selector
* to modify the LDT directly instead of using the DPMI calls.
*
* To perform this search of the LDT, this function uses the
* sgdt and sldt instructions to find the linear address of
* the (GDT and then) LDT. While those instructions themselves
* execute without problem, the linear address that sgdt returns
* points (at least under Linux) to the kernel address space, so
* that any subsequent access leads to a segfault.
*
* Fortunately, WIN32S16 still contains as a fallback option the
* mechanism of using DPMI calls to modify LDT selectors instead
* of direct writes to the LDT. Thus we can circumvent the problem
* by simply replacing the first byte of the offending function
* with an 'retf' instruction. This means that the global variable
* supposed to contain the LDT alias selector will remain zero,
* and hence WIN32S16 will fall back to using DPMI calls.
*
* The heuristic we employ to _find_ that function is as follows:
* We search between the addresses of the exported symbols SetFS
* and StackLinearToSegmented for the byte sequence '0F 01 04'
* (this is the opcode of 'sgdt [si]'). We then search backwards
* from this address for the last occurrence of 'CB' (retf) that marks
* the end of the preceeding function. The following byte (which
* should now be the first byte of the function we are looking for)
* will be replaced by 'CB' (retf).
*
* This heuristic works for the retail as well as the debug version
* of Win32s version 1.30. For versions earlier than that this
* hack should not be necessary at all, since the whole mechanism
* ('PERF130') was introduced only in 1.30 to improve the overall
* performance of Win32s.
*/
if (!W32S_offset)
{
HMODULE16 hModule = GetModuleHandle16("win32s16");
SEGPTR func1 = (SEGPTR)GetProcAddress16(hModule, "SetFS");
SEGPTR func2 = (SEGPTR)GetProcAddress16(hModule, "StackLinearToSegmented");
if ( hModule && func1 && func2
&& SELECTOROF(func1) == SELECTOROF(func2))
{
BYTE *start = MapSL(func1);
BYTE *end = MapSL(func2);
BYTE *p, *retv = NULL;
int found = 0;
for (p = start; p < end; p++)
if (*p == 0xCB) found = 0, retv = p;
else if (*p == 0x0F) found = 1;
else if (*p == 0x01 && found == 1) found = 2;
else if (*p == 0x04 && found == 2) { found = 3; break; }
else found = 0;
if (found == 3 && retv)
{
TRACE("PERF130 hack: "
"Replacing byte %02X at offset %04X:%04X\n",
*(retv+1), SELECTOROF(func1),
OFFSETOF(func1) + retv+1-start);
*(retv+1) = (BYTE)0xCB;
}
}
}
/*
* Mark process as Win32s, so that subsequent DPMI calls
* will perform the W32S_APP2WINE/W32S_WINE2APP address shift.
*/
W32S_offset = 0x10000;
break;
case 0x0001: /* Install Exception Handling */
/*
* Input: EBX: Flat address of W32SKRNL Exception Data
*
* ECX: LoWord: Flat Code Selector
* HiWord: Flat Data Selector
*
* EDX: Flat address of W32SKRNL Exception Handler
* (this is equal to W32S_BackTo32 + 0x40)
*
* ESI: SEGPTR KERNEL.HASGPHANDLER
*
* EDI: SEGPTR phCurrentTask (KERNEL.THHOOK + 0x10)
*
* Output: EAX: 0 if OK
*/
TRACE("[0001] EBX=%lx ECX=%lx EDX=%lx ESI=%lx EDI=%lx\n",
context->Ebx, context->Ecx, context->Edx,
context->Esi, context->Edi);
/* FIXME */
context->Eax = 0;
break;
case 0x0002: /* Set Page Access Flags */
/*
* Input: EBX: New access flags
* Bit 2: User Page if set, Supervisor Page if clear
* Bit 1: Read-Write if set, Read-Only if clear
*
* ECX: Size of memory area to change
*
* EDX: Flat start address of memory area
*
* Output: EAX: Size of area changed
*/
TRACE("[0002] EBX=%lx ECX=%lx EDX=%lx\n",
context->Ebx, context->Ecx, context->Edx);
/* FIXME */
context->Eax = context->Ecx;
break;
case 0x0003: /* Get Page Access Flags */
/*
* Input: EDX: Flat address of page to query
*
* Output: EAX: Page access flags
* Bit 2: User Page if set, Supervisor Page if clear
* Bit 1: Read-Write if set, Read-Only if clear
*/
TRACE("[0003] EDX=%lx\n", context->Edx);
/* FIXME */
context->Eax = 6;
break;
case 0x0004: /* Map Module */
/*
* Input: ECX: IMTE (offset in Module Table) of new module
*
* EDX: Flat address of Win32s Module Table
*
* Output: EAX: 0 if OK
*/
if (!context->Edx || CX_reg(context) == 0xFFFF)
{
TRACE("MapModule: Initialization call\n");
context->Eax = 0;
}
else
{
/*
* Structure of a Win32s Module Table Entry:
*/
struct Win32sModule
{
DWORD flags;
DWORD flatBaseAddr;
LPCSTR moduleName;
LPCSTR pathName;
LPCSTR unknown;
LPBYTE baseAddr;
DWORD hModule;
DWORD relocDelta;
};
/*
* Note: This function should set up a demand-paged memory image
* of the given module. Since mmap does not allow file offsets
* not aligned at 1024 bytes, we simply load the image fully
* into memory.
*/
struct Win32sModule *moduleTable =
(struct Win32sModule *)W32S_APP2WINE(context->Edx);
struct Win32sModule *module = moduleTable + context->Ecx;
IMAGE_NT_HEADERS *nt_header = PE_HEADER(module->baseAddr);
IMAGE_SECTION_HEADER *pe_seg = PE_SECTIONS(module->baseAddr);
HFILE image = _lopen(module->pathName, OF_READ);
BOOL error = (image == HFILE_ERROR);
UINT i;
TRACE("MapModule: Loading %s\n", module->pathName);
for (i = 0;
!error && i < nt_header->FileHeader.NumberOfSections;
i++, pe_seg++)
if(!(pe_seg->Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA))
{
DWORD off = pe_seg->PointerToRawData;
DWORD len = pe_seg->SizeOfRawData;
LPBYTE addr = module->baseAddr + pe_seg->VirtualAddress;
TRACE("MapModule: "
"Section %d at %08lx from %08lx len %08lx\n",
i, (DWORD)addr, off, len);
if ( _llseek(image, off, SEEK_SET) != off
|| _lread(image, addr, len) != len)
error = TRUE;
}
_lclose(image);
if (error)
ERR("MapModule: Unable to load %s\n", module->pathName);
else if (module->relocDelta != 0)
{
IMAGE_DATA_DIRECTORY *dir = nt_header->OptionalHeader.DataDirectory
+ IMAGE_DIRECTORY_ENTRY_BASERELOC;
IMAGE_BASE_RELOCATION *r = (IMAGE_BASE_RELOCATION *)
(dir->Size? module->baseAddr + dir->VirtualAddress : 0);
TRACE("MapModule: Reloc delta %08lx\n", module->relocDelta);
while (r && r->VirtualAddress)
{
LPBYTE page = module->baseAddr + r->VirtualAddress;
WORD *TypeOffset = (WORD *)(r + 1);
int count = (r->SizeOfBlock - sizeof(*r)) / sizeof(*TypeOffset);
TRACE("MapModule: %d relocations for page %08lx\n",
count, (DWORD)page);
for(i = 0; i < count; i++)
{
int offset = TypeOffset[i] & 0xFFF;
int type = TypeOffset[i] >> 12;
switch(type)
{
case IMAGE_REL_BASED_ABSOLUTE:
break;
case IMAGE_REL_BASED_HIGH:
*(WORD *)(page+offset) += HIWORD(module->relocDelta);
break;
case IMAGE_REL_BASED_LOW:
*(WORD *)(page+offset) += LOWORD(module->relocDelta);
break;
case IMAGE_REL_BASED_HIGHLOW:
*(DWORD*)(page+offset) += module->relocDelta;
break;
default:
WARN("MapModule: Unsupported fixup type\n");
break;
}
}
r = (IMAGE_BASE_RELOCATION *)((LPBYTE)r + r->SizeOfBlock);
}
}
context->Eax = 0;
RESET_CFLAG(context);
}
break;
case 0x0005: /* UnMap Module */
/*
* Input: EDX: Flat address of module image
*
* Output: EAX: 1 if OK
*/
TRACE("UnMapModule: %lx\n", (DWORD)W32S_APP2WINE(context->Edx));
/* As we didn't map anything, there's nothing to unmap ... */
context->Eax = 1;
break;
case 0x0006: /* VirtualAlloc */
/*
* Input: ECX: Current Process
*
* EDX: Flat address of arguments on stack
*
* DWORD *retv [out] Flat base address of allocated region
* LPVOID base [in] Flat address of region to reserve/commit
* DWORD size [in] Size of region
* DWORD type [in] Type of allocation
* DWORD prot [in] Type of access protection
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
DWORD size = stack[2];
DWORD type = stack[3];
DWORD prot = stack[4];
DWORD result;
TRACE("VirtualAlloc(%lx, %lx, %lx, %lx, %lx)\n",
(DWORD)retv, (DWORD)base, size, type, prot);
if (type & 0x80000000)
{
WARN("VirtualAlloc: strange type %lx\n", type);
type &= 0x7fffffff;
}
if (!base && (type & MEM_COMMIT) && prot == PAGE_READONLY)
{
WARN("VirtualAlloc: NLS hack, allowing write access!\n");
prot = PAGE_READWRITE;
}
result = (DWORD)VirtualAlloc(base, size, type, prot);
if (W32S_WINE2APP(result))
*retv = W32S_WINE2APP(result),
context->Eax = STATUS_SUCCESS;
else
*retv = 0,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x0007: /* VirtualFree */
/*
* Input: ECX: Current Process
*
* EDX: Flat address of arguments on stack
*
* DWORD *retv [out] TRUE if success, FALSE if failure
* LPVOID base [in] Flat address of region
* DWORD size [in] Size of region
* DWORD type [in] Type of operation
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
DWORD size = stack[2];
DWORD type = stack[3];
DWORD result;
TRACE("VirtualFree(%lx, %lx, %lx, %lx)\n",
(DWORD)retv, (DWORD)base, size, type);
result = VirtualFree(base, size, type);
if (result)
*retv = TRUE,
context->Eax = STATUS_SUCCESS;
else
*retv = FALSE,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x0008: /* VirtualProtect */
/*
* Input: ECX: Current Process
*
* EDX: Flat address of arguments on stack
*
* DWORD *retv [out] TRUE if success, FALSE if failure
* LPVOID base [in] Flat address of region
* DWORD size [in] Size of region
* DWORD new_prot [in] Desired access protection
* DWORD *old_prot [out] Previous access protection
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
DWORD size = stack[2];
DWORD new_prot = stack[3];
DWORD *old_prot = (DWORD *)W32S_APP2WINE(stack[4]);
DWORD result;
TRACE("VirtualProtect(%lx, %lx, %lx, %lx, %lx)\n",
(DWORD)retv, (DWORD)base, size, new_prot, (DWORD)old_prot);
result = VirtualProtect(base, size, new_prot, old_prot);
if (result)
*retv = TRUE,
context->Eax = STATUS_SUCCESS;
else
*retv = FALSE,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x0009: /* VirtualQuery */
/*
* Input: ECX: Current Process
*
* EDX: Flat address of arguments on stack
*
* DWORD *retv [out] Nr. bytes returned
* LPVOID base [in] Flat address of region
* LPMEMORY_BASIC_INFORMATION info [out] Info buffer
* DWORD len [in] Size of buffer
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
LPMEMORY_BASIC_INFORMATION info =
(LPMEMORY_BASIC_INFORMATION)W32S_APP2WINE(stack[2]);
DWORD len = stack[3];
DWORD result;
TRACE("VirtualQuery(%lx, %lx, %lx, %lx)\n",
(DWORD)retv, (DWORD)base, (DWORD)info, len);
result = VirtualQuery(base, info, len);
*retv = result;
context->Eax = STATUS_SUCCESS;
}
break;
case 0x000A: /* SetVirtMemProcess */
/*
* Input: ECX: Process Handle
*
* EDX: Flat address of region
*
* Output: EAX: NtStatus
*/
TRACE("[000a] ECX=%lx EDX=%lx\n",
context->Ecx, context->Edx);
/* FIXME */
context->Eax = STATUS_SUCCESS;
break;
case 0x000B: /* ??? some kind of cleanup */
/*
* Input: ECX: Process Handle
*
* Output: EAX: NtStatus
*/
TRACE("[000b] ECX=%lx\n", context->Ecx);
/* FIXME */
context->Eax = STATUS_SUCCESS;
break;
case 0x000C: /* Set Debug Flags */
/*
* Input: EDX: Debug Flags
*
* Output: EDX: Previous Debug Flags
*/
FIXME("[000c] EDX=%lx\n", context->Edx);
/* FIXME */
context->Edx = 0;
break;
case 0x000D: /* NtCreateSection */
/*
* Input: EDX: Flat address of arguments on stack
*
* HANDLE32 *retv [out] Handle of Section created
* DWORD flags1 [in] (?? unknown ??)
* DWORD atom [in] Name of Section to create
* LARGE_INTEGER *size [in] Size of Section
* DWORD protect [in] Access protection
* DWORD flags2 [in] (?? unknown ??)
* HFILE32 hFile [in] Handle of file to map
* DWORD psp [in] (Win32s: PSP that hFile belongs to)
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *) W32S_APP2WINE(context->Edx);
HANDLE *retv = (HANDLE *)W32S_APP2WINE(stack[0]);
DWORD flags1 = stack[1];
DWORD atom = stack[2];
LARGE_INTEGER *size = (LARGE_INTEGER *)W32S_APP2WINE(stack[3]);
DWORD protect = stack[4];
DWORD flags2 = stack[5];
HANDLE hFile = DosFileHandleToWin32Handle(stack[6]);
DWORD psp = stack[7];
HANDLE result = INVALID_HANDLE_VALUE;
char name[128];
TRACE("NtCreateSection(%lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx)\n",
(DWORD)retv, flags1, atom, (DWORD)size, protect, flags2,
(DWORD)hFile, psp);
if (!atom || GlobalGetAtomNameA(atom, name, sizeof(name)))
{
TRACE("NtCreateSection: name=%s\n", atom? name : NULL);
result = CreateFileMappingA(hFile, NULL, protect,
size? size->s.HighPart : 0,
size? size->s.LowPart : 0,
atom? name : NULL);
}
if (result == INVALID_HANDLE_VALUE)
WARN("NtCreateSection: failed!\n");
else
TRACE("NtCreateSection: returned %lx\n", (DWORD)result);
if (result != INVALID_HANDLE_VALUE)
*retv = result,
context->Eax = STATUS_SUCCESS;
else
*retv = result,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x000E: /* NtOpenSection */
/*
* Input: EDX: Flat address of arguments on stack
*
* HANDLE32 *retv [out] Handle of Section opened
* DWORD protect [in] Access protection
* DWORD atom [in] Name of Section to create
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
HANDLE *retv = (HANDLE *)W32S_APP2WINE(stack[0]);
DWORD protect = stack[1];
DWORD atom = stack[2];
HANDLE result = INVALID_HANDLE_VALUE;
char name[128];
TRACE("NtOpenSection(%lx, %lx, %lx)\n",
(DWORD)retv, protect, atom);
if (atom && GlobalGetAtomNameA(atom, name, sizeof(name)))
{
TRACE("NtOpenSection: name=%s\n", name);
result = OpenFileMappingA(protect, FALSE, name);
}
if (result == INVALID_HANDLE_VALUE)
WARN("NtOpenSection: failed!\n");
else
TRACE("NtOpenSection: returned %lx\n", (DWORD)result);
if (result != INVALID_HANDLE_VALUE)
*retv = result,
context->Eax = STATUS_SUCCESS;
else
*retv = result,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x000F: /* NtCloseSection */
/*
* Input: EDX: Flat address of arguments on stack
*
* HANDLE32 handle [in] Handle of Section to close
* DWORD *id [out] Unique ID (?? unclear ??)
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
HANDLE handle = stack[0];
DWORD *id = (DWORD *)W32S_APP2WINE(stack[1]);
TRACE("NtCloseSection(%lx, %lx)\n", (DWORD)handle, (DWORD)id);
CloseHandle(handle);
if (id) *id = 0; /* FIXME */
context->Eax = STATUS_SUCCESS;
}
break;
case 0x0010: /* NtDupSection */
/*
* Input: EDX: Flat address of arguments on stack
*
* HANDLE32 handle [in] Handle of Section to duplicate
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
HANDLE handle = stack[0];
HANDLE new_handle;
TRACE("NtDupSection(%lx)\n", (DWORD)handle);
DuplicateHandle( GetCurrentProcess(), handle,
GetCurrentProcess(), &new_handle,
0, FALSE, DUPLICATE_SAME_ACCESS );
context->Eax = STATUS_SUCCESS;
}
break;
case 0x0011: /* NtMapViewOfSection */
/*
* Input: EDX: Flat address of arguments on stack
*
* HANDLE32 SectionHandle [in] Section to be mapped
* DWORD ProcessHandle [in] Process to be mapped into
* DWORD * BaseAddress [in/out] Address to be mapped at
* DWORD ZeroBits [in] (?? unclear ??)
* DWORD CommitSize [in] (?? unclear ??)
* LARGE_INTEGER *SectionOffset [in] Offset within section
* DWORD * ViewSize [in] Size of view
* DWORD InheritDisposition [in] (?? unclear ??)
* DWORD AllocationType [in] (?? unclear ??)
* DWORD Protect [in] Access protection
*
* Output: EAX: NtStatus
*/
{
DWORD * stack = (DWORD *)W32S_APP2WINE(context->Edx);
HANDLE SectionHandle = stack[0];
DWORD ProcessHandle = stack[1]; /* ignored */
DWORD * BaseAddress = (DWORD *)W32S_APP2WINE(stack[2]);
DWORD ZeroBits = stack[3];
DWORD CommitSize = stack[4];
LARGE_INTEGER *SectionOffset = (LARGE_INTEGER *)W32S_APP2WINE(stack[5]);
DWORD * ViewSize = (DWORD *)W32S_APP2WINE(stack[6]);
DWORD InheritDisposition = stack[7];
DWORD AllocationType = stack[8];
DWORD Protect = stack[9];
LPBYTE address = (LPBYTE)(BaseAddress?
W32S_APP2WINE(*BaseAddress) : 0);
DWORD access = 0, result;
switch (Protect & ~(PAGE_GUARD|PAGE_NOCACHE))
{
case PAGE_READONLY: access = FILE_MAP_READ; break;
case PAGE_READWRITE: access = FILE_MAP_WRITE; break;
case PAGE_WRITECOPY: access = FILE_MAP_COPY; break;
case PAGE_EXECUTE_READ: access = FILE_MAP_READ; break;
case PAGE_EXECUTE_READWRITE: access = FILE_MAP_WRITE; break;
case PAGE_EXECUTE_WRITECOPY: access = FILE_MAP_COPY; break;
}
TRACE("NtMapViewOfSection"
"(%lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx, %lx)\n",
(DWORD)SectionHandle, ProcessHandle, (DWORD)BaseAddress,
ZeroBits, CommitSize, (DWORD)SectionOffset, (DWORD)ViewSize,
InheritDisposition, AllocationType, Protect);
TRACE("NtMapViewOfSection: "
"base=%lx, offset=%lx, size=%lx, access=%lx\n",
(DWORD)address, SectionOffset? SectionOffset->s.LowPart : 0,
ViewSize? *ViewSize : 0, access);
result = (DWORD)MapViewOfFileEx(SectionHandle, access,
SectionOffset? SectionOffset->s.HighPart : 0,
SectionOffset? SectionOffset->s.LowPart : 0,
ViewSize? *ViewSize : 0, address);
TRACE("NtMapViewOfSection: result=%lx\n", result);
if (W32S_WINE2APP(result))
{
if (BaseAddress) *BaseAddress = W32S_WINE2APP(result);
context->Eax = STATUS_SUCCESS;
}
else
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x0012: /* NtUnmapViewOfSection */
/*
* Input: EDX: Flat address of arguments on stack
*
* DWORD ProcessHandle [in] Process (defining address space)
* LPBYTE BaseAddress [in] Base address of view to be unmapped
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
DWORD ProcessHandle = stack[0]; /* ignored */
LPBYTE BaseAddress = (LPBYTE)W32S_APP2WINE(stack[1]);
TRACE("NtUnmapViewOfSection(%lx, %lx)\n",
ProcessHandle, (DWORD)BaseAddress);
UnmapViewOfFile(BaseAddress);
context->Eax = STATUS_SUCCESS;
}
break;
case 0x0013: /* NtFlushVirtualMemory */
/*
* Input: EDX: Flat address of arguments on stack
*
* DWORD ProcessHandle [in] Process (defining address space)
* LPBYTE *BaseAddress [in?] Base address of range to be flushed
* DWORD *ViewSize [in?] Number of bytes to be flushed
* DWORD *unknown [???] (?? unknown ??)
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
DWORD ProcessHandle = stack[0]; /* ignored */
DWORD *BaseAddress = (DWORD *)W32S_APP2WINE(stack[1]);
DWORD *ViewSize = (DWORD *)W32S_APP2WINE(stack[2]);
DWORD *unknown = (DWORD *)W32S_APP2WINE(stack[3]);
LPBYTE address = (LPBYTE)(BaseAddress? W32S_APP2WINE(*BaseAddress) : 0);
DWORD size = ViewSize? *ViewSize : 0;
TRACE("NtFlushVirtualMemory(%lx, %lx, %lx, %lx)\n",
ProcessHandle, (DWORD)BaseAddress, (DWORD)ViewSize,
(DWORD)unknown);
TRACE("NtFlushVirtualMemory: base=%lx, size=%lx\n",
(DWORD)address, size);
FlushViewOfFile(address, size);
context->Eax = STATUS_SUCCESS;
}
break;
case 0x0014: /* Get/Set Debug Registers */
/*
* Input: ECX: 0 if Get, 1 if Set
*
* EDX: Get: Flat address of buffer to receive values of
* debug registers DR0 .. DR7
* Set: Flat address of buffer containing values of
* debug registers DR0 .. DR7 to be set
* Output: None
*/
FIXME("[0014] ECX=%lx EDX=%lx\n",
context->Ecx, context->Edx);
/* FIXME */
break;
case 0x0015: /* Set Coprocessor Emulation Flag */
/*
* Input: EDX: 0 to deactivate, 1 to activate coprocessor emulation
*
* Output: None
*/
TRACE("[0015] EDX=%lx\n", context->Edx);
/* We don't care, as we always have a coprocessor anyway */
break;
case 0x0016: /* Init Win32S VxD PSP */
/*
* If called to query required PSP size:
*
* Input: EBX: 0
* Output: EDX: Required size of Win32s VxD PSP
*
* If called to initialize allocated PSP:
*
* Input: EBX: LoWord: Selector of Win32s VxD PSP
* HiWord: Paragraph of Win32s VxD PSP (DOSMEM)
* Output: None
*/
if (context->Ebx == 0)
context->Edx = 0x80;
else
{
PDB16 *psp = MapSL( MAKESEGPTR( BX_reg(context), 0 ));
psp->nbFiles = 32;
psp->fileHandlesPtr = MAKELONG(HIWORD(context->Ebx), 0x5c);
memset((LPBYTE)psp + 0x5c, '\xFF', 32);
}
break;
case 0x0017: /* Set Break Point */
/*
* Input: EBX: Offset of Break Point
* CX: Selector of Break Point
*
* Output: None
*/
FIXME("[0017] EBX=%lx CX=%x\n",
context->Ebx, CX_reg(context));
/* FIXME */
break;
case 0x0018: /* VirtualLock */
/*
* Input: ECX: Current Process
*
* EDX: Flat address of arguments on stack
*
* DWORD *retv [out] TRUE if success, FALSE if failure
* LPVOID base [in] Flat address of range to lock
* DWORD size [in] Size of range
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
DWORD size = stack[2];
DWORD result;
TRACE("VirtualLock(%lx, %lx, %lx)\n",
(DWORD)retv, (DWORD)base, size);
result = VirtualLock(base, size);
if (result)
*retv = TRUE,
context->Eax = STATUS_SUCCESS;
else
*retv = FALSE,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x0019: /* VirtualUnlock */
/*
* Input: ECX: Current Process
*
* EDX: Flat address of arguments on stack
*
* DWORD *retv [out] TRUE if success, FALSE if failure
* LPVOID base [in] Flat address of range to unlock
* DWORD size [in] Size of range
*
* Output: EAX: NtStatus
*/
{
DWORD *stack = (DWORD *)W32S_APP2WINE(context->Edx);
DWORD *retv = (DWORD *)W32S_APP2WINE(stack[0]);
LPVOID base = (LPVOID) W32S_APP2WINE(stack[1]);
DWORD size = stack[2];
DWORD result;
TRACE("VirtualUnlock(%lx, %lx, %lx)\n",
(DWORD)retv, (DWORD)base, size);
result = VirtualUnlock(base, size);
if (result)
*retv = TRUE,
context->Eax = STATUS_SUCCESS;
else
*retv = FALSE,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x001A: /* KGetSystemInfo */
/*
* Input: None
*
* Output: ECX: Start of sparse memory arena
* EDX: End of sparse memory arena
*/
TRACE("KGetSystemInfo()\n");
/*
* Note: Win32s reserves 0GB - 2GB for Win 3.1 and uses 2GB - 4GB as
* sparse memory arena. We do it the other way around, since
* we have to reserve 3GB - 4GB for Linux, and thus use
* 0GB - 3GB as sparse memory arena.
*
* FIXME: What about other OSes ?
*/
context->Ecx = W32S_WINE2APP(0x00000000);
context->Edx = W32S_WINE2APP(0xbfffffff);
break;
case 0x001B: /* KGlobalMemStat */
/*
* Input: ESI: Flat address of buffer to receive memory info
*
* Output: None
*/
{
struct Win32sMemoryInfo
{
DWORD DIPhys_Count; /* Total physical pages */
DWORD DIFree_Count; /* Free physical pages */
DWORD DILin_Total_Count; /* Total virtual pages (private arena) */
DWORD DILin_Total_Free; /* Free virtual pages (private arena) */
DWORD SparseTotal; /* Total size of sparse arena (bytes ?) */
DWORD SparseFree; /* Free size of sparse arena (bytes ?) */
};
struct Win32sMemoryInfo *info =
(struct Win32sMemoryInfo *)W32S_APP2WINE(context->Esi);
FIXME("KGlobalMemStat(%lx)\n", (DWORD)info);
/* FIXME */
}
break;
case 0x001C: /* Enable/Disable Exceptions */
/*
* Input: ECX: 0 to disable, 1 to enable exception handling
*
* Output: None
*/
TRACE("[001c] ECX=%lx\n", context->Ecx);
/* FIXME */
break;
case 0x001D: /* VirtualAlloc called from 16-bit code */
/*
* Input: EDX: Segmented address of arguments on stack
*
* LPVOID base [in] Flat address of region to reserve/commit
* DWORD size [in] Size of region
* DWORD type [in] Type of allocation
* DWORD prot [in] Type of access protection
*
* Output: EAX: NtStatus
* EDX: Flat base address of allocated region
*/
{
DWORD *stack = MapSL( MAKESEGPTR( LOWORD(context->Edx), HIWORD(context->Edx) ));
LPVOID base = (LPVOID)W32S_APP2WINE(stack[0]);
DWORD size = stack[1];
DWORD type = stack[2];
DWORD prot = stack[3];
DWORD result;
TRACE("VirtualAlloc16(%lx, %lx, %lx, %lx)\n",
(DWORD)base, size, type, prot);
if (type & 0x80000000)
{
WARN("VirtualAlloc16: strange type %lx\n", type);
type &= 0x7fffffff;
}
result = (DWORD)VirtualAlloc(base, size, type, prot);
if (W32S_WINE2APP(result))
context->Edx = W32S_WINE2APP(result),
context->Eax = STATUS_SUCCESS;
else
context->Edx = 0,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
TRACE("VirtualAlloc16: returning base %lx\n", context->Edx);
}
break;
case 0x001E: /* VirtualFree called from 16-bit code */
/*
* Input: EDX: Segmented address of arguments on stack
*
* LPVOID base [in] Flat address of region
* DWORD size [in] Size of region
* DWORD type [in] Type of operation
*
* Output: EAX: NtStatus
* EDX: TRUE if success, FALSE if failure
*/
{
DWORD *stack = MapSL( MAKESEGPTR( LOWORD(context->Edx), HIWORD(context->Edx) ));
LPVOID base = (LPVOID)W32S_APP2WINE(stack[0]);
DWORD size = stack[1];
DWORD type = stack[2];
DWORD result;
TRACE("VirtualFree16(%lx, %lx, %lx)\n",
(DWORD)base, size, type);
result = VirtualFree(base, size, type);
if (result)
context->Edx = TRUE,
context->Eax = STATUS_SUCCESS;
else
context->Edx = FALSE,
context->Eax = STATUS_NO_MEMORY; /* FIXME */
}
break;
case 0x001F: /* FWorkingSetSize */
/*
* Input: EDX: 0 if Get, 1 if Set
*
* ECX: Get: Buffer to receive Working Set Size
* Set: Buffer containing Working Set Size
*
* Output: NtStatus
*/
{
DWORD *ptr = (DWORD *)W32S_APP2WINE(context->Ecx);
BOOL set = context->Edx;
TRACE("FWorkingSetSize(%lx, %lx)\n", (DWORD)ptr, (DWORD)set);
if (set)
/* We do it differently ... */;
else
*ptr = 0x100;
context->Eax = STATUS_SUCCESS;
}
break;
default:
VXD_BARF( context, "W32S" );
}
/***********************************************************************
* NE_LoadSegment
*/
BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
{
SEGTABLEENTRY *pSegTable, *pSeg;
WORD *pModuleTable;
WORD count, i, offset, next_offset;
HMODULE16 module;
FARPROC16 address = 0;
HFILE hf;
DWORD res;
struct relocation_entry_s *rep, *reloc_entries;
char *func_name;
int size;
char* mem;
char buffer[256];
int ordinal, additive;
unsigned short *sp;
pSegTable = NE_SEG_TABLE( pModule );
pSeg = pSegTable + segnum - 1;
if (pSeg->flags & NE_SEGFLAGS_LOADED)
{
/* self-loader ? -> already loaded it */
if (pModule->flags & NE_FFLAGS_SELFLOAD)
return TRUE;
/* leave, except for DGROUP, as this may be the second instance */
if (segnum != pModule->dgroup)
return TRUE;
}
if (!pSeg->filepos) return TRUE; /* No file image, just return */
pModuleTable = NE_MODULE_TABLE( pModule );
hf = NE_OpenFile( pModule );
TRACE_(module)("Loading segment %d, hSeg=%04x, flags=%04x\n",
segnum, pSeg->hSeg, pSeg->flags );
SetFilePointer( hf, pSeg->filepos << pModule->alignment, NULL, SEEK_SET );
if (pSeg->size) size = pSeg->size;
else size = pSeg->minsize ? pSeg->minsize : 0x10000;
mem = GlobalLock16(pSeg->hSeg);
if (pModule->flags & NE_FFLAGS_SELFLOAD && segnum > 1)
{
/* Implement self-loading segments */
SELFLOADHEADER *selfloadheader;
DWORD oldstack;
HANDLE hFile32;
HFILE16 hFile16;
selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg),0) );
oldstack = NtCurrentTeb()->WOW32Reserved;
NtCurrentTeb()->WOW32Reserved = MAKESEGPTR(pModule->self_loading_sel,
0xff00 - sizeof(STACK16FRAME));
TRACE_(dll)("CallLoadAppSegProc(hmodule=0x%04x,hf=0x%04x,segnum=%d\n",
pModule->self,hf,segnum );
DuplicateHandle( GetCurrentProcess(), hf, GetCurrentProcess(), &hFile32,
0, FALSE, DUPLICATE_SAME_ACCESS );
hFile16 = Win32HandleToDosFileHandle( hFile32 );
pSeg->hSeg = NE_CallTo16_word_www( selfloadheader->LoadAppSeg,
pModule->self, hFile16, segnum );
TRACE_(dll)("Ret CallLoadAppSegProc: hSeg = 0x%04x\n", pSeg->hSeg);
_lclose16( hFile16 );
NtCurrentTeb()->WOW32Reserved = oldstack;
}
else if (!(pSeg->flags & NE_SEGFLAGS_ITERATED))
ReadFile(hf, mem, size, &res, NULL);
else {
/*
The following bit of code for "iterated segments" was written without
any documentation on the format of these segments. It seems to work,
but may be missing something. If you have any doc please either send
it to me or fix the code yourself. [email protected]
*/
char* buff = HeapAlloc(GetProcessHeap(), 0, size);
char* curr = buff;
if(buff == NULL) {
WARN_(dll)("Memory exausted!");
return FALSE;
}
ReadFile(hf, buff, size, &res, NULL);
while(curr < buff + size) {
unsigned int rept = *((short*) curr);
curr = (char *)(((short*) curr) + 1);
unsigned int len = *((short*) curr);
curr = (char *)(((short*) curr) + 1);
for(; rept > 0; rept--) {
char* bytes = curr;
unsigned int byte;
for(byte = 0; byte < len; byte++)
*mem++ = *bytes++;
}
curr += len;
}
HeapFree(GetProcessHeap(), 0, buff);
}
pSeg->flags |= NE_SEGFLAGS_LOADED;
/* Perform exported function prolog fixups */
NE_FixupSegmentPrologs( pModule, segnum );
if (!(pSeg->flags & NE_SEGFLAGS_RELOC_DATA))
return TRUE; /* No relocation data, we are done */
ReadFile(hf, &count, sizeof(count), &res, NULL);
if (!count) return TRUE;
TRACE_(fixup)("Fixups for %.*s, segment %d, hSeg %04x\n",
*((BYTE *)pModule + pModule->name_table),
(char *)pModule + pModule->name_table + 1,
segnum, pSeg->hSeg );
TRACE_(segment)("Fixups for %.*s, segment %d, hSeg %04x\n",
*((BYTE *)pModule + pModule->name_table),
(char *)pModule + pModule->name_table + 1,
segnum, pSeg->hSeg );
reloc_entries = (struct relocation_entry_s *)HeapAlloc(GetProcessHeap(), 0, count * sizeof(struct relocation_entry_s));
if(reloc_entries == NULL) {
WARN_(fixup)("Not enough memory for relocation entries!");
return FALSE;
}
if (!ReadFile( hf, reloc_entries, count * sizeof(struct relocation_entry_s), &res, NULL) ||
(res != count * sizeof(struct relocation_entry_s)))
{
WARN_(fixup)("Unable to read relocation information\n" );
return FALSE;
}
/*
* Go through the relocation table one entry at a time.
*/
rep = reloc_entries;
for (i = 0; i < count; i++, rep++)
{
/*
* Get the target address corresponding to this entry.
*/
/* If additive, there is no target chain list. Instead, add source
and target */
additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
rep->relocation_type &= 0x3;
switch (rep->relocation_type)
{
case NE_RELTYPE_ORDINAL:
module = pModuleTable[rep->target1-1];
ordinal = rep->target2;
address = NE_GetEntryPoint( module, ordinal );
if (!address)
{
NE_MODULE *pTarget = NE_GetPtr( module );
if (!pTarget)
WARN_(module)("Module not found: %04x, reference %d of module %*.*s\n",
module, rep->target1,
*((BYTE *)pModule + pModule->name_table),
*((BYTE *)pModule + pModule->name_table),
(char *)pModule + pModule->name_table + 1 );
else
{
ERR_(fixup)("No implementation for %.*s.%d, setting to 0xdeadbeef\n",
*((BYTE *)pTarget + pTarget->name_table),
(char *)pTarget + pTarget->name_table + 1,
ordinal );
address = (FARPROC16)0xdeadbeef;
}
}
if (TRACE_ON(fixup))
{
NE_MODULE *pTarget = NE_GetPtr( module );
TRACE_(fixup)("%d: %.*s.%d=%04x:%04x %s\n", i + 1,
*((BYTE *)pTarget + pTarget->name_table),
(char *)pTarget + pTarget->name_table + 1,
ordinal, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
}
break;
case NE_RELTYPE_NAME:
module = pModuleTable[rep->target1-1];
func_name = (char *)pModule + pModule->import_table + rep->target2;
memcpy( buffer, func_name+1, *func_name );
buffer[(BYTE)*func_name] = '\0';
func_name = buffer;
ordinal = NE_GetOrdinal( module, func_name );
address = NE_GetEntryPoint( module, ordinal );
if (ERR_ON(fixup) && !address)
{
NE_MODULE *pTarget = NE_GetPtr( module );
ERR_(fixup)("No implementation for %.*s.%s, setting to 0xdeadbeef\n",
*((BYTE *)pTarget + pTarget->name_table),
(char *)pTarget + pTarget->name_table + 1, func_name );
}
if (!address) address = (FARPROC16) 0xdeadbeef;
if (TRACE_ON(fixup))
{
NE_MODULE *pTarget = NE_GetPtr( module );
TRACE_(fixup)("%d: %.*s.%s=%04x:%04x %s\n", i + 1,
*((BYTE *)pTarget + pTarget->name_table),
(char *)pTarget + pTarget->name_table + 1,
func_name, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
}
break;
case NE_RELTYPE_INTERNAL:
if ((rep->target1 & 0xff) == 0xff)
{
address = NE_GetEntryPoint( pModule->self, rep->target2 );
}
else
{
address = (FARPROC16)MAKESEGPTR( SEL(pSegTable[rep->target1-1].hSeg), rep->target2 );
}
TRACE_(fixup)("%d: %04x:%04x %s\n",
i + 1, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
break;
case NE_RELTYPE_OSFIXUP:
/* Relocation type 7:
*
* These appear to be used as fixups for the Windows
* floating point emulator. Let's just ignore them and
* try to use the hardware floating point. Linux should
* successfully emulate the coprocessor if it doesn't
* exist.
*/
TRACE_(fixup)("%d: TYPE %d, OFFSET %04x, TARGET %04x %04x %s\n",
i + 1, rep->relocation_type, rep->offset,
rep->target1, rep->target2,
NE_GetRelocAddrName( rep->address_type, additive ) );
continue;
}
offset = rep->offset;
/* Apparently, high bit of address_type is sometimes set; */
/* we ignore it for now */
if (rep->address_type > NE_RADDR_OFFSET32)
{
char module[10];
GetModuleName16( pModule->self, module, sizeof(module) );
ERR_(fixup)("WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
module, rep->address_type );
}
if (additive)
{
sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
TRACE_(fixup)(" %04x:%04x\n", offset, *sp );
switch (rep->address_type & 0x7f)
{
case NE_RADDR_LOWBYTE:
*(BYTE *)sp += LOBYTE((int)address);
break;
case NE_RADDR_OFFSET16:
*sp += LOWORD(address);
break;
case NE_RADDR_POINTER32:
*sp += LOWORD(address);
*(sp+1) = HIWORD(address);
break;
case NE_RADDR_SELECTOR:
/* Borland creates additive records with offset zero. Strange, but OK */
if (*sp)
ERR_(fixup)("Additive selector to %04x.Please report\n",*sp);
else
*sp = HIWORD(address);
break;
default:
goto unknown;
}
}
else /* non-additive fixup */
{
do
{
sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
next_offset = *sp;
TRACE_(fixup)(" %04x:%04x\n", offset, *sp );
switch (rep->address_type & 0x7f)
{
case NE_RADDR_LOWBYTE:
*(BYTE *)sp = LOBYTE((int)address);
break;
case NE_RADDR_OFFSET16:
*sp = LOWORD(address);
break;
case NE_RADDR_POINTER32:
*(FARPROC16 *)sp = address;
break;
case NE_RADDR_SELECTOR:
*sp = SELECTOROF(address);
break;
default:
goto unknown;
}
if (next_offset == offset) break; /* avoid infinite loop */
if (next_offset >= GlobalSize16(pSeg->hSeg)) break;
offset = next_offset;
} while (offset != 0xffff);
}
}
HeapFree(GetProcessHeap(), 0, reloc_entries);
return TRUE;
unknown:
WARN_(fixup)("WARNING: %d: unknown ADDR TYPE %d, "
"TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
i + 1, rep->address_type, rep->relocation_type,
rep->offset, rep->target1, rep->target2);
HeapFree(GetProcessHeap(), 0, reloc_entries);
return FALSE;
}
/***********************************************************************
* apply_relocations
*
* Apply relocations to a segment. Helper for NE_LoadSegment.
*/
static inline BOOL apply_relocations( NE_MODULE *pModule, const struct relocation_entry_s *rep,
int count, int segnum )
{
BYTE *func_name;
char buffer[256];
int i, ordinal;
WORD offset, *sp;
HMODULE16 module;
FARPROC16 address = 0;
HMODULE16 *pModuleTable = (HMODULE16 *)((char *)pModule + pModule->ne_modtab);
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
SEGTABLEENTRY *pSeg = pSegTable + segnum - 1;
/*
* Go through the relocation table one entry at a time.
*/
for (i = 0; i < count; i++, rep++)
{
/*
* Get the target address corresponding to this entry.
*/
/* If additive, there is no target chain list. Instead, add source
and target */
int additive = rep->relocation_type & NE_RELFLAG_ADDITIVE;
switch (rep->relocation_type & 3)
{
case NE_RELTYPE_ORDINAL:
module = pModuleTable[rep->target1-1];
ordinal = rep->target2;
address = NE_GetEntryPoint( module, ordinal );
if (!address)
{
NE_MODULE *pTarget = NE_GetPtr( module );
if (!pTarget)
WARN_(module)("Module not found: %04x, reference %d of module %*.*s\n",
module, rep->target1,
*((BYTE *)pModule + pModule->ne_restab),
*((BYTE *)pModule + pModule->ne_restab),
(char *)pModule + pModule->ne_restab + 1 );
else
{
ERR("No implementation for %.*s.%d, setting to 0xdeadbeef\n",
*((BYTE *)pTarget + pTarget->ne_restab),
(char *)pTarget + pTarget->ne_restab + 1,
ordinal );
address = (FARPROC16)0xdeadbeef;
}
}
if (TRACE_ON(fixup))
{
NE_MODULE *pTarget = NE_GetPtr( module );
TRACE("%d: %.*s.%d=%04x:%04x %s\n", i + 1,
*((BYTE *)pTarget + pTarget->ne_restab),
(char *)pTarget + pTarget->ne_restab + 1,
ordinal, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
}
break;
case NE_RELTYPE_NAME:
module = pModuleTable[rep->target1-1];
func_name = (BYTE *)pModule + pModule->ne_imptab + rep->target2;
memcpy( buffer, func_name+1, *func_name );
buffer[*func_name] = '\0';
ordinal = NE_GetOrdinal( module, buffer );
address = NE_GetEntryPoint( module, ordinal );
if (ERR_ON(fixup) && !address)
{
NE_MODULE *pTarget = NE_GetPtr( module );
ERR("No implementation for %.*s.%s, setting to 0xdeadbeef\n",
*((BYTE *)pTarget + pTarget->ne_restab),
(char *)pTarget + pTarget->ne_restab + 1, buffer );
}
if (!address) address = (FARPROC16) 0xdeadbeef;
if (TRACE_ON(fixup))
{
NE_MODULE *pTarget = NE_GetPtr( module );
TRACE("%d: %.*s.%s=%04x:%04x %s\n", i + 1,
*((BYTE *)pTarget + pTarget->ne_restab),
(char *)pTarget + pTarget->ne_restab + 1,
buffer, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
}
break;
case NE_RELTYPE_INTERNAL:
if ((rep->target1 & 0xff) == 0xff)
{
address = NE_GetEntryPoint( pModule->self, rep->target2 );
}
else
{
address = (FARPROC16)MAKESEGPTR( SEL(pSegTable[rep->target1-1].hSeg), rep->target2 );
}
TRACE("%d: %04x:%04x %s\n",
i + 1, HIWORD(address), LOWORD(address),
NE_GetRelocAddrName( rep->address_type, additive ) );
break;
case NE_RELTYPE_OSFIXUP:
/* Relocation type 7:
*
* These appear to be used as fixups for the Windows
* floating point emulator. Let's just ignore them and
* try to use the hardware floating point. Linux should
* successfully emulate the coprocessor if it doesn't
* exist.
*/
TRACE("%d: TYPE %d, OFFSET %04x, TARGET %04x %04x %s\n",
i + 1, rep->relocation_type, rep->offset,
rep->target1, rep->target2,
NE_GetRelocAddrName( rep->address_type, additive ) );
continue;
}
offset = rep->offset;
/* Apparently, high bit of address_type is sometimes set; */
/* we ignore it for now */
if (rep->address_type > NE_RADDR_OFFSET32)
{
char module[10];
GetModuleName16( pModule->self, module, sizeof(module) );
ERR("WARNING: module %s: unknown reloc addr type = 0x%02x. Please report.\n",
module, rep->address_type );
}
if (additive)
{
sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
TRACE(" %04x:%04x\n", offset, *sp );
switch (rep->address_type & 0x7f)
{
case NE_RADDR_LOWBYTE:
*(BYTE *)sp += LOBYTE((int)address);
break;
case NE_RADDR_OFFSET16:
*sp += LOWORD(address);
break;
case NE_RADDR_POINTER32:
*sp += LOWORD(address);
*(sp+1) = HIWORD(address);
break;
case NE_RADDR_SELECTOR:
/* Borland creates additive records with offset zero. Strange, but OK */
if (*sp)
ERR("Additive selector to %04x.Please report\n",*sp);
else
*sp = HIWORD(address);
break;
default:
goto unknown;
}
}
else /* non-additive fixup */
{
do
{
WORD next_offset;
sp = MapSL( MAKESEGPTR( SEL(pSeg->hSeg), offset ) );
next_offset = *sp;
TRACE(" %04x:%04x\n", offset, *sp );
switch (rep->address_type & 0x7f)
{
case NE_RADDR_LOWBYTE:
*(BYTE *)sp = LOBYTE((int)address);
break;
case NE_RADDR_OFFSET16:
*sp = LOWORD(address);
break;
case NE_RADDR_POINTER32:
*(FARPROC16 *)sp = address;
break;
case NE_RADDR_SELECTOR:
*sp = SELECTOROF(address);
break;
default:
goto unknown;
}
if (next_offset == offset) break; /* avoid infinite loop */
if (next_offset >= GlobalSize16(pSeg->hSeg)) break;
offset = next_offset;
} while (offset != 0xffff);
}
}
return TRUE;
unknown:
WARN("WARNING: %d: unknown ADDR TYPE %d, "
"TYPE %d, OFFSET %04x, TARGET %04x %04x\n",
i + 1, rep->address_type, rep->relocation_type,
rep->offset, rep->target1, rep->target2);
return FALSE;
}
FARPROC16
SNOOP16_GetProcAddress16(HMODULE16 hmod,DWORD ordinal,FARPROC16 origfun) {
SNOOP16_DLL *dll = firstdll;
SNOOP16_FUN *fun;
NE_MODULE *pModule = NE_GetPtr(hmod);
unsigned char *cpnt;
char name[200];
if (!TRACE_ON(snoop) || !pModule || !HIWORD(origfun))
return origfun;
if (!*(LPBYTE)MapSL((SEGPTR)origfun)) /* 0x00 is an impossible opcode, possible dataref. */
return origfun;
while (dll) {
if (hmod == dll->hmod)
break;
dll=dll->next;
}
if (!dll) /* probably internal */
return origfun;
if (ordinal>65535/sizeof(SNOOP16_FUN))
return origfun;
fun = dll->funs+ordinal;
/* already done? */
fun->lcall = 0x9a;
fun->snr = MAKELONG(0,xsnr);
fun->origfun = origfun;
if (fun->name)
return (FARPROC16)(SEGPTR)MAKELONG(((char*)fun-(char*)dll->funs),dll->funhandle);
cpnt = (unsigned char *)pModule + pModule->ne_restab;
while (*cpnt) {
cpnt += *cpnt + 1 + sizeof(WORD);
if (*(WORD*)(cpnt+*cpnt+1) == ordinal) {
sprintf(name,"%.*s",*cpnt,cpnt+1);
break;
}
}
/* Now search the non-resident names table */
if (!*cpnt && pModule->nrname_handle) {
cpnt = (unsigned char *)GlobalLock16( pModule->nrname_handle );
while (*cpnt) {
cpnt += *cpnt + 1 + sizeof(WORD);
if (*(WORD*)(cpnt+*cpnt+1) == ordinal) {
sprintf(name,"%.*s",*cpnt,cpnt+1);
break;
}
}
}
if (*cpnt)
{
fun->name = HeapAlloc(GetProcessHeap(),0,strlen(name)+1);
strcpy( fun->name, name );
}
else
fun->name = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,1); /* empty string */
if (!SNOOP16_ShowDebugmsgSnoop(dll->name, ordinal, fun->name))
return origfun;
/* more magic. do not try to snoop thunk data entries (MMSYSTEM) */
if (strchr(fun->name,'_')) {
char *s=strchr(fun->name,'_');
if (!strncasecmp(s,"_thunkdata",10)) {
HeapFree(GetProcessHeap(),0,fun->name);
fun->name = NULL;
return origfun;
}
}
fun->lcall = 0x9a;
fun->snr = MAKELONG(0,xsnr);
fun->origfun = origfun;
fun->nrofargs = -1;
return (FARPROC16)(SEGPTR)MAKELONG(((char*)fun-(char*)dll->funs),dll->funhandle);
}
/***********************************************************************
* NE_LoadSegment
*/
BOOL NE_LoadSegment( NE_MODULE *pModule, WORD segnum )
{
WORD count;
DWORD pos;
const struct relocation_entry_s *rep;
int size;
SEGTABLEENTRY *pSegTable = NE_SEG_TABLE( pModule );
SEGTABLEENTRY *pSeg = pSegTable + segnum - 1;
if (pSeg->flags & NE_SEGFLAGS_LOADED)
{
/* self-loader ? -> already loaded it */
if (pModule->ne_flags & NE_FFLAGS_SELFLOAD)
return TRUE;
/* leave, except for DGROUP, as this may be the second instance */
if (segnum != pModule->ne_autodata)
return TRUE;
}
if (!pSeg->filepos) return TRUE; /* No file image, just return */
TRACE_(module)("Loading segment %d, hSeg=%04x, flags=%04x\n",
segnum, pSeg->hSeg, pSeg->flags );
pos = pSeg->filepos << pModule->ne_align;
if (pSeg->size) size = pSeg->size;
else size = pSeg->minsize ? pSeg->minsize : 0x10000;
if (pModule->ne_flags & NE_FFLAGS_SELFLOAD && segnum > 1)
{
/* Implement self-loading segments */
SELFLOADHEADER *selfloadheader;
void *oldstack;
HFILE16 hFile16;
WORD args[3];
DWORD ret;
selfloadheader = MapSL( MAKESEGPTR(SEL(pSegTable->hSeg),0) );
oldstack = NtCurrentTeb()->WOW32Reserved;
NtCurrentTeb()->WOW32Reserved = (void *)MAKESEGPTR(pModule->self_loading_sel,
0xff00 - sizeof(STACK16FRAME));
hFile16 = NE_OpenFile( pModule );
TRACE_(dll)("Call LoadAppSegProc(hmodule=0x%04x,hf=%x,segnum=%d)\n",
pModule->self,hFile16,segnum );
args[2] = pModule->self;
args[1] = hFile16;
args[0] = segnum;
WOWCallback16Ex( (DWORD)selfloadheader->LoadAppSeg, WCB16_PASCAL, sizeof(args), args, &ret );
pSeg->hSeg = LOWORD(ret);
TRACE_(dll)("Ret LoadAppSegProc: hSeg=0x%04x\n", pSeg->hSeg);
_lclose16( hFile16 );
NtCurrentTeb()->WOW32Reserved = oldstack;
pSeg->flags |= NE_SEGFLAGS_LOADED;
return TRUE;
}
else if (!(pSeg->flags & NE_SEGFLAGS_ITERATED))
{
void *mem = GlobalLock16(pSeg->hSeg);
if (!NE_READ_DATA( pModule, mem, pos, size ))
return FALSE;
pos += size;
}
else
{
/*
The following bit of code for "iterated segments" was written without
any documentation on the format of these segments. It seems to work,
but may be missing something.
*/
const char *buff = NE_GET_DATA( pModule, pos, size );
const char* curr = buff;
char *mem = GlobalLock16(pSeg->hSeg);
pos += size;
if (buff == NULL) return FALSE;
while(curr < buff + size) {
unsigned int rept = ((const short *)curr)[0];
unsigned int len = ((const short *)curr)[1];
curr += 2*sizeof(short);
while (rept--)
{
memcpy( mem, curr, len );
mem += len;
}
curr += len;
}
}
pSeg->flags |= NE_SEGFLAGS_LOADED;
/* Perform exported function prolog fixups */
NE_FixupSegmentPrologs( pModule, segnum );
if (!(pSeg->flags & NE_SEGFLAGS_RELOC_DATA))
return TRUE; /* No relocation data, we are done */
if (!NE_READ_DATA( pModule, &count, pos, sizeof(count) ) || !count) return TRUE;
pos += sizeof(count);
TRACE("Fixups for %.*s, segment %d, hSeg %04x\n",
*((BYTE *)pModule + pModule->ne_restab),
(char *)pModule + pModule->ne_restab + 1,
segnum, pSeg->hSeg );
if (!(rep = NE_GET_DATA( pModule, pos, count * sizeof(struct relocation_entry_s) )))
return FALSE;
return apply_relocations( pModule, rep, count, segnum );
}
/**********************************************************************
* LockResource16 (KERNEL32.@)
*/
LPVOID WINAPI LockResource16( HGLOBAL16 handle )
{
return MapSL( WIN16_LockResource16(handle) );
}
/***********************************************************************
* GetOpenFileName (COMMDLG.1)
*
* Creates a dialog box for the user to select a file to open.
*
* RETURNS
* TRUE on success: user selected a valid file
* FALSE on cancel, error, close or filename-does-not-fit-in-buffer.
*
* BUGS
* unknown, there are some FIXMEs left.
*/
BOOL16 WINAPI GetOpenFileName16( SEGPTR ofn ) /* [in/out] address of structure with data*/
{
LPOPENFILENAME16 lpofn = MapSL(ofn);
LPDLGTEMPLATEA template = NULL;
