| 1 | /* $Id: windlllx.cpp,v 1.20 2001-06-15 09:42:48 bird Exp $ */
|
|---|
| 2 |
|
|---|
| 3 | /*
|
|---|
| 4 | * Win32 LX Dll class (compiled in OS/2 using Odin32 api)
|
|---|
| 5 | *
|
|---|
| 6 | * Copyright 1999-2000 Sander van Leeuwen (sandervl@xs4all.nl)
|
|---|
| 7 | *
|
|---|
| 8 | * TODO: Unloading of dlls probably needs to be fixed due to OS/2 bug
|
|---|
| 9 | * (wrong unload order of dlls)
|
|---|
| 10 | *
|
|---|
| 11 | * Project Odin Software License can be found in LICENSE.TXT
|
|---|
| 12 | *
|
|---|
| 13 | */
|
|---|
| 14 | #define INCL_DOSFILEMGR /* File Manager values */
|
|---|
| 15 | #define INCL_DOSERRORS /* DOS Error values */
|
|---|
| 16 | #define INCL_DOSPROCESS /* DOS Process values */
|
|---|
| 17 | #define INCL_DOSMODULEMGR
|
|---|
| 18 | #define INCL_DOSMISC /* DOS Miscellanous values */
|
|---|
| 19 | #define INCL_WIN
|
|---|
| 20 | #include <os2wrap.h> //Odin32 OS/2 api wrappers
|
|---|
| 21 | #include <os2newapi.h>
|
|---|
| 22 | #include <stdio.h>
|
|---|
| 23 | #include <string.h>
|
|---|
| 24 | #include <stdlib.h>
|
|---|
| 25 | #include <iostream.h>
|
|---|
| 26 | #include <fstream.h>
|
|---|
| 27 | #include <misc.h>
|
|---|
| 28 | #include <win32type.h>
|
|---|
| 29 | #include <windllbase.h>
|
|---|
| 30 | #include <windlllx.h>
|
|---|
| 31 | #include "winexepe2lx.h"
|
|---|
| 32 | #include "winexepeldr.h"
|
|---|
| 33 | #include <odinlx.h>
|
|---|
| 34 | #include <wprocess.h>
|
|---|
| 35 | #include "oslibmisc.h"
|
|---|
| 36 |
|
|---|
| 37 | #include <exe386.h>
|
|---|
| 38 |
|
|---|
| 39 | #define DBG_LOCALLOG DBG_windlllx
|
|---|
| 40 | #include "dbglocal.h"
|
|---|
| 41 |
|
|---|
| 42 | //******************************************************************************
|
|---|
| 43 | //Create LX Dll object and send process attach message
|
|---|
| 44 | //System dlls set EntryPoint to 0
|
|---|
| 45 | //Parameters:
|
|---|
| 46 | // HINSTANCE hInstance - OS/2 module handle
|
|---|
| 47 | // WIN32DLLENTRY EntryPoint - Win32 dll entrypoint address
|
|---|
| 48 | // PVOID pResData - pointer to win32 resource data
|
|---|
| 49 | // DWORD MajorImageVersion - major image/os version (for fake win32 header)
|
|---|
| 50 | // DWORD MinorImageVersion - minor image/os version (for fake win32 header)
|
|---|
| 51 | // DWORD Subsystem - subsystem type (for fake win32 header)
|
|---|
| 52 | // (IMAGE_SUBSYSTEM_WINDOWS_CUI/IMAGE_SUBSYSTEM_WINDOWS_GUI)
|
|---|
| 53 | //
|
|---|
| 54 | //Returns: Odin32 module handle
|
|---|
| 55 | //******************************************************************************
|
|---|
| 56 | DWORD WIN32API RegisterLxDll(HINSTANCE hInstance, WIN32DLLENTRY EntryPoint,
|
|---|
| 57 | PVOID pResData,
|
|---|
| 58 | DWORD MajorImageVersion,
|
|---|
| 59 | DWORD MinorImageVersion,
|
|---|
| 60 | DWORD Subsystem)
|
|---|
| 61 | {
|
|---|
| 62 | APIRET rc;
|
|---|
| 63 | Win32LxDll *windll;
|
|---|
| 64 | Win32DllBase *windlldep;
|
|---|
| 65 | char szFileName[CCHMAXPATH], szErrName[CCHMAXPATH];
|
|---|
| 66 |
|
|---|
| 67 | if(OSLibGetDllName(hInstance, szFileName, sizeof(szFileName)) == FALSE) {
|
|---|
| 68 | dprintf(("ERROR: RegisterLxDll: OSLibGetDllName %x failed!!", hInstance));
|
|---|
| 69 | return 0;
|
|---|
| 70 | }
|
|---|
| 71 | dprintf(("RegisterLxDll %x %s", hInstance, szFileName));
|
|---|
| 72 | //Make sure DosLoadModule is called at least once for a dll (to make sure
|
|---|
| 73 | //OS/2 doesn't unload the dll when it's still needed)
|
|---|
| 74 | rc = DosLoadModule(szErrName, sizeof(szErrName), szFileName, &hInstance);
|
|---|
| 75 | if(rc != 0) {
|
|---|
| 76 | dprintf(("ERROR: RegisterLxDll: DosLoadModule %s failed (rc=%d)!!", szFileName, rc));
|
|---|
| 77 | return 0;
|
|---|
| 78 | }
|
|---|
| 79 |
|
|---|
| 80 | windll = new Win32LxDll(hInstance, EntryPoint, pResData, MajorImageVersion,
|
|---|
| 81 | MinorImageVersion, Subsystem);
|
|---|
| 82 | if(windll == NULL) {
|
|---|
| 83 | dprintf(("RegisterLxDll: windll == NULL!!!"));
|
|---|
| 84 | return 0;
|
|---|
| 85 | }
|
|---|
| 86 | if(!fPeLoader) {
|
|---|
| 87 | windll->AddRef();
|
|---|
| 88 |
|
|---|
| 89 | if(windll->attachProcess() == 0)
|
|---|
| 90 | return 0;
|
|---|
| 91 |
|
|---|
| 92 | return windll->getInstanceHandle();
|
|---|
| 93 | }
|
|---|
| 94 | IMAGE_DOS_HEADER doshdr;
|
|---|
| 95 | struct e32_exe lxhdr;
|
|---|
| 96 | ULONG offset;
|
|---|
| 97 | char modulename[CCHMAXPATH];
|
|---|
| 98 | char modsize;
|
|---|
| 99 | int i;
|
|---|
| 100 |
|
|---|
| 101 | //SvL: This code reads the import name table of the dll to get the dependencies
|
|---|
| 102 | // on other dlls.
|
|---|
| 103 | //DosQueryHeaderInfo is an undocumented api, but works very well.
|
|---|
| 104 | //(no need to save FS here as we'll return to OS/2 immediately)
|
|---|
| 105 | rc = DosQueryHeaderInfo(hInstance, 0, &doshdr, sizeof(IMAGE_DOS_HEADER), QHINF_READFILE);
|
|---|
| 106 | if(rc) {
|
|---|
| 107 | goto hdrerror;
|
|---|
| 108 | }
|
|---|
| 109 | rc = DosQueryHeaderInfo(hInstance, doshdr.e_lfanew, &lxhdr, sizeof(e32_exe), QHINF_READFILE);
|
|---|
| 110 | if(rc) {
|
|---|
| 111 | goto hdrerror;
|
|---|
| 112 | }
|
|---|
| 113 | offset = doshdr.e_lfanew + lxhdr.e32_impmod;
|
|---|
| 114 | for(i=0;i<lxhdr.e32_impmodcnt;i++) {
|
|---|
| 115 | rc = DosQueryHeaderInfo(hInstance, offset, &modsize, 1, QHINF_READFILE);
|
|---|
| 116 | if(rc) {
|
|---|
| 117 | goto hdrerror;
|
|---|
| 118 | }
|
|---|
| 119 | rc = DosQueryHeaderInfo(hInstance, offset+1, &modulename, min(modsize, sizeof(modulename)), QHINF_READFILE);
|
|---|
| 120 | if(rc) {
|
|---|
| 121 | goto hdrerror;
|
|---|
| 122 | }
|
|---|
| 123 | modulename[modsize] = 0;
|
|---|
| 124 | windlldep = Win32DllBase::findModule(modulename, TRUE);
|
|---|
| 125 | if(windlldep && strcmp(windlldep->getModuleName(), windll->getModuleName())) {
|
|---|
| 126 | dprintf(("RegisterLxDll: Add dependency %s -> %s", windll->getModuleName(), modulename));
|
|---|
| 127 | windll->addDependency(windlldep);
|
|---|
| 128 | }
|
|---|
| 129 | else dprintf(("HARMLESS WARNING: Can't find dll %s referenced by %s", modulename, windll->getModuleName()));
|
|---|
| 130 | offset += modsize + 1;
|
|---|
| 131 | }
|
|---|
| 132 | return windll->getInstanceHandle();
|
|---|
| 133 |
|
|---|
| 134 | hdrerror:
|
|---|
| 135 | dprintf(("DosQueryHeaderInfo returned %d", rc));
|
|---|
| 136 | return windll->getInstanceHandle();
|
|---|
| 137 | }
|
|---|
| 138 | //******************************************************************************
|
|---|
| 139 | //Destroy LX Dll object
|
|---|
| 140 | //******************************************************************************
|
|---|
| 141 | BOOL WIN32API UnregisterLxDll(HINSTANCE hInstance)
|
|---|
| 142 | {
|
|---|
| 143 | Win32DllBase *windll;
|
|---|
| 144 |
|
|---|
| 145 | //Don't proceed for pe2lx/win32k (os/2 dll unload dependency bug)
|
|---|
| 146 | //Don't do it either after ExitProcess has been called
|
|---|
| 147 | if(!fPeLoader || WinExe == NULL)
|
|---|
| 148 | return TRUE;
|
|---|
| 149 |
|
|---|
| 150 | windll = Win32DllBase::findModule(hInstance);
|
|---|
| 151 | if(!windll) {
|
|---|
| 152 | dprintf(("UnregisterLxDll: Can't find dll with handle %x (already deleted)", hInstance));
|
|---|
| 153 | return TRUE; //already deleted by Win32LxDll::Release
|
|---|
| 154 | }
|
|---|
| 155 | dprintf(("UnregisterLxDll %s", windll->getModuleName()));
|
|---|
| 156 | //This can only happen for LX dependencies (i.e. wininet loads wsock32)
|
|---|
| 157 | delete windll;
|
|---|
| 158 | return TRUE;
|
|---|
| 159 | }
|
|---|
| 160 | //******************************************************************************
|
|---|
| 161 | //******************************************************************************
|
|---|
| 162 | Win32LxDll::Win32LxDll(HINSTANCE hInstance, WIN32DLLENTRY EntryPoint, PVOID pResData,
|
|---|
| 163 | DWORD MajorImageVersion, DWORD MinorImageVersion,
|
|---|
| 164 | DWORD Subsystem)
|
|---|
| 165 | : Win32ImageBase(hInstance),
|
|---|
| 166 | Win32LxImage(hInstance, pResData),
|
|---|
| 167 | Win32DllBase(hInstance, EntryPoint)
|
|---|
| 168 | {
|
|---|
| 169 | this->MajorImageVersion = MajorImageVersion;
|
|---|
| 170 | this->MinorImageVersion = MinorImageVersion;
|
|---|
| 171 | this->Subsystem = Subsystem;
|
|---|
| 172 |
|
|---|
| 173 | if(EntryPoint == NULL) {
|
|---|
| 174 | fSkipThreadEntryCalls = TRUE;
|
|---|
| 175 | fAttachedToProcess = TRUE;
|
|---|
| 176 | }
|
|---|
| 177 | hinstanceOS2 = hInstance;
|
|---|
| 178 | //new win32 instance handle must be pointer to PE header
|
|---|
| 179 | hinstance = (HINSTANCE)buildHeader(MajorImageVersion, MinorImageVersion,
|
|---|
| 180 | Subsystem);
|
|---|
| 181 | dprintf(("Fake PE header %x for dll %s", hinstance, getModuleName()));
|
|---|
| 182 | }
|
|---|
| 183 | //******************************************************************************
|
|---|
| 184 | //******************************************************************************
|
|---|
| 185 | Win32LxDll::~Win32LxDll()
|
|---|
| 186 | {
|
|---|
| 187 | }
|
|---|
| 188 | //******************************************************************************
|
|---|
| 189 | //Returns reference count or -1 if load failed (PE loader only!)
|
|---|
| 190 | //******************************************************************************
|
|---|
| 191 | #ifdef DEBUG
|
|---|
| 192 | ULONG Win32LxDll::AddRef(char *parentname)
|
|---|
| 193 | #else
|
|---|
| 194 | ULONG Win32LxDll::AddRef()
|
|---|
| 195 | #endif
|
|---|
| 196 | {
|
|---|
| 197 | Win32DllBase *dll;
|
|---|
| 198 | QueueItem *item;
|
|---|
| 199 | ULONG ret;
|
|---|
| 200 |
|
|---|
| 201 | #ifdef DEBUG
|
|---|
| 202 | ret = Win32DllBase::AddRef(parentname);
|
|---|
| 203 | #else
|
|---|
| 204 | ret = Win32DllBase::AddRef();
|
|---|
| 205 | #endif
|
|---|
| 206 |
|
|---|
| 207 | if(!fPeLoader)
|
|---|
| 208 | return ret;
|
|---|
| 209 |
|
|---|
| 210 | if(referenced == 1)
|
|---|
| 211 | {
|
|---|
| 212 | item = loadedDlls.Head();
|
|---|
| 213 | while(item) {
|
|---|
| 214 | dll = (Win32DllBase *)loadedDlls.getItem(item);
|
|---|
| 215 | if(dll == NULL) {
|
|---|
| 216 | dprintf(("ERROR: Win32DllBase::AddRef: dll item == NULL!!"));
|
|---|
| 217 | DebugInt3();
|
|---|
| 218 | return -1;
|
|---|
| 219 | }
|
|---|
| 220 | #ifdef DEBUG
|
|---|
| 221 | dll->AddRef(getModuleName());
|
|---|
| 222 | #else
|
|---|
| 223 | dll->AddRef();
|
|---|
| 224 | #endif
|
|---|
| 225 | item = loadedDlls.getNext(item);
|
|---|
| 226 | }
|
|---|
| 227 | if(attachProcess() == 0) {
|
|---|
| 228 | dprintf(("WARNING: Dll %s refused to be loaded; aborting", getName()));
|
|---|
| 229 | return -1;
|
|---|
| 230 | }
|
|---|
| 231 | }
|
|---|
| 232 | return ret;
|
|---|
| 233 | }
|
|---|
| 234 | //******************************************************************************
|
|---|
| 235 | //******************************************************************************
|
|---|
| 236 | ULONG Win32LxDll::Release()
|
|---|
| 237 | {
|
|---|
| 238 | HINSTANCE hinst;
|
|---|
| 239 | WIN32DLLENTRY EntryPointTmp = dllEntryPoint;
|
|---|
| 240 | PVOID pResDataTmp = (PVOID)pResRootDir;
|
|---|
| 241 | DWORD MajorImageVersionTmp = MajorImageVersion;
|
|---|
| 242 | DWORD MinorImageVersionTmp = MinorImageVersion;
|
|---|
| 243 | DWORD SubsystemTmp = Subsystem;
|
|---|
| 244 | ULONG ret;
|
|---|
| 245 | APIRET rc;
|
|---|
| 246 | BOOL fNoUnload = fDisableUnload; //only set for kernel32.dll
|
|---|
| 247 | Win32LxDll *pModule;
|
|---|
| 248 |
|
|---|
| 249 | hinst = hinstanceOS2;
|
|---|
| 250 | ret = Win32DllBase::Release();
|
|---|
| 251 | if(ret == 0 && !fNoUnload) {//only set for kernel32.dll (fDisableUnload)
|
|---|
| 252 | //DosFreeModule sends a termination message to the dll.
|
|---|
| 253 | //The LX dll informs us when it's removed (UnregisterDll call)
|
|---|
| 254 | rc = DosFreeModule(hinst);
|
|---|
| 255 | if(rc) {
|
|---|
| 256 | dprintf(("Win32LxDll::Release: DosFreeModule %x returned %d", hinst, rc));
|
|---|
| 257 | if(rc == ERROR_INVALID_ACCESS && !fExitProcess) {
|
|---|
| 258 | //Dll refused to unload because it has an active exitlist handler
|
|---|
| 259 | //or depends on a dll that registered an exitlist handler
|
|---|
| 260 | //In this case the handle remains valid and the entrypoint of
|
|---|
| 261 | //the dll is NOT called for DLL_PROCESS_DETACH
|
|---|
| 262 | //WORKAROUND: Re-register the dll so future LoadLibrary calls
|
|---|
| 263 | // don't fail!
|
|---|
| 264 | dprintf(("WORKAROUND: Re-register the dll so future LoadLibrary calls don't fail!"));
|
|---|
| 265 | RegisterLxDll(hinst, EntryPointTmp, pResDataTmp,
|
|---|
| 266 | MajorImageVersionTmp,
|
|---|
| 267 | MinorImageVersionTmp,
|
|---|
| 268 | SubsystemTmp);
|
|---|
| 269 |
|
|---|
| 270 | /* OS/2 dll, system dll, converted dll or win32k took care of it. */
|
|---|
| 271 | pModule = Win32LxDll::findModuleByOS2Handle(hinst);
|
|---|
| 272 | if(pModule)
|
|---|
| 273 | {
|
|---|
| 274 | pModule->setDllHandleOS2(hinst);
|
|---|
| 275 | if(fPeLoader)
|
|---|
| 276 | {
|
|---|
| 277 | if(pModule->AddRef() == -1) {//-1 -> load failed (attachProcess)
|
|---|
| 278 | dprintf(("ERROR Dll refused to be loaded; aborting"));
|
|---|
| 279 | DebugInt3();
|
|---|
| 280 | delete pModule;
|
|---|
| 281 | return 0;
|
|---|
| 282 | }
|
|---|
| 283 | }
|
|---|
| 284 | pModule->incDynamicLib();
|
|---|
| 285 | }
|
|---|
| 286 | else DebugInt3();
|
|---|
| 287 | }
|
|---|
| 288 | }
|
|---|
| 289 | }
|
|---|
| 290 | return(ret);
|
|---|
| 291 | }
|
|---|
| 292 | //******************************************************************************
|
|---|
| 293 | //******************************************************************************
|
|---|
| 294 | BOOL Win32LxDll::isPe2LxDll() const
|
|---|
| 295 | {
|
|---|
| 296 | return FALSE;
|
|---|
| 297 | }
|
|---|
| 298 | //******************************************************************************
|
|---|
| 299 | //******************************************************************************
|
|---|
| 300 | BOOL Win32LxDll::isLxDll() const
|
|---|
| 301 | {
|
|---|
| 302 | return TRUE;
|
|---|
| 303 | }
|
|---|
| 304 | //******************************************************************************
|
|---|
| 305 | //******************************************************************************
|
|---|
| 306 | void Win32LxDll::setDllHandleOS2(HINSTANCE hInstanceOS2)
|
|---|
| 307 | {
|
|---|
| 308 | //Loaded with LoadLibrary(Ex); no need for a 2nd DosLoadModule
|
|---|
| 309 | //Dlls that are indirectly loaded (i.e. GDI32->KERNEL32 dependancy) need
|
|---|
| 310 | //this additional DosLoadModule (and setDllHandleOS2 isn't called for those)
|
|---|
| 311 | if(this->hinstanceOS2) {
|
|---|
| 312 | DosFreeModule(this->hinstanceOS2);
|
|---|
| 313 | }
|
|---|
| 314 | this->hinstanceOS2 = hInstanceOS2;
|
|---|
| 315 | }
|
|---|
| 316 | //******************************************************************************
|
|---|
| 317 | //******************************************************************************
|
|---|
| 318 | Win32LxDll *Win32LxDll::findModuleByOS2Handle(HINSTANCE hinstance)
|
|---|
| 319 | {
|
|---|
| 320 | dlllistmutex.enter();
|
|---|
| 321 |
|
|---|
| 322 | Win32DllBase *mod = Win32DllBase::getFirst();
|
|---|
| 323 | while (mod != NULL)
|
|---|
| 324 | {
|
|---|
| 325 | if (mod->isLxDll())
|
|---|
| 326 | {
|
|---|
| 327 | Win32LxDll *lxdll = (Win32LxDll *)mod;
|
|---|
| 328 | if (lxdll->hinstanceOS2 == hinstance)
|
|---|
| 329 | {
|
|---|
| 330 | dlllistmutex.leave();
|
|---|
| 331 | return(lxdll);
|
|---|
| 332 | }
|
|---|
| 333 | }
|
|---|
| 334 | mod = mod->getNext();
|
|---|
| 335 | }
|
|---|
| 336 | dlllistmutex.leave();
|
|---|
| 337 | return(NULL);
|
|---|
| 338 | }
|
|---|
| 339 | //******************************************************************************
|
|---|
| 340 | //******************************************************************************
|
|---|
