/***********************************************************************
* EnumDisplayDevicesW (USER32.@)
*/
BOOL WINAPI
EnumDisplayDevicesW (LPCWSTR lpDevice, DWORD iDevNum,
LPDISPLAY_DEVICEW lpDisplayDevice, DWORD dwFlags)
{
TRACE_(system) ("(%s, %ld, %p, 0x%08lx)\n", debugstr_w (lpDevice), iDevNum,
lpDisplayDevice, dwFlags);
if (dwFlags)
FIXME_(system) ("dwFlags 0x%lx is not supported!\n", dwFlags);
/* We only present one device to the application */
if (iDevNum)
return FALSE;
FIXME_(system) ("Real display device and monitor names should be retrieved\n");
/* Don't bother checking for lpDisplayDevice != NULL; Windows XP crashes
in that case too */
if (lpDevice == NULL)
{
strcpyW (lpDisplayDevice->DeviceName, DeviceName);
strcpyW (lpDisplayDevice->DeviceString, DeviceString);
strcpyW (lpDisplayDevice->DeviceID, DeviceID);
strcpyW (lpDisplayDevice->DeviceKey, DeviceKey);
lpDisplayDevice->StateFlags =
DISPLAY_DEVICE_ATTACHED_TO_DESKTOP |
DISPLAY_DEVICE_PRIMARY_DEVICE |
DISPLAY_DEVICE_VGA_COMPATIBLE;
}
else
{
if (strcmpW (lpDevice, DeviceName))
{
ERR_(system) ("Attempted to get non-existant monitor info!\n");
return FALSE;
}
strcpyW (lpDisplayDevice->DeviceName, MDeviceName);
strcpyW (lpDisplayDevice->DeviceString, MDeviceString);
strcpyW (lpDisplayDevice->DeviceID, MDeviceID);
strcpyW (lpDisplayDevice->DeviceKey, MDeviceKey);
lpDisplayDevice->StateFlags =
DISPLAY_DEVICE_ATTACHED_TO_DESKTOP |
DISPLAY_DEVICE_MULTI_DRIVER;
}
return TRUE;
}
static void add_to_init_list( struct ne_init_list *list, NE_MODULE *hModule )
{
NE_MODULE **newModule = NULL;
if ( list->count == list->size )
{
int newSize = list->size + 128;
if (list->module)
newModule = HeapReAlloc( GetProcessHeap(), 0,
list->module, newSize*sizeof(NE_MODULE *) );
else
newModule = HeapAlloc( GetProcessHeap(), 0,
newSize*sizeof(NE_MODULE *) );
if ( !newModule )
{
FIXME_(dll)("Out of memory!\n");
return;
}
list->module = newModule;
list->size = newSize;
}
list->module[list->count++] = hModule;
}
/***********************************************************************
* K32GetWsChangesEx (KERNEL32.@)
*/
BOOL WINAPI K32GetWsChangesEx(HANDLE process, PSAPI_WS_WATCH_INFORMATION_EX *watchinfoex, DWORD *size)
{
FIXME_(seh)("(%p, %p, %p)\n", process, watchinfoex, size);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/**********************************************************************
* BlockInput (USER32.@)
*/
BOOL WINAPI BlockInput(BOOL fBlockIt)
{
FIXME_(keyboard)("(%d): stub\n", fBlockIt);
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
return FALSE;
}
/***********************************************************************
* SignalProc32 (USER.391)
* UserSignalProc (USER32.@)
*
* For comments about the meaning of uCode and dwFlags
* see PROCESS_CallUserSignalProc.
*
*/
WORD WINAPI UserSignalProc( UINT uCode, DWORD dwThreadOrProcessID,
DWORD dwFlags, HMODULE16 hModule )
{
/* FIXME: Proper reaction to most signals still missing. */
switch ( uCode )
{
case USIG_DLL_UNLOAD_WIN16:
case USIG_DLL_UNLOAD_WIN32:
USER_ModuleUnload( hModule );
break;
case USIG_DLL_UNLOAD_ORPHANS:
case USIG_FAULT_DIALOG_PUSH:
case USIG_FAULT_DIALOG_POP:
case USIG_THREAD_INIT:
case USIG_THREAD_EXIT:
case USIG_PROCESS_CREATE:
case USIG_PROCESS_INIT:
case USIG_PROCESS_LOADED:
case USIG_PROCESS_RUNNING:
case USIG_PROCESS_EXIT:
case USIG_PROCESS_DESTROY:
break;
default:
FIXME_(win)("(%04x, %08lx, %04lx, %04x)\n",
uCode, dwThreadOrProcessID, dwFlags, hModule );
break;
}
/* FIXME: Should chain to GdiSignalProc now. */
return 0;
}
/***********************************************************************
* EnumDisplaySettingsExW (USER32.@)
*/
BOOL WINAPI EnumDisplaySettingsExW(LPCWSTR lpszDeviceName, DWORD iModeNum,
LPDEVMODEW lpDevMode, DWORD dwFlags)
{
FIXME_(system)("(%s,%lu,%p,%08lx): stub\n",
debugstr_w(lpszDeviceName), iModeNum, lpDevMode, dwFlags);
return EnumDisplaySettingsW(lpszDeviceName, iModeNum, lpDevMode);
}
/***********************************************************************
* SetUserObjectSecurity (USER32.@)
*/
BOOL WINAPI SetUserObjectSecurity(
HANDLE hObj,
PSECURITY_INFORMATION pSIRequested,
PSECURITY_DESCRIPTOR pSID
) {
FIXME_(win32)("(0x%08x,%p,%p),stub!\n",hObj,pSIRequested,pSID);
return TRUE;
}
/***********************************************************************
* CreateWindowStationW (USER32.@)
*/
HWINSTA WINAPI CreateWindowStationW(
LPWSTR winstation,DWORD res1,DWORD desiredaccess,
LPSECURITY_ATTRIBUTES lpsa
) {
FIXME_(win32)("(%s,0x%08lx,0x%08lx,%p),stub!\n",debugstr_w(winstation),
res1,desiredaccess,lpsa
);
return (HWINSTA)0xdeadcafe;
}
/***********************************************************************
* K32GetMappedFileNameW (KERNEL32.@)
*/
DWORD WINAPI K32GetMappedFileNameW(HANDLE process, LPVOID lpv, LPWSTR file_name, DWORD size)
{
FIXME_(file)("(%p, %p, %p, %d): stub\n", process, lpv, file_name, size);
if (file_name && size)
file_name[0] = '\0';
return 0;
}
/***********************************************************************
* RegisterDeviceNotificationA (USER32.@)
*/
HDEVNOTIFY WINAPI RegisterDeviceNotificationA(
HANDLE hnd, LPVOID notifyfilter, DWORD flags
) {
FIXME_(win32)("Not converting strings in notifyfilter(%p) to WCHAR\n");
HDEVNOTIFY result = RegisterDeviceNotificationW( hnd, notifyfilter, flags );
return result;
}
/***********************************************************************
* CreateDesktopW (USER32.@)
*/
HDESK WINAPI CreateDesktopW(
LPWSTR lpszDesktop,LPWSTR lpszDevice,LPDEVMODEW pDevmode,
DWORD dwFlags,DWORD dwDesiredAccess,LPSECURITY_ATTRIBUTES lpsa
) {
FIXME_(win32)("(%s,%s,%p,0x%08lx,0x%08lx,%p),stub!\n",
debugstr_w(lpszDesktop),debugstr_w(lpszDevice),pDevmode,
dwFlags,dwDesiredAccess,lpsa
);
return (HDESK)0xcafedead;
}
/***********************************************************************
* UnregisterDeviceNotification (USER32.@)
*/
BOOL WINAPI UnregisterDeviceNotification(HDEVNOTIFY handle)
{
FIXME_(win32)("(handle = %p), STUB! Freeing fake handle\n", handle);
if (handle){
HeapFree(GetProcessHeap(), 0, handle);
return TRUE;
}
return FALSE;
}
/***********************************************************************
* UserSeeUserDo (USER.216)
*/
DWORD WINAPI UserSeeUserDo16(WORD wReqType, WORD wParam1, WORD wParam2, WORD wParam3)
{
switch (wReqType)
{
case USUD_LOCALALLOC:
return LOCAL_Alloc(USER_HeapSel, wParam1, wParam3);
case USUD_LOCALFREE:
return LOCAL_Free(USER_HeapSel, wParam1);
case USUD_LOCALCOMPACT:
return LOCAL_Compact(USER_HeapSel, wParam3, 0);
case USUD_LOCALHEAP:
return USER_HeapSel;
case USUD_FIRSTCLASS:
FIXME_(local)("return a pointer to the first window class.\n");
return (DWORD)-1;
default:
WARN_(local)("wReqType %04x (unknown)", wReqType);
return (DWORD)-1;
}
}
/***********************************************************************
* UnregisterHotKey (USER32.@)
*/
BOOL WINAPI UnregisterHotKey(HWND hwnd,INT id)
{
static int once;
if (!once++) FIXME_(keyboard)("(%p,%d): stub\n",hwnd,id);
return TRUE;
}
static HRESULT IDirectMusicBandImpl_IPersistStream_ParseInstrument (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
ICOM_THIS_MULTI(IDirectMusicBandImpl, PersistStreamVtbl, iface);
DMUS_PRIVATE_CHUNK Chunk;
DWORD ListSize[3], ListCount[3];
LARGE_INTEGER liMove; /* used when skipping chunks */
HRESULT hr;
DMUS_IO_INSTRUMENT inst;
LPDMUS_PRIVATE_INSTRUMENT pNewInstrument;
IDirectMusicObject* pObject = NULL;
if (pChunk->fccID != DMUS_FOURCC_INSTRUMENT_LIST) {
ERR_(dmfile)(": %s chunk should be an INSTRUMENT list\n", debugstr_fourcc (pChunk->fccID));
return E_FAIL;
}
ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
ListCount[0] = 0;
do {
IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
switch (Chunk.fccID) {
case DMUS_FOURCC_INSTRUMENT_CHUNK: {
TRACE_(dmfile)(": Instrument chunk\n");
if (Chunk.dwSize != sizeof(DMUS_IO_INSTRUMENT)) return E_FAIL;
IStream_Read (pStm, &inst, sizeof(DMUS_IO_INSTRUMENT), NULL);
TRACE_(dmfile)(" - dwPatch: %u\n", inst.dwPatch);
TRACE_(dmfile)(" - dwAssignPatch: %u\n", inst.dwAssignPatch);
TRACE_(dmfile)(" - dwNoteRanges[0]: %u\n", inst.dwNoteRanges[0]);
TRACE_(dmfile)(" - dwNoteRanges[1]: %u\n", inst.dwNoteRanges[1]);
TRACE_(dmfile)(" - dwNoteRanges[2]: %u\n", inst.dwNoteRanges[2]);
TRACE_(dmfile)(" - dwNoteRanges[3]: %u\n", inst.dwNoteRanges[3]);
TRACE_(dmfile)(" - dwPChannel: %u\n", inst.dwPChannel);
TRACE_(dmfile)(" - dwFlags: %x\n", inst.dwFlags);
TRACE_(dmfile)(" - bPan: %u\n", inst.bPan);
TRACE_(dmfile)(" - bVolume: %u\n", inst.bVolume);
TRACE_(dmfile)(" - nTranspose: %d\n", inst.nTranspose);
TRACE_(dmfile)(" - dwChannelPriority: %u\n", inst.dwChannelPriority);
TRACE_(dmfile)(" - nPitchBendRange: %d\n", inst.nPitchBendRange);
break;
}
case FOURCC_LIST: {
IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
ListCount[1] = 0;
switch (Chunk.fccID) {
case DMUS_FOURCC_REF_LIST: {
FIXME_(dmfile)(": DMRF (DM References) list\n");
hr = IDirectMusicUtils_IPersistStream_ParseReference (iface, &Chunk, pStm, &pObject);
if (FAILED(hr)) {
ERR(": could not load Reference\n");
return hr;
}
break;
}
default: {
TRACE_(dmfile)(": unknown (skipping)\n");
liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
break;
}
}
break;
}
default: {
TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
liMove.QuadPart = Chunk.dwSize;
IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
break;
}
}
TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
} while (ListCount[0] < ListSize[0]);
/*
* @TODO insert pNewInstrument into This
*/
pNewInstrument = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_INSTRUMENT));
if (NULL == pNewInstrument) {
ERR(": no more memory\n");
return E_OUTOFMEMORY;
}
memcpy(&pNewInstrument->pInstrument, &inst, sizeof(DMUS_IO_INSTRUMENT));
pNewInstrument->ppReferenceCollection = NULL;
if (NULL != pObject) {
IDirectMusicCollection* pCol = NULL;
hr = IDirectMusicObject_QueryInterface (pObject, &IID_IDirectMusicCollection, (void**) &pCol);
if (FAILED(hr)) {
ERR(": failed to get IDirectMusicCollection Interface from DMObject\n");
HeapFree(GetProcessHeap(), 0, pNewInstrument);
return hr;
}
pNewInstrument->ppReferenceCollection = pCol;
IDirectMusicObject_Release(pObject);
}
list_add_tail (&This->Instruments, &pNewInstrument->entry);
return S_OK;
}
/***********************************************************************
* CloseDesktop (USER32.@)
*/
BOOL WINAPI CloseDesktop(HDESK hDesk)
{
FIXME_(win32)("(0x%08x)\n", hDesk);
return TRUE;
}
/***********************************************************************
* RegisterHotKey (USER32.@)
*/
BOOL WINAPI RegisterHotKey(HWND hwnd,INT id,UINT modifiers,UINT vk)
{
static int once;
if (!once++) FIXME_(keyboard)("(%p,%d,0x%08x,%X): stub\n",hwnd,id,modifiers,vk);
return TRUE;
}
/***********************************************************************
* RegisterSystemThread (USER32.@)
*/
void WINAPI RegisterSystemThread(DWORD flags, DWORD reserved)
{
FIXME_(win32)("(%08lx, %08lx)\n", flags, reserved);
}
/***********************************************************************
* SetWindowStationUser (USER32.@)
*/
DWORD WINAPI SetWindowStationUser(DWORD x1,DWORD x2) {
FIXME_(win32)("(0x%08lx,0x%08lx),stub!\n",x1,x2);
return 1;
}
static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegment (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, PersistStreamVtbl, iface);
DMUS_PRIVATE_CHUNK Chunk;
DWORD ListSize[3], ListCount[3];
LARGE_INTEGER liMove; /* used when skipping chunks */
HRESULT hr;
IDirectMusicObject* pObject = NULL;
LPDMUS_PRIVATE_SEGMENT_ITEM pNewItem = NULL;
if (pChunk->fccID != DMUS_FOURCC_SEGMENT_LIST) {
ERR_(dmfile)(": %s chunk should be a SEGMENT list\n", debugstr_fourcc (pChunk->fccID));
return E_FAIL;
}
ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
ListCount[0] = 0;
do {
IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
switch (Chunk.fccID) {
case DMUS_FOURCC_SEGMENTITEM_CHUNK: {
TRACE_(dmfile)(": segment item chunk\n");
/** alloc new item entry */
pNewItem = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_SEGMENT_ITEM));
if (!pNewItem) {
ERR(": no more memory\n");
return E_OUTOFMEMORY;
}
IStream_Read (pStm, &pNewItem->header, sizeof(DMUS_IO_SEGMENT_ITEM_HEADER), NULL);
TRACE_(dmfile)(" - lTimePhysical: %u\n", pNewItem->header.lTimeLogical);
TRACE_(dmfile)(" - lTimePhysical: %u\n", pNewItem->header.lTimePhysical);
TRACE_(dmfile)(" - dwPlayFlags: 0x%08x\n", pNewItem->header.dwPlayFlags);
TRACE_(dmfile)(" - dwFlags: 0x%08x\n", pNewItem->header.dwFlags);
list_add_tail (&This->Items, &pNewItem->entry);
break;
}
case DMUS_FOURCC_SEGMENTITEMNAME_CHUNK: {
TRACE_(dmfile)(": segment item name chunk\n");
if (!pNewItem) {
ERR(": pNewItem not allocated, bad chunk order?\n");
return E_FAIL;
}
IStream_Read (pStm, pNewItem->wszName, Chunk.dwSize, NULL);
TRACE_(dmfile)(" - name: %s\n", debugstr_w(pNewItem->wszName));
break;
}
case FOURCC_LIST: {
IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
ListCount[1] = 0;
switch (Chunk.fccID) {
case DMUS_FOURCC_REF_LIST: {
FIXME_(dmfile)(": DMRF (DM References) list\n");
hr = IDirectMusicUtils_IPersistStream_ParseReference (iface, &Chunk, pStm, &pObject);
if (FAILED(hr)) {
ERR(": could not load Reference\n");
return hr;
}
if (!pNewItem) {
ERR(": pNewItem not allocated, bad chunk order?\n");
return E_FAIL;
}
pNewItem->pObject = pObject;
break;
}
default: {
TRACE_(dmfile)(": unknown (skipping)\n");
liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
break;
}
}
break;
}
default: {
TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
liMove.QuadPart = Chunk.dwSize;
IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
break;
}
}
TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
} while (ListCount[0] < ListSize[0]);
return S_OK;
}
/***********************************************************************
* SetLogonNotifyWindow (USER32.@)
*/
DWORD WINAPI SetLogonNotifyWindow(HWINSTA hwinsta,HWND hwnd) {
FIXME_(win32)("(0x%x,%04x),stub!\n",hwinsta,hwnd);
return 1;
}
/***********************************************************************
* RegisterHotKey (USER32.@)
*/
BOOL WINAPI RegisterHotKey(HWND hwnd,INT id,UINT modifiers,UINT vk)
{
FIXME_(keyboard)("(%p,%d,0x%08x,%d): stub\n",hwnd,id,modifiers,vk);
return TRUE;
}
/***********************************************************************
* UnregisterHotKey (USER32.@)
*/
BOOL WINAPI UnregisterHotKey(HWND hwnd,INT id)
{
FIXME_(keyboard)("(%p,%d): stub\n",hwnd,id);
return TRUE;
}
/***********************************************************************
* RegisterDeviceNotificationW (USER32.@)
*/
HDEVNOTIFY WINAPI RegisterDeviceNotificationW(
HANDLE hnd, LPVOID notifyfilter, DWORD flags
) {
FIXME_(win32)("(hwnd=%08x, filter=%p, flags=0x%08lx), semi-stub! Returning a fake handle\n",
hnd, notifyfilter, flags);
DEVTYP_UNION dev;
DWORD devType;
/* FIXME: currently we only send the WM_DEVICECHANGE messages to top level windows so report an error if someone is trying to
register a child window for device notifications
FIXME: Since we aren't using the name parameter in the notifyfilter structure, we don't bother doing the string conversion if
this function is called from RegisterDeviceNotificationA() */
if (GetParent(hnd))
ERR_(win32)("This is a child window: right now it can't receive WM_DEVICECHANGE messages!\n");
if (notifyfilter)
{
dev.pVoid = notifyfilter;
switch(dev.pHdr->dbch_devicetype)
{
case DBT_DEVTYP_OEM:
FIXME_(win32)("Unimplemented support for: OEM Device 0x%x -- dbco_size: %d, dbco_identifier: %d, dbco_suppfunc: %d\n", dev.pVoid, dev.pOEM->dbco_size, dev.pOEM->dbco_identifier, dev.pOEM->dbco_suppfunc);
break;
case DBT_DEVTYP_VOLUME:
FIXME_(win32)("Unimplemented support for: Volume 0x%x -- dbcv_size: %d, dbcv_unitmask: %d, dbcv_flags: %d\n", dev.pVoid, dev.pVol->dbcv_size, dev.pVol->dbcv_unitmask, dev.pVol->dbcv_flags);
break;
case DBT_DEVTYP_PORT:
FIXME_(win32)("Unimplemented support for: Port Device 0x%x -- dbcp_size: %d, dbcp_name: %s\n", dev.pVoid, dev.pPort->dbcp_size, dev.pPort->dbcp_name);
break;
case DBT_DEVTYP_DEVICEINTERFACE:
FIXME_(win32)("Class of devices 0x%x -- dbcc_size: %d, dbcc_guid: %s, dbcc_name: %s\n", dev.pVoid, dev.pDevInt->dbcc_size, debugstr_guid(&(dev.pDevInt->dbcc_classguid)), dev.pDevInt->dbcc_name);
/*if (flags == DEVICE_NOTIFY_WINDOW_HANDLE)
USER_Driver.pRegisterDeviceNotification(hnd, notifyfilter);*/
break;
case DBT_DEVTYP_HANDLE:
FIXME_(win32)("Unimplemented support for: File Handle 0x%x -- dbch_size: %d, dbch_handle: %d, dbch_hdevnotify: %d, dbch_eventguid: %s\n", dev.pVoid, dev.pHnd->dbch_size, dev.pHnd->dbch_handle, dev.pHnd->dbch_hdevnotify, debugstr_guid(&(dev.pHnd->dbch_eventguid)));
break;
default:
FIXME_(win32)("Unknown device type\n");
break;
}
}
/* used for debug output */
switch (flags)
{
case DEVICE_NOTIFY_WINDOW_HANDLE:
TRACE_(win32)("Recipient is a window handle\n");
break;
case DEVICE_NOTIFY_SERVICE_HANDLE:
FIXME_(win32)("Unimplemented: Recipient is a service handle\n");
break;
case DEVICE_NOTIFY_ALL_INTERFACE_CLASSES:
FIXME_(win32)("Unimplemented: Recipient is all interface classes\n");
break;
default:
break;
}
HDEVNOTIFY result = (HDEVNOTIFY)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(int));
return result;
}
/***********************************************************************
* GetUserObjectInformationW (USER32.@)
*/
BOOL WINAPI GetUserObjectInformationW( HANDLE hObj, INT nIndex, LPVOID pvInfo, DWORD nLength, LPDWORD lpnLen )
{ FIXME_(win32)("(0x%x %i %p %ld %p),stub!\n", hObj, nIndex, pvInfo, nLength, lpnLen );
return TRUE;
}
/***********************************************************************
* GetUserObjectSecurity (USER32.@)
*/
BOOL WINAPI GetUserObjectSecurity(HANDLE hObj, PSECURITY_INFORMATION pSIRequested,
PSECURITY_DESCRIPTOR pSID, DWORD nLength, LPDWORD lpnLengthNeeded)
{ FIXME_(win32)("(0x%x %p %p len=%ld %p),stub!\n", hObj, pSIRequested, pSID, nLength, lpnLengthNeeded);
return TRUE;
}
/***********************************************************************
* K32EnumPageFilesW (KERNEL32.@)
*/
BOOL WINAPI K32EnumPageFilesW( PENUM_PAGE_FILE_CALLBACKW callback, LPVOID context )
{
FIXME_(file)("(%p, %p) stub\n", callback, context );
return FALSE;
}
/**********************************************************************
* PE_LoadImage
* Load one PE format DLL/EXE into memory
*
* Unluckily we can't just mmap the sections where we want them, for
* (at least) Linux does only support offsets which are page-aligned.
*
* BUT we have to map the whole image anyway, for Win32 programs sometimes
* want to access them. (HMODULE32 point to the start of it)
*/
HMODULE PE_LoadImage( int handle, LPCSTR filename, WORD *version )
{
HMODULE hModule;
HANDLE mapping;
IMAGE_NT_HEADERS *nt;
IMAGE_SECTION_HEADER *pe_sec;
IMAGE_DATA_DIRECTORY *dir;
// BY_HANDLE_FILE_INFORMATION bhfi;
int i, rawsize, lowest_va, vma_size, file_size = 0;
DWORD load_addr = 0, aoep, reloc = 0;
// struct get_read_fd_request *req = get_req_buffer();
int unix_handle = handle;
int page_size = getpagesize();
// if ( GetFileInformationByHandle( hFile, &bhfi ) )
// file_size = bhfi.nFileSizeLow;
file_size=lseek(handle, 0, SEEK_END);
lseek(handle, 0, SEEK_SET);
// fix CreateFileMappingA
mapping = CreateFileMappingA( handle, NULL, PAGE_READONLY | SEC_COMMIT,
0, 0, NULL );
if (!mapping)
{
WARN("CreateFileMapping error %ld\n", GetLastError() );
return 0;
}
// hModule = (HMODULE)MapViewOfFile( mapping, FILE_MAP_READ, 0, 0, 0 );
hModule=(HMODULE)mapping;
// CloseHandle( mapping );
if (!hModule)
{
WARN("MapViewOfFile error %ld\n", GetLastError() );
return 0;
}
if ( *(WORD*)hModule !=IMAGE_DOS_SIGNATURE)
{
WARN("%s image doesn't have DOS signature, but 0x%04x\n", filename,*(WORD*)hModule);
goto error;
}
nt = PE_HEADER( hModule );
if ( nt->Signature != IMAGE_NT_SIGNATURE )
{
WARN("%s image doesn't have PE signature, but 0x%08lx\n", filename, nt->Signature );
goto error;
}
if ( nt->FileHeader.Machine != IMAGE_FILE_MACHINE_I386 )
{
dbg_printf("Trying to load PE image for unsupported architecture (");
switch (nt->FileHeader.Machine)
{
case IMAGE_FILE_MACHINE_UNKNOWN: dbg_printf("Unknown"); break;
case IMAGE_FILE_MACHINE_I860: dbg_printf("I860"); break;
case IMAGE_FILE_MACHINE_R3000: dbg_printf("R3000"); break;
case IMAGE_FILE_MACHINE_R4000: dbg_printf("R4000"); break;
case IMAGE_FILE_MACHINE_R10000: dbg_printf("R10000"); break;
case IMAGE_FILE_MACHINE_ALPHA: dbg_printf("Alpha"); break;
case IMAGE_FILE_MACHINE_POWERPC: dbg_printf("PowerPC"); break;
default: dbg_printf("Unknown-%04x", nt->FileHeader.Machine); break;
}
dbg_printf(")\n");
goto error;
}
pe_sec = PE_SECTIONS( hModule );
rawsize = 0; lowest_va = 0x10000;
for (i = 0; i < nt->FileHeader.NumberOfSections; i++)
{
if (lowest_va > pe_sec[i].VirtualAddress)
lowest_va = pe_sec[i].VirtualAddress;
if (pe_sec[i].Characteristics & IMAGE_SCN_CNT_UNINITIALIZED_DATA)
continue;
if (pe_sec[i].PointerToRawData+pe_sec[i].SizeOfRawData > rawsize)
rawsize = pe_sec[i].PointerToRawData+pe_sec[i].SizeOfRawData;
}
if ( file_size && file_size < rawsize )
{
ERR("PE module is too small (header: %d, filesize: %d), "
"probably truncated download?\n",
rawsize, file_size );
goto error;
}
aoep = nt->OptionalHeader.AddressOfEntryPoint;
if (aoep && (aoep < lowest_va))
FIXME("VIRUS WARNING: '%s' has an invalid entrypoint (0x%08lx) "
"below the first virtual address (0x%08x) "
"(possibly infected by Tchernobyl/SpaceFiller virus)!\n",
filename, aoep, lowest_va );
/* FIXME: Hack! While we don't really support shared sections yet,
* this checks for those special cases where the whole DLL
* consists only of shared sections and is mapped into the
* shared address space > 2GB. In this case, we assume that
* the module got mapped at its base address. Thus we simply
* check whether the module has actually been mapped there
* and use it, if so. This is needed to get Win95 USER32.DLL
* to work (until we support shared sections properly).
*/
if ( nt->OptionalHeader.ImageBase & 0x80000000 &&
!strstr(filename, "xanlib.dll"))
{
HMODULE sharedMod = (HMODULE)nt->OptionalHeader.ImageBase;
IMAGE_NT_HEADERS *sharedNt = (PIMAGE_NT_HEADERS)
( (LPBYTE)sharedMod + ((LPBYTE)nt - (LPBYTE)hModule) );
/* Well, this check is not really comprehensive,
but should be good enough for now ... */
if ( !IsBadReadPtr( (LPBYTE)sharedMod, sizeof(IMAGE_DOS_HEADER) )
&& memcmp( (LPBYTE)sharedMod, (LPBYTE)hModule, sizeof(IMAGE_DOS_HEADER) ) == 0
&& !IsBadReadPtr( sharedNt, sizeof(IMAGE_NT_HEADERS) )
&& memcmp( sharedNt, nt, sizeof(IMAGE_NT_HEADERS) ) == 0 )
{
UnmapViewOfFile( (LPVOID)hModule );
return sharedMod;
}
}
load_addr = nt->OptionalHeader.ImageBase;
vma_size = calc_vma_size( hModule );
load_addr = (DWORD)VirtualAlloc( (void*)load_addr, vma_size,
MEM_RESERVE | MEM_COMMIT,
PAGE_EXECUTE_READWRITE );
if (load_addr == 0)
{
FIXME("We need to perform base relocations for %s\n", filename);
dir = nt->OptionalHeader.DataDirectory+IMAGE_DIRECTORY_ENTRY_BASERELOC;
if (dir->Size)
reloc = dir->VirtualAddress;
else
{
FIXME( "FATAL: Need to relocate %s, but no relocation records present (%s). Try to run that file directly !\n",
filename,
(nt->FileHeader.Characteristics&IMAGE_FILE_RELOCS_STRIPPED)?
"stripped during link" : "unknown reason" );
goto error;
}
/* FIXME: If we need to relocate a system DLL (base > 2GB) we should
* really make sure that the *new* base address is also > 2GB.
* Some DLLs really check the MSB of the module handle :-/
*/
if ( nt->OptionalHeader.ImageBase & 0x80000000 )
ERR( "Forced to relocate system DLL (base > 2GB). This is not good.\n" );
load_addr = (DWORD)VirtualAlloc( NULL, vma_size,
MEM_RESERVE | MEM_COMMIT,
PAGE_EXECUTE_READWRITE );
if (!load_addr) {
FIXME_(win32)(
"FATAL: Couldn't load module %s (out of memory, %d needed)!\n", filename, vma_size);
goto error;
}
}
TRACE("Load addr is %lx (base %lx), range %x\n",
load_addr, nt->OptionalHeader.ImageBase, vma_size );
TRACE_(segment)("Loading %s at %lx, range %x\n",
filename, load_addr, vma_size );
#if 0
*(PIMAGE_DOS_HEADER)load_addr = *(PIMAGE_DOS_HEADER)hModule;
*PE_HEADER( load_addr ) = *nt;
memcpy( PE_SECTIONS(load_addr), PE_SECTIONS(hModule),
sizeof(IMAGE_SECTION_HEADER) * nt->FileHeader.NumberOfSections );
memcpy( load_addr, hModule, lowest_fa );
#endif
if ((void*)FILE_dommap( handle, (void *)load_addr, 0, nt->OptionalHeader.SizeOfHeaders,
0, 0, PROT_EXEC | PROT_WRITE | PROT_READ,
MAP_PRIVATE | MAP_FIXED ) != (void*)load_addr)
{
ERR_(win32)( "Critical Error: failed to map PE header to necessary address.\n");
goto error;
}
pe_sec = PE_SECTIONS( hModule );
for (i = 0; i < nt->FileHeader.NumberOfSections; i++, pe_sec++)
{
if (!pe_sec->SizeOfRawData || !pe_sec->PointerToRawData) continue;
TRACE("%s: mmaping section %s at %p off %lx size %lx/%lx\n",
filename, pe_sec->Name, (void*)RVA(pe_sec->VirtualAddress),
pe_sec->PointerToRawData, pe_sec->SizeOfRawData, pe_sec->Misc.VirtualSize );
if ((void*)FILE_dommap( unix_handle, (void*)RVA(pe_sec->VirtualAddress),
0, pe_sec->SizeOfRawData, 0, pe_sec->PointerToRawData,
PROT_EXEC | PROT_WRITE | PROT_READ,
MAP_PRIVATE | MAP_FIXED ) != (void*)RVA(pe_sec->VirtualAddress))
{
ERR_(win32)( "Critical Error: failed to map PE section to necessary address.\n");
goto error;
}
if ((pe_sec->SizeOfRawData < pe_sec->Misc.VirtualSize) &&
(pe_sec->SizeOfRawData & (page_size-1)))
{
DWORD end = (pe_sec->SizeOfRawData & ~(page_size-1)) + page_size;
if (end > pe_sec->Misc.VirtualSize) end = pe_sec->Misc.VirtualSize;
TRACE("clearing %p - %p\n",
RVA(pe_sec->VirtualAddress) + pe_sec->SizeOfRawData,
RVA(pe_sec->VirtualAddress) + end );
memset( (char*)RVA(pe_sec->VirtualAddress) + pe_sec->SizeOfRawData, 0,
end - pe_sec->SizeOfRawData );
}
}
if ( reloc )
do_relocations( load_addr, (IMAGE_BASE_RELOCATION *)RVA(reloc) );
*version = ( (nt->OptionalHeader.MajorSubsystemVersion & 0xff) << 8 )
| (nt->OptionalHeader.MinorSubsystemVersion & 0xff);
UnmapViewOfFile( (LPVOID)hModule );
return (HMODULE)load_addr;
error:
if (unix_handle != -1) close( unix_handle );
if (load_addr)
VirtualFree( (LPVOID)load_addr, 0, MEM_RELEASE );
UnmapViewOfFile( (LPVOID)hModule );
return 0;
}
/***********************************************************************
* K32InitializeProcessForWsWatch (KERNEL32.@)
*/
BOOL WINAPI K32InitializeProcessForWsWatch(HANDLE process)
{
FIXME_(seh)("(process=%p): stub\n", process);
return TRUE;
}
/***********************************************************************
* SetSystemCursor (USER32.@)
*/
BOOL WINAPI SetSystemCursor(HCURSOR hcur, DWORD id)
{ FIXME_(win32)("(%08x,%08lx),stub!\n", hcur, id);
return TRUE;
}