/* * Modules * * Copyright 1995 Alexandre Julliard */ #include #include #include #include #include #include #include #include "windows.h" #include "class.h" #include "file.h" #include "global.h" #include "heap.h" #include "module.h" #include "neexe.h" #include "pe_image.h" #include "process.h" #include "thread.h" #include "resource.h" #include "selectors.h" #include "stackframe.h" #include "task.h" #include "toolhelp.h" #include "debug.h" #include "callback.h" extern BOOL32 THREAD_InitDone; extern HMODULE16 hFirstModule; /* FIXME */ static HMODULE16 hCachedModule = 0; /* Module cached by MODULE_OpenFile */ static HMODULE32 MODULE_LoadModule(LPCSTR name,BOOL32 force) { return 0; } HMODULE32 (*fnBUILTIN_LoadModule)(LPCSTR name,BOOL32 force) = MODULE_LoadModule; /************************************************************************* * MODULE32_LookupHMODULE * looks for the referenced HMODULE in the current process */ WINE_MODREF* MODULE32_LookupHMODULE(PDB32 *process,HMODULE32 hmod) { WINE_MODREF *wm; if (!hmod) return process->exe_modref; if (!HIWORD(hmod)) { ERR(module,"tried to lookup 0x%04x in win32 module handler!\n",hmod); return NULL; } for (wm = process->modref_list;wm;wm=wm->next) if (wm->module == hmod) return wm; return NULL; } /*********************************************************************** * MODULE_GetPtr16 */ NE_MODULE *MODULE_GetPtr16( HMODULE16 hModule ) { return (NE_MODULE*)GlobalLock16( GetExePtr(hModule) ); } /*********************************************************************** * MODULE_GetPtr32 */ NE_MODULE *MODULE_GetPtr32( HMODULE32 hModule ) { return (NE_MODULE*)GlobalLock16( MODULE_HANDLEtoHMODULE16(hModule) ); } /*********************************************************************** * MODULE_HANDLEtoHMODULE16 */ HMODULE16 MODULE_HANDLEtoHMODULE16(HANDLE32 handle) { NE_MODULE *pModule; if (HIWORD(handle)) { WARN(module,"looking up 0x%08x in win16 function!\n",handle); /* this is a HMODULE32 */ /* walk the list looking for the correct startaddress */ pModule = (NE_MODULE *)GlobalLock16( hFirstModule ); while (pModule) { if (pModule->module32 == handle) return pModule->self; pModule = (NE_MODULE*)GlobalLock16(pModule->next); } return 0; } return GetExePtr(handle); } /*********************************************************************** * MODULE_OpenFile */ int MODULE_OpenFile( HMODULE32 hModule ) { NE_MODULE *pModule; DOS_FULL_NAME full_name; char *name; static int cachedfd = -1; hModule = MODULE_HANDLEtoHMODULE16(hModule); TRACE(module, "(%04x) cache: mod=%04x fd=%d\n", hModule, hCachedModule, cachedfd ); if (!(pModule = MODULE_GetPtr32( hModule ))) return -1; if (hCachedModule == hModule) return cachedfd; close( cachedfd ); hCachedModule = hModule; name = NE_MODULE_NAME( pModule ); if (!DOSFS_GetFullName( name, TRUE, &full_name ) || (cachedfd = open( full_name.long_name, O_RDONLY )) == -1) WARN( module, "Can't open file '%s' for module %04x\n", name, hModule ); TRACE(module, "opened '%s' -> %d\n", name, cachedfd ); return cachedfd; } /*********************************************************************** * MODULE_CreateInstance * * If lib_only is TRUE, handle the module like a library even if it is a .EXE */ HINSTANCE16 MODULE_CreateInstance( HMODULE16 hModule, HINSTANCE16 *prev, BOOL32 lib_only ) { SEGTABLEENTRY *pSegment; NE_MODULE *pModule; int minsize; HINSTANCE16 hNewInstance; if (!(pModule = MODULE_GetPtr16( hModule ))) return 0; if (pModule->dgroup == 0) { if (prev) *prev = hModule; return hModule; } pSegment = NE_SEG_TABLE( pModule ) + pModule->dgroup - 1; if (prev) *prev = pSegment->selector; /* if it's a library, create a new instance only the first time */ if (pSegment->selector) { if (pModule->flags & NE_FFLAGS_LIBMODULE) return pSegment->selector; if (lib_only) return pSegment->selector; } minsize = pSegment->minsize ? pSegment->minsize : 0x10000; if (pModule->ss == pModule->dgroup) minsize += pModule->stack_size; minsize += pModule->heap_size; hNewInstance = GLOBAL_Alloc( GMEM_ZEROINIT | GMEM_FIXED, minsize, hModule, FALSE, FALSE, FALSE ); if (!hNewInstance) return 0; pSegment->selector = hNewInstance; return hNewInstance; } /*********************************************************************** * MODULE_CreateDummyModule * * Create a dummy NE module for Win32 or Winelib. */ HMODULE32 MODULE_CreateDummyModule( const OFSTRUCT *ofs ) { HMODULE32 hModule; NE_MODULE *pModule; SEGTABLEENTRY *pSegment; char *pStr,*s; int len; const char* basename; INT32 of_size = sizeof(OFSTRUCT) - sizeof(ofs->szPathName) + strlen(ofs->szPathName) + 1; INT32 size = sizeof(NE_MODULE) + /* loaded file info */ of_size + /* segment table: DS,CS */ 2 * sizeof(SEGTABLEENTRY) + /* name table */ 9 + /* several empty tables */ 8; hModule = GlobalAlloc16( GMEM_MOVEABLE | GMEM_ZEROINIT, size ); if (!hModule) return (HMODULE32)11; /* invalid exe */ FarSetOwner( hModule, hModule ); pModule = (NE_MODULE *)GlobalLock16( hModule ); /* Set all used entries */ pModule->magic = IMAGE_OS2_SIGNATURE; pModule->count = 1; pModule->next = 0; pModule->flags = 0; pModule->dgroup = 1; pModule->ss = 1; pModule->cs = 2; pModule->heap_size = 0xe000; pModule->stack_size = 0x1000; pModule->seg_count = 2; pModule->modref_count = 0; pModule->nrname_size = 0; pModule->fileinfo = sizeof(NE_MODULE); pModule->os_flags = NE_OSFLAGS_WINDOWS; pModule->expected_version = 0x030a; pModule->self = hModule; /* Set loaded file information */ memcpy( pModule + 1, ofs, of_size ); ((OFSTRUCT *)(pModule+1))->cBytes = of_size - 1; pSegment = (SEGTABLEENTRY*)((char*)(pModule + 1) + of_size); pModule->seg_table = pModule->dgroup_entry = (int)pSegment - (int)pModule; /* Data segment */ pSegment->size = 0; pSegment->flags = NE_SEGFLAGS_DATA; pSegment->minsize = 0x1000; pSegment++; /* Code segment */ pSegment->flags = 0; pSegment++; /* Module name */ pStr = (char *)pSegment; pModule->name_table = (int)pStr - (int)pModule; basename = strrchr(ofs->szPathName,'\\'); if (!basename) basename = ofs->szPathName; else basename++; len = strlen(basename); if ((s = strchr(basename,'.'))) len = s - basename; if (len > 8) len = 8; *pStr = len; strncpy( pStr+1, basename, len ); if (len < 8) pStr[len+1] = 0; pStr += 9; /* All tables zero terminated */ pModule->res_table = pModule->import_table = pModule->entry_table = (int)pStr - (int)pModule; NE_RegisterModule( pModule ); return hModule; } /*********************************************************************** * MODULE_GetWndProcEntry16 (not a Windows API function) * * Return an entry point from the WPROCS dll. */ FARPROC16 MODULE_GetWndProcEntry16( LPCSTR name ) { FARPROC16 ret = NULL; if (__winelib) { /* FIXME: hack for Winelib */ extern LRESULT ColorDlgProc(HWND16,UINT16,WPARAM16,LPARAM); extern LRESULT FileOpenDlgProc(HWND16,UINT16,WPARAM16,LPARAM); extern LRESULT FileSaveDlgProc(HWND16,UINT16,WPARAM16,LPARAM); extern LRESULT FindTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM); extern LRESULT PrintDlgProc(HWND16,UINT16,WPARAM16,LPARAM); extern LRESULT PrintSetupDlgProc(HWND16,UINT16,WPARAM16,LPARAM); extern LRESULT ReplaceTextDlgProc16(HWND16,UINT16,WPARAM16,LPARAM); if (!strcmp(name,"ColorDlgProc")) return (FARPROC16)ColorDlgProc; if (!strcmp(name,"FileOpenDlgProc")) return (FARPROC16)FileOpenDlgProc; if (!strcmp(name,"FileSaveDlgProc")) return (FARPROC16)FileSaveDlgProc; if (!strcmp(name,"FindTextDlgProc")) return (FARPROC16)FindTextDlgProc16; if (!strcmp(name,"PrintDlgProc")) return (FARPROC16)PrintDlgProc; if (!strcmp(name,"PrintSetupDlgProc")) return (FARPROC16)PrintSetupDlgProc; if (!strcmp(name,"ReplaceTextDlgProc")) return (FARPROC16)ReplaceTextDlgProc16; WARN(module,"No mapping for %s(), add one in library/miscstubs.c\n",name); assert( FALSE ); return NULL; } else { WORD ordinal; static HMODULE32 hModule = 0; if (!hModule) hModule = GetModuleHandle16( "WPROCS" ); ordinal = NE_GetOrdinal( hModule, name ); if (!(ret = NE_GetEntryPoint( hModule, ordinal ))) { WARN( module, "%s not found\n", name ); assert( FALSE ); } } return ret; } /*********************************************************************** * MODULE_GetModuleName */ LPSTR MODULE_GetModuleName( HMODULE32 hModule ) { NE_MODULE *pModule; BYTE *p, len; static char buffer[10]; if (!(pModule = MODULE_GetPtr32( hModule ))) return NULL; p = (BYTE *)pModule + pModule->name_table; len = MIN( *p, 8 ); memcpy( buffer, p + 1, len ); buffer[len] = '\0'; return buffer; } /********************************************************************** * MODULE_FindModule * * Find a module from a path name. * RETURNS * the win16 module handle if found * 0 if not */ HMODULE32 MODULE_FindModule16( LPCSTR path /* [in] path of the module to be found */ ) { HMODULE32 hModule = hFirstModule; LPCSTR filename, dotptr, modulepath, modulename; BYTE len, *name_table; if (!(filename = strrchr( path, '\\' ))) filename = path; else filename++; if ((dotptr = strrchr( filename, '.' )) != NULL) len = (BYTE)(dotptr - filename); else len = strlen( filename ); while(hModule) { NE_MODULE *pModule = MODULE_GetPtr16( hModule ); if (!pModule) break; modulepath = NE_MODULE_NAME(pModule); if (!(modulename = strrchr( modulepath, '\\' ))) modulename = modulepath; else modulename++; if (!lstrcmpi32A( modulename, filename )) return hModule; name_table = (BYTE *)pModule + pModule->name_table; if ((*name_table == len) && !lstrncmpi32A(filename, name_table+1, len)) return hModule; hModule = pModule->next; } return 0; } /********************************************************************** * MODULE_FindModule32 * * Find a (loaded) win32 module depending on path * The handling of '.' is a bit weird, but we need it that way, * for sometimes the programs use '.exe' and '.dll' and * this is the only way to differentiate. (mainly hypertrm.exe) * * RETURNS * the module handle if found * 0 if not */ HMODULE32 MODULE_FindModule32( PDB32* process, /* [in] process in which to find the library */ LPCSTR path /* [in] pathname of module/library to be found */ ) { LPSTR filename; LPSTR dotptr; WINE_MODREF *wm; if (!(filename = strrchr( path, '\\' ))) filename = HEAP_strdupA(process->heap,0,path); else filename = HEAP_strdupA(process->heap,0,filename+1); dotptr=strrchr(filename,'.'); if (!process) { HeapFree(process->heap,0,filename); return 0; } for (wm=process->modref_list;wm;wm=wm->next) { LPSTR xmodname,xdotptr; assert (wm->modname); xmodname = HEAP_strdupA(process->heap,0,wm->modname); xdotptr=strrchr(xmodname,'.'); if ( (xdotptr && !dotptr) || (!xdotptr && dotptr) ) { if (dotptr) *dotptr = '\0'; if (xdotptr) *xdotptr = '\0'; } if (!lstrcmpi32A( filename, xmodname)) { HeapFree(process->heap,0,filename); HeapFree(process->heap,0,xmodname); return wm->module; } if (dotptr) *dotptr='.'; /* FIXME: add paths, shortname */ HeapFree(process->heap,0,xmodname); } HeapFree(process->heap,0,filename); return 0; } /********************************************************************** * MODULE_CallWEP * * Call a DLL's WEP, allowing it to shut down. * FIXME: we always pass the WEP WEP_FREE_DLL, never WEP_SYSTEM_EXIT */ static BOOL16 MODULE_CallWEP( HMODULE16 hModule ) { FARPROC16 WEP = (FARPROC16)0; WORD ordinal = NE_GetOrdinal( hModule, "WEP" ); if (ordinal) WEP = NE_GetEntryPoint( hModule, ordinal ); if (!WEP) { WARN(module, "module %04x doesn't have a WEP\n", hModule ); return FALSE; } return Callbacks->CallWindowsExitProc( WEP, WEP_FREE_DLL ); } /********************************************************************** * MODULE_FreeModule * * Remove a module from memory. */ BOOL16 MODULE_FreeModule( HMODULE32 hModule, TDB* pTaskContext ) { HMODULE16 *hPrevModule; NE_MODULE *pModule; SEGTABLEENTRY *pSegment; HMODULE16 *pModRef; int i; if (!(pModule = MODULE_GetPtr32( hModule ))) return FALSE; hModule = pModule->self; if (((INT16)(--pModule->count)) > 0 ) return TRUE; else pModule->count = 0; if (pModule->flags & NE_FFLAGS_BUILTIN) return FALSE; /* Can't free built-in module */ if (pModule->flags & NE_FFLAGS_LIBMODULE) { MODULE_CallWEP( hModule ); /* Free the objects owned by the DLL module */ if( pTaskContext && pTaskContext->userhandler ) { pTaskContext->userhandler( hModule, USIG_DLL_UNLOAD, 0, pTaskContext->hInstance, pTaskContext->hQueue ); } } /* Clear magic number just in case */ pModule->magic = pModule->self = 0; /* Remove it from the linked list */ hPrevModule = &hFirstModule; while (*hPrevModule && (*hPrevModule != hModule)) { hPrevModule = &(MODULE_GetPtr16( *hPrevModule ))->next; } if (*hPrevModule) *hPrevModule = pModule->next; /* Free all the segments */ pSegment = NE_SEG_TABLE( pModule ); for (i = 1; i <= pModule->seg_count; i++, pSegment++) { GlobalFree16( pSegment->selector ); } /* Free the referenced modules */ pModRef = (HMODULE16*)NE_MODULE_TABLE( pModule ); for (i = 0; i < pModule->modref_count; i++, pModRef++) { FreeModule16( *pModRef ); } /* Free the module storage */ if (pModule->nrname_handle) GlobalFree16( pModule->nrname_handle ); if (pModule->dlls_to_init) GlobalFree16( pModule->dlls_to_init ); GlobalFree16( hModule ); /* Remove module from cache */ if (hCachedModule == hModule) hCachedModule = 0; return TRUE; } /********************************************************************** * MODULE_Load * * Implementation of LoadModule(). * * cmd_line must contain the whole command-line, including argv[0] (and * without a preceding length byte). * If cmd_line is NULL, the module is loaded as a library even if it is a .exe */ HINSTANCE16 MODULE_Load( LPCSTR name, UINT16 uFlags, LPCSTR cmd_line, LPCSTR env, UINT32 show_cmd ) { HMODULE32 hModule; HINSTANCE16 hInstance, hPrevInstance; NE_MODULE *pModule; OFSTRUCT ofs; HFILE32 hFile; if (__winelib) { lstrcpyn32A( ofs.szPathName, name, sizeof(ofs.szPathName) ); if ((hModule = MODULE_CreateDummyModule( &ofs )) < 32) return hModule; pModule = (NE_MODULE *)GlobalLock16( hModule ); hInstance = MODULE_CreateInstance( hModule, &hPrevInstance, (cmd_line == NULL) ); } else { hModule = MODULE_FindModule16( name ); if (!hModule) /* We have to load the module */ { /* Try to load the built-in first if not disabled */ if ((hModule = fnBUILTIN_LoadModule( name, FALSE ))) return MODULE_HANDLEtoHMODULE16( hModule ); if ((hFile = OpenFile32( name, &ofs, OF_READ )) == HFILE_ERROR32) { /* Now try the built-in even if disabled */ if ((hModule = fnBUILTIN_LoadModule( name, TRUE ))) { WARN(module, "Could not load Windows DLL '%s', using built-in module.\n", name ); return MODULE_HANDLEtoHMODULE16( hModule ); } return 2; /* File not found */ } /* Create the module structure */ hModule = NE_LoadModule( hFile, &ofs, uFlags, cmd_line, env, show_cmd ); if (hModule < 32) { if ((hModule == 21) && cmd_line) hModule = PE_LoadModule( hFile, &ofs, cmd_line, env, show_cmd ); } if (hModule < 32) fprintf( stderr, "LoadModule: can't load '%s', error=%d\n", name, hModule ); _lclose32( hFile ); return hModule; } else /* module is already loaded, just create a new data segment if it's a task */ { pModule = MODULE_GetPtr32( hModule ); hInstance = MODULE_CreateInstance( hModule, &hPrevInstance, (cmd_line == NULL) ); if (hInstance != hPrevInstance) /* not a library */ NE_LoadSegment( pModule, pModule->dgroup ); pModule->count++; } } /* !winelib */ /* Create a task for this instance */ if (cmd_line && !(pModule->flags & NE_FFLAGS_LIBMODULE)) { PDB32 *pdb; pModule->flags |= NE_FFLAGS_GUI; pdb = PROCESS_Create( pModule, cmd_line, env, hInstance, hPrevInstance, show_cmd ); if (pdb && (GetNumTasks() > 1)) Yield16(); } return hInstance; } /********************************************************************** * LoadModule16 (KERNEL.45) */ HINSTANCE16 LoadModule16( LPCSTR name, LPVOID paramBlock ) { LOADPARAMS *params = (LOADPARAMS *)paramBlock; LPSTR cmd_line = (LPSTR)PTR_SEG_TO_LIN( params->cmdLine ); LPSTR new_cmd_line; UINT16 show_cmd = 0; LPCVOID env = NULL; HINSTANCE16 hInstance; if (!paramBlock || (paramBlock == (LPVOID)-1)) return LoadLibrary16( name ); params = (LOADPARAMS *)paramBlock; cmd_line = (LPSTR)PTR_SEG_TO_LIN( params->cmdLine ); /* PowerPoint passes NULL as showCmd */ if (params->showCmd) show_cmd = *((UINT16 *)PTR_SEG_TO_LIN(params->showCmd)+1); if (!cmd_line) cmd_line = ""; else if (*cmd_line) cmd_line++; /* skip the length byte */ if (!(new_cmd_line = HeapAlloc( GetProcessHeap(), 0, strlen(cmd_line) + strlen(name) + 2 ))) return 0; strcpy( new_cmd_line, name ); strcat( new_cmd_line, " " ); strcat( new_cmd_line, cmd_line ); if (params->hEnvironment) env = GlobalLock16( params->hEnvironment ); hInstance = MODULE_Load( name, 0, new_cmd_line, env, show_cmd ); if (params->hEnvironment) GlobalUnlock16( params->hEnvironment ); HeapFree( GetProcessHeap(), 0, new_cmd_line ); return hInstance; } /********************************************************************** * LoadModule32 (KERNEL32.499) * * FIXME * * This should get implemented via CreateProcess -- MODULE_Load * is resolutely 16-bit. */ DWORD LoadModule32( LPCSTR name, LPVOID paramBlock ) { LOADPARAMS32 *params = (LOADPARAMS32 *)paramBlock; #if 0 STARTUPINFO st; PROCESSINFORMATION pi; st.cb = sizeof(STARTUPINFO); st.wShowWindow = p->lpCmdShow[2] ; WRONG BOOL32 ret = CreateProcess32A( name, p->lpCmdLine, NULL, NULL, FALSE, 0, p->lpEnvAddress, NULL, &st, &pi); if (!ret) { /* handle errors appropriately */ } CloseHandle32(pi.hProcess); CloseHandle32(pi.hThread); #else return MODULE_Load( name, 0, params->lpCmdLine, params->lpEnvAddress, *((UINT16 *)params->lpCmdShow + 1) ); #endif } /********************************************************************** * FreeModule16 (KERNEL.46) */ BOOL16 WINAPI FreeModule16( HMODULE16 hModule ) { NE_MODULE *pModule; if (!(pModule = MODULE_GetPtr16( hModule ))) return FALSE; TRACE(module, "%s count %d\n", MODULE_GetModuleName(hModule), pModule->count ); return MODULE_FreeModule( hModule, GlobalLock16(GetCurrentTask()) ); } /********************************************************************** * GetModuleHandle16 (KERNEL.47) */ HMODULE16 WINAPI WIN16_GetModuleHandle( SEGPTR name ) { if (HIWORD(name) == 0) return GetExePtr( (HINSTANCE16)name ); return MODULE_FindModule16( PTR_SEG_TO_LIN(name) ); } HMODULE16 WINAPI GetModuleHandle16( LPCSTR name ) { return MODULE_FindModule16( name ); } /*********************************************************************** * GetModuleHandle (KERNEL32.237) */ HMODULE32 WINAPI GetModuleHandle32A(LPCSTR module) { TRACE(win32, "%s\n", module ? module : "NULL"); if (module == NULL) return PROCESS_Current()->exe_modref->module; else return MODULE_FindModule32(PROCESS_Current(),module); } HMODULE32 WINAPI GetModuleHandle32W(LPCWSTR module) { HMODULE32 hModule; LPSTR modulea = HEAP_strdupWtoA( GetProcessHeap(), 0, module ); hModule = GetModuleHandle32A( modulea ); HeapFree( GetProcessHeap(), 0, modulea ); return hModule; } /********************************************************************** * GetModuleUsage (KERNEL.48) */ INT16 WINAPI GetModuleUsage( HINSTANCE16 hModule ) { NE_MODULE *pModule; if (!(pModule = MODULE_GetPtr16( hModule ))) return 0; TRACE(module, "(%04x): returning %d\n", hModule, pModule->count ); return pModule->count; } /********************************************************************** * GetModuleFileName16 (KERNEL.49) */ INT16 WINAPI GetModuleFileName16( HINSTANCE16 hModule, LPSTR lpFileName, INT16 nSize ) { NE_MODULE *pModule; if (!hModule) hModule = GetCurrentTask(); if (!(pModule = MODULE_GetPtr16( hModule ))) return 0; lstrcpyn32A( lpFileName, NE_MODULE_NAME(pModule), nSize ); TRACE(module, "%s\n", lpFileName ); return strlen(lpFileName); } /*********************************************************************** * GetModuleFileName32A (KERNEL32.235) * FIXME FIXME */ DWORD WINAPI GetModuleFileName32A( HMODULE32 hModule, LPSTR lpFileName, DWORD size ) { NE_MODULE *pModule; if (!hModule) { TDB *pTask = (TDB *)GlobalLock16( GetCurrentTask() ); hModule = pTask->hInstance; } if (!(pModule = MODULE_GetPtr32( hModule ))) return 0; lstrcpyn32A( lpFileName, NE_MODULE_NAME(pModule), size ); TRACE(module, "%s\n", lpFileName ); return strlen(lpFileName); } /*********************************************************************** * GetModuleFileName32W (KERNEL32.236) */ DWORD WINAPI GetModuleFileName32W( HMODULE32 hModule, LPWSTR lpFileName, DWORD size ) { LPSTR fnA = (char*)HeapAlloc( GetProcessHeap(), 0, size ); DWORD res = GetModuleFileName32A( hModule, fnA, size ); lstrcpynAtoW( lpFileName, fnA, size ); HeapFree( GetProcessHeap(), 0, fnA ); return res; } /********************************************************************** * GetModuleName (KERNEL.27) */ BOOL16 WINAPI GetModuleName( HINSTANCE16 hinst, LPSTR buf, INT16 nSize ) { LPSTR name = MODULE_GetModuleName(hinst); if (!name) return FALSE; lstrcpyn32A( buf, name, nSize ); return TRUE; } /*********************************************************************** * LoadLibraryEx32W (KERNEL.513) * FIXME */ HMODULE32 WINAPI LoadLibraryEx32W16( LPCSTR libname, HANDLE16 hf, DWORD flags ) { TRACE(module,"(%s,%d,%08lx)\n",libname,hf,flags); return LoadLibraryEx32A(libname, hf,flags); } /*********************************************************************** * LoadLibraryEx32A (KERNEL32) */ HMODULE32 WINAPI LoadLibraryEx32A(LPCSTR libname,HFILE32 hfile,DWORD flags) { HMODULE32 hmod; hmod = PE_LoadLibraryEx32A(libname,PROCESS_Current(),hfile,flags); if (hmod < 32) { char buffer[256]; strcpy( buffer, libname ); strcat( buffer, ".dll" ); hmod = PE_LoadLibraryEx32A(buffer,PROCESS_Current(),hfile,flags); } /* initialize all DLLs, which haven't been initialized yet. */ if (hmod >= 32) PE_InitializeDLLs( PROCESS_Current(), DLL_PROCESS_ATTACH, NULL); return hmod; } /*********************************************************************** * LoadLibraryA (KERNEL32) */ HMODULE32 WINAPI LoadLibrary32A(LPCSTR libname) { return LoadLibraryEx32A(libname,0,0); } /*********************************************************************** * LoadLibraryW (KERNEL32) */ HMODULE32 WINAPI LoadLibrary32W(LPCWSTR libnameW) { return LoadLibraryEx32W(libnameW,0,0); } /*********************************************************************** * LoadLibraryExW (KERNEL32) */ HMODULE32 WINAPI LoadLibraryEx32W(LPCWSTR libnameW,HFILE32 hfile,DWORD flags) { LPSTR libnameA = HEAP_strdupWtoA( GetProcessHeap(), 0, libnameW ); HMODULE32 ret = LoadLibraryEx32A( libnameA , hfile, flags ); HeapFree( GetProcessHeap(), 0, libnameA ); return ret; } /*********************************************************************** * FreeLibrary */ BOOL32 WINAPI FreeLibrary32(HINSTANCE32 hLibModule) { TRACE(module,"hLibModule=%08x\n", hLibModule); return MODULE_FreeModule(hLibModule,GlobalLock16(GetCurrentTask()) ); } /*********************************************************************** * LoadLibrary (KERNEL.95) */ HINSTANCE16 WINAPI LoadLibrary16( LPCSTR libname ) { HINSTANCE16 handle; TRACE(module, "(%08x) %s\n", (int)libname, libname); handle = MODULE_Load( libname, 0, NULL, NULL, 0 ); if (handle == (HINSTANCE16)2) /* file not found */ { char buffer[256]; lstrcpyn32A( buffer, libname, 252 ); strcat( buffer, ".dll" ); handle = MODULE_Load( buffer, 0, NULL, NULL, 0 ); } return handle; } /*********************************************************************** * PrivateLoadLibrary (KERNEL32) * * FIXME: rough guesswork, don't know what "Private" means */ HINSTANCE32 WINAPI PrivateLoadLibrary(LPCSTR libname) { return (HINSTANCE32)LoadLibrary16(libname); } /*********************************************************************** * FreeLibrary16 (KERNEL.96) */ void WINAPI FreeLibrary16( HINSTANCE16 handle ) { TRACE(module,"%04x\n", handle ); FreeModule16( handle ); } /*********************************************************************** * PrivateFreeLibrary (KERNEL32) * * FIXME: rough guesswork, don't know what "Private" means */ void WINAPI PrivateFreeLibrary(HINSTANCE32 handle) { FreeLibrary16((HINSTANCE16)handle); } /*********************************************************************** * WinExec16 (KERNEL.166) */ HINSTANCE16 WINAPI WinExec16( LPCSTR lpCmdLine, UINT16 nCmdShow ) { return WinExec32( lpCmdLine, nCmdShow ); } /*********************************************************************** * WinExec32 (KERNEL32.566) */ HINSTANCE32 WINAPI WinExec32( LPCSTR lpCmdLine, UINT32 nCmdShow ) { HINSTANCE32 handle = 2; char *p, filename[256]; static int use_load_module = 1; int spacelimit = 0, exhausted = 0; if (!lpCmdLine) return 2; /* File not found */ /* Keep trying to load a file by trying different filenames; e.g., for the cmdline "abcd efg hij", try "abcd" with args "efg hij", then "abcd efg" with arg "hij", and finally "abcd efg hij" with no args */ while(!exhausted && handle == 2) { int spacecount = 0; /* Build the filename and command-line */ lstrcpyn32A(filename, lpCmdLine, sizeof(filename) - 4 /* for extension */); /* Keep grabbing characters until end-of-string, tab, or until the number of spaces is greater than the spacelimit */ for (p = filename; ; p++) { if(*p == ' ') { ++spacecount; if(spacecount > spacelimit) { ++spacelimit; break; } } if(*p == '\0' || *p == '\t') { exhausted = 1; break; } } *p = '\0'; /* Now load the executable file */ if (use_load_module) { /* Winelib: Use LoadModule() only for the program itself */ if (__winelib) use_load_module = 0; handle = MODULE_Load( filename, 0, lpCmdLine, NULL, nCmdShow ); if (handle == 2) /* file not found */ { /* Check that the original file name did not have a suffix */ p = strrchr(filename, '.'); /* if there is a '.', check if either \ OR / follow */ if (!p || strchr(p, '/') || strchr(p, '\\')) { p = filename + strlen(filename); strcpy( p, ".exe" ); handle = MODULE_Load( filename, 0, lpCmdLine, NULL, nCmdShow ); *p = '\0'; /* Remove extension */ } } } else handle = 2; /* file not found */ if (handle < 32) { /* Try to start it as a unix program */ if (!fork()) { /* Child process */ DOS_FULL_NAME full_name; const char *unixfilename = NULL; const char *argv[256], **argptr; int iconic = (nCmdShow == SW_SHOWMINIMIZED || nCmdShow == SW_SHOWMINNOACTIVE); THREAD_InitDone = FALSE; /* we didn't init this process */ /* get unixfilename */ if (strchr(filename, '/') || strchr(filename, ':') || strchr(filename, '\\')) { if (DOSFS_GetFullName( filename, TRUE, &full_name )) unixfilename = full_name.long_name; } else unixfilename = filename; if (unixfilename) { /* build argv */ argptr = argv; if (iconic) *argptr++ = "-iconic"; *argptr++ = unixfilename; p = strdup(lpCmdLine); while (1) { while (*p && (*p == ' ' || *p == '\t')) *p++ = '\0'; if (!*p) break; *argptr++ = p; while (*p && *p != ' ' && *p != '\t') p++; } *argptr++ = 0; /* Execute */ execvp(argv[0], (char**)argv); } /* Failed ! */ if (__winelib) { /* build argv */ argptr = argv; *argptr++ = "wine"; if (iconic) *argptr++ = "-iconic"; *argptr++ = lpCmdLine; *argptr++ = 0; /* Execute */ execvp(argv[0] , (char**)argv); /* Failed ! */ MSG("WinExec: can't exec 'wine %s'\n", lpCmdLine); } exit(1); } } } /* while (!exhausted && handle < 32) */ return handle; } /*********************************************************************** * WIN32_GetProcAddress16 (KERNEL32.36) * Get procaddress in 16bit module from win32... (kernel32 undoc. ordinal func) */ FARPROC16 WINAPI WIN32_GetProcAddress16( HMODULE32 hModule, LPSTR name ) { WORD ordinal; FARPROC16 ret; if (!hModule) { WARN(module,"hModule may not be 0!\n"); return (FARPROC16)0; } hModule = MODULE_HANDLEtoHMODULE16(hModule); if (HIWORD(name)) { ordinal = NE_GetOrdinal( hModule, name ); TRACE(module, "%04x '%s'\n", hModule, name ); } else { ordinal = LOWORD(name); TRACE(module, "%04x %04x\n", hModule, ordinal ); } if (!ordinal) return (FARPROC16)0; ret = NE_GetEntryPoint( hModule, ordinal ); TRACE(module,"returning %08x\n",(UINT32)ret); return ret; } /*********************************************************************** * GetProcAddress16 (KERNEL.50) */ FARPROC16 WINAPI GetProcAddress16( HMODULE16 hModule, SEGPTR name ) { WORD ordinal; FARPROC16 ret; if (!hModule) hModule = GetCurrentTask(); hModule = GetExePtr( hModule ); if (HIWORD(name) != 0) { ordinal = NE_GetOrdinal( hModule, (LPSTR)PTR_SEG_TO_LIN(name) ); TRACE(module, "%04x '%s'\n", hModule, (LPSTR)PTR_SEG_TO_LIN(name) ); } else { ordinal = LOWORD(name); TRACE(module, "%04x %04x\n", hModule, ordinal ); } if (!ordinal) return (FARPROC16)0; ret = NE_GetEntryPoint( hModule, ordinal ); TRACE(module, "returning %08x\n", (UINT32)ret ); return ret; } /*********************************************************************** * GetProcAddress32 (KERNEL32.257) */ FARPROC32 WINAPI GetProcAddress32( HMODULE32 hModule, LPCSTR function ) { return MODULE_GetProcAddress32( PROCESS_Current(), hModule, function ); } /*********************************************************************** * MODULE_GetProcAddress32 (internal) */ FARPROC32 MODULE_GetProcAddress32( PDB32 *process, /* [in] process context */ HMODULE32 hModule, /* [in] current module handle */ LPCSTR function ) /* [in] function to be looked up */ { WINE_MODREF *wm = MODULE32_LookupHMODULE(process,hModule); if (HIWORD(function)) TRACE(win32,"(%08lx,%s)\n",(DWORD)hModule,function); else TRACE(win32,"(%08lx,%p)\n",(DWORD)hModule,function); if (!wm) return (FARPROC32)0; switch (wm->type) { case MODULE32_PE: return PE_FindExportedFunction( process, wm, function); default: ERR(module,"wine_modref type %d not handled.\n",wm->type); return (FARPROC32)0; } } /*********************************************************************** * RtlImageNtHeaders (NTDLL) */ LPIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE32 hModule) { /* basically: * return hModule+(((IMAGE_DOS_HEADER*)hModule)->e_lfanew); * but we could get HMODULE16 or the like (think builtin modules) */ WINE_MODREF *wm = MODULE32_LookupHMODULE( PROCESS_Current(), hModule ); if (!wm || (wm->type != MODULE32_PE)) return (LPIMAGE_NT_HEADERS)0; return PE_HEADER(wm->module); } /********************************************************************** * GetExpWinVer (KERNEL.167) */ WORD WINAPI GetExpWinVer( HMODULE16 hModule ) { NE_MODULE *pModule = MODULE_GetPtr16( hModule ); return pModule ? pModule->expected_version : 0; } /********************************************************************** * IsSharedSelector (KERNEL.345) */ BOOL16 WINAPI IsSharedSelector( HANDLE16 selector ) { /* Check whether the selector belongs to a DLL */ NE_MODULE *pModule = MODULE_GetPtr16( selector ); if (!pModule) return FALSE; return (pModule->flags & NE_FFLAGS_LIBMODULE) != 0; } /********************************************************************** * ModuleFirst (TOOLHELP.59) */ BOOL16 WINAPI ModuleFirst( MODULEENTRY *lpme ) { lpme->wNext = hFirstModule; return ModuleNext( lpme ); } /********************************************************************** * ModuleNext (TOOLHELP.60) */ BOOL16 WINAPI ModuleNext( MODULEENTRY *lpme ) { NE_MODULE *pModule; char *name; if (!lpme->wNext) return FALSE; if (!(pModule = MODULE_GetPtr16( lpme->wNext ))) return FALSE; name = (char *)pModule + pModule->name_table; memcpy( lpme->szModule, name + 1, *name ); lpme->szModule[(BYTE)*name] = '\0'; lpme->hModule = lpme->wNext; lpme->wcUsage = pModule->count; strncpy( lpme->szExePath, NE_MODULE_NAME(pModule), MAX_PATH ); lpme->szExePath[MAX_PATH] = '\0'; lpme->wNext = pModule->next; return TRUE; } /********************************************************************** * ModuleFindName (TOOLHELP.61) */ BOOL16 WINAPI ModuleFindName( MODULEENTRY *lpme, LPCSTR name ) { lpme->wNext = GetModuleHandle16( name ); return ModuleNext( lpme ); } /********************************************************************** * ModuleFindHandle (TOOLHELP.62) */ BOOL16 WINAPI ModuleFindHandle( MODULEENTRY *lpme, HMODULE16 hModule ) { hModule = GetExePtr( hModule ); lpme->wNext = hModule; return ModuleNext( lpme ); }