/**************************************************************************** * UTRegister (KERNEL32.@) */ BOOL WINAPI UTRegister( HMODULE hModule, LPSTR lpsz16BITDLL, LPSTR lpszInitName, LPSTR lpszProcName, FARPROC *ppfn32Thunk, FARPROC pfnUT32CallBack, LPVOID lpBuff ) { UTINFO *ut; HMODULE16 hModule16; FARPROC16 target16, init16; /* Load 16-bit DLL and get UTProc16 entry point */ if ( (hModule16 = LoadLibrary16( lpsz16BITDLL )) <= 32 || (target16 = GetProcAddress16( hModule16, lpszProcName )) == 0 ) return FALSE; /* Allocate UTINFO struct */ RtlAcquirePebLock(); if ( (ut = UTFind( hModule )) != NULL ) ut = NULL; else ut = UTAlloc( hModule, hModule16, target16, pfnUT32CallBack ); RtlReleasePebLock(); if ( !ut ) { FreeLibrary16( hModule16 ); return FALSE; } /* Call UTInit16 if present */ if ( lpszInitName && (init16 = GetProcAddress16( hModule16, lpszInitName )) != 0 ) { SEGPTR callback = MapLS( &ut->ut16 ); SEGPTR segBuff = MapLS( lpBuff ); WORD args[4]; DWORD ret; args[3] = SELECTOROF(callback); args[2] = OFFSETOF(callback); args[1] = SELECTOROF(segBuff); args[0] = OFFSETOF(segBuff); WOWCallback16Ex( (DWORD)init16, WCB16_PASCAL, sizeof(args), args, &ret ); UnMapLS( segBuff ); UnMapLS( callback ); if (!ret) { UTUnRegister( hModule ); return FALSE; } } /* Return 32-bit thunk */ *ppfn32Thunk = (FARPROC) &ut->ut32; return TRUE; }
/*********************************************************************** * SystemHeapInfo (TOOLHELP.71) */ BOOL16 WINAPI SystemHeapInfo16( SYSHEAPINFO *pHeapInfo ) { STACK16FRAME* stack16 = MapSL((SEGPTR)NtCurrentTeb()->WOW32Reserved); HANDLE16 oldDS = stack16->ds; WORD user = LoadLibrary16( "USER.EXE" ); WORD gdi = LoadLibrary16( "GDI.EXE" ); stack16->ds = user; pHeapInfo->wUserFreePercent = (int)LocalCountFree16() * 100 / LocalHeapSize16(); stack16->ds = gdi; pHeapInfo->wGDIFreePercent = (int)LocalCountFree16() * 100 / LocalHeapSize16(); stack16->ds = oldDS; pHeapInfo->hUserSegment = user; pHeapInfo->hGDISegment = gdi; FreeLibrary16( user ); FreeLibrary16( gdi ); return TRUE; }
/**************************************************************************** * UTUnRegister (KERNEL32.@) */ VOID WINAPI UTUnRegister( HMODULE hModule ) { UTINFO *ut; HMODULE16 hModule16 = 0; RtlAcquirePebLock(); ut = UTFind( hModule ); if ( ut ) { hModule16 = ut->hModule16; UTFree( ut ); } RtlReleasePebLock(); if ( hModule16 ) FreeLibrary16( hModule16 ); }
/************************************************************************** * DRIVER_TryOpenDriver16 [internal] * * Tries to load a 16 bit driver whose DLL's (module) name is lpFileName. */ static LPWINE_DRIVER DRIVER_TryOpenDriver16(LPCSTR lpFileName, LPARAM lParam2) { static WORD DRIVER_hDrvr16Counter /* = 0 */; LPWINE_DRIVER lpDrv = NULL; HMODULE16 hModule; DRIVERPROC16 lpProc; LPCSTR lpSFN; LPSTR ptr; TRACE("('%s', %08lX);\n", lpFileName, lParam2); if (strlen(lpFileName) < 1) return lpDrv; if ((lpSFN = strrchr(lpFileName, '\\')) == NULL) lpSFN = lpFileName; else lpSFN++; if ((ptr = strchr(lpFileName, ' ')) != NULL) { *ptr++ = '\0'; while (*ptr == ' ') ptr++; if (*ptr == '\0') ptr = NULL; } if ((hModule = LoadLibrary16(lpFileName)) < 32) goto exit; if ((lpProc = (DRIVERPROC16)GetProcAddress16(hModule, "DRIVERPROC")) == NULL) goto exit; if ((lpDrv = HeapAlloc(GetProcessHeap(), 0, sizeof(WINE_DRIVER))) == NULL) goto exit; lpDrv->dwDriverID = 0; while (DRIVER_FindFromHDrvr16(++DRIVER_hDrvr16Counter)); lpDrv->hDriver16 = DRIVER_hDrvr16Counter; lstrcpynA(lpDrv->szAliasName, lpSFN, sizeof(lpDrv->szAliasName)); lpDrv->hModule16 = hModule; lpDrv->lpDrvProc = lpProc; if (!DRIVER_AddToList(lpDrv, (LPARAM)ptr, lParam2)) goto exit; return lpDrv; exit: TRACE("Unable to load 16 bit module (%s): %04x\n", lpFileName, hModule); if (hModule >= 32) FreeLibrary16(hModule); HeapFree(GetProcessHeap(), 0, lpDrv); return NULL; }
/****************************************************************************** * OleMetaFilePictFromIconAndLabel (OLE2.56) * * Returns a global memory handle to a metafile which contains the icon and * label given. * I guess the result of that should look somehow like desktop icons. * If no hIcon is given, we load the icon via lpszSourceFile and iIconIndex. * This code might be wrong at some places. */ HGLOBAL16 WINAPI OleMetaFilePictFromIconAndLabel16( HICON16 hIcon, LPCOLESTR16 lpszLabel, LPCOLESTR16 lpszSourceFile, UINT16 iIconIndex ) { METAFILEPICT16 *mf16; HGLOBAL16 hmf16; HMETAFILE hmf; INT mfSize; HDC hdc; if (!hIcon) { if (lpszSourceFile) { HINSTANCE16 hInstance = LoadLibrary16(lpszSourceFile); /* load the icon at index from lpszSourceFile */ hIcon = HICON_16(LoadIconA(HINSTANCE_32(hInstance), (LPCSTR)(DWORD)iIconIndex)); FreeLibrary16(hInstance); } else return 0; } FIXME("(%04x, '%s', '%s', %d): incorrect metrics, please try to correct them !\n", hIcon, lpszLabel, lpszSourceFile, iIconIndex); hdc = CreateMetaFileW(NULL); DrawIcon(hdc, 0, 0, HICON_32(hIcon)); /* FIXME */ TextOutA(hdc, 0, 0, lpszLabel, 1); /* FIXME */ hmf = CloseMetaFile(hdc); hmf16 = GlobalAlloc16(0, sizeof(METAFILEPICT16)); mf16 = (METAFILEPICT16 *)GlobalLock16(hmf16); mf16->mm = MM_ANISOTROPIC; mf16->xExt = 20; /* FIXME: bogus */ mf16->yExt = 20; /* dito */ mfSize = GetMetaFileBitsEx(hmf, 0, 0); mf16->hMF = GlobalAlloc16(GMEM_MOVEABLE, mfSize); if(mf16->hMF) { GetMetaFileBitsEx(hmf, mfSize, GlobalLock16(mf16->hMF)); GlobalUnlock16(mf16->hMF); } return hmf16; }
/*********************************************************************** * GetFreeSystemResources (USER.284) */ WORD WINAPI GetFreeSystemResources16( WORD resType ) { HINSTANCE16 gdi_inst; WORD gdi_heap; int userPercent, gdiPercent; if ((gdi_inst = LoadLibrary16( "GDI" )) < 32) return 0; gdi_heap = gdi_inst | 7; switch(resType) { case GFSR_USERRESOURCES: userPercent = (int)LOCAL_CountFree( USER_HeapSel ) * 100 / LOCAL_HeapSize( USER_HeapSel ); gdiPercent = 100; break; case GFSR_GDIRESOURCES: gdiPercent = (int)LOCAL_CountFree( gdi_inst ) * 100 / LOCAL_HeapSize( gdi_inst ); userPercent = 100; break; case GFSR_SYSTEMRESOURCES: userPercent = (int)LOCAL_CountFree( USER_HeapSel ) * 100 / LOCAL_HeapSize( USER_HeapSel ); gdiPercent = (int)LOCAL_CountFree( gdi_inst ) * 100 / LOCAL_HeapSize( gdi_inst ); break; default: userPercent = gdiPercent = 0; break; } FreeLibrary16( gdi_inst ); return (WORD)min( userPercent, gdiPercent ); }
/*********************************************************************** * 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; }
/*********************************************************************** * VERSION_GetFileVersionInfo_16 [internal] * * NOTE: returns size of the 16-bit VERSION resource or 0xFFFFFFFF * in the case if file exists, but VERSION_INFO not found. * FIXME: handle is not used. */ static DWORD VERSION_GetFileVersionInfo_16( LPCSTR filename, LPDWORD handle, DWORD datasize, LPVOID data ) { VS_FIXEDFILEINFO *vffi; DWORD len; BYTE *buf; HMODULE16 hModule; HRSRC16 hRsrc; HGLOBAL16 hMem; BOOL do_free_library = FALSE; TRACE("(%s,%p)\n", debugstr_a(filename), handle ); hModule = GetModuleHandle16(filename); if(hModule < 32) { hModule = LoadLibrary16(filename); do_free_library = TRUE; } if(hModule < 32) { WARN("Could not load %s\n", debugstr_a(filename)); return 0; } hRsrc = FindResource16(hModule, MAKEINTRESOURCEA(VS_VERSION_INFO), MAKEINTRESOURCEA(VS_FILE_INFO)); if(!hRsrc) { WARN("Could not find VS_VERSION_INFO in %s\n", debugstr_a(filename)); if(do_free_library) FreeLibrary16(hModule); return 0xFFFFFFFF; } len = SizeofResource16(hModule, hRsrc); hMem = LoadResource16(hModule, hRsrc); if(!hMem) { WARN("Could not load VS_VERSION_INFO from %s\n", debugstr_a(filename)); if(do_free_library) FreeLibrary16(hModule); return 0xFFFFFFFF; } buf = LockResource16(hMem); if(!VersionInfoIs16(buf)) goto END; vffi = (VS_FIXEDFILEINFO *)VersionInfo16_Value( (VS_VERSION_INFO_STRUCT16 *)buf ); if ( vffi->dwSignature != VS_FFI_SIGNATURE ) { WARN("vffi->dwSignature is 0x%08lx, but not 0x%08lx!\n", vffi->dwSignature, VS_FFI_SIGNATURE ); len = 0xFFFFFFFF; goto END; } if ( TRACE_ON(ver) ) print_vffi_debug( vffi ); if(data) { if(datasize < len) len = datasize; /* truncate data */ if(len) memcpy(data, buf, len); else len = 0xFFFFFFFF; } END: FreeResource16(hMem); if(do_free_library) FreeLibrary16(hModule); return len; }