source: trunk/src/kernel32/windllbase.cpp@ 4474

Last change on this file since 4474 was 4474, checked in by sandervl, 25 years ago

pe loader fixes, add system32\drivers dir during installation, add build date + time during kernel32 load
File size: 22.7 KB
Line 
1/* $Id: windllbase.cpp,v 1.18 2000-10-10 17:14:06 sandervl Exp $ */
2
3/*
4 * Win32 Dll base class
5 *
6 * Copyright 1998-1999 Sander van Leeuwen (sandervl@xs4all.nl)
7 *
8 * Unloading of a dll always happens in order of dependency (taking nr of
9 * loads into account)
10 * Unloading of dynamically loaded dll (with LoadLibrary) in deleteAll
11 * is done in LIFO order (NT exhibits the same behaviour)
12 *
13 * RemoveCircularDependency: TODO: Send process detach message here??
14 *
15 * Project Odin Software License can be found in LICENSE.TXT
16 *
17 */
18#define INCL_DOSFILEMGR /* File Manager values */
19#define INCL_DOSERRORS /* DOS Error values */
20#define INCL_DOSPROCESS /* DOS Process values */
21#define INCL_DOSMODULEMGR
22#define INCL_DOSMISC /* DOS Miscellanous values */
23#define INCL_WIN
24#include <os2wrap.h> //Odin32 OS/2 api wrappers
25#include <stdio.h>
26#include <string.h>
27#include <stdlib.h>
28#include <iostream.h>
29#include <fstream.h>
30#include <misc.h>
31#include <win32api.h>
32#include <pefile.h>
33#include <windllbase.h>
34#include <wprocess.h>
35#include "exceptions.h"
36#include "exceptutil.h"
37#include "cio.h"
38#include "vmutex.h"
39#include "oslibmisc.h"
40#include "oslibdos.h"
41#include "profile.h"
42
43#define DBG_LOCALLOG DBG_windllbase
44#include "dbglocal.h"
45
46VMutex dlllistmutex; //protects linked lists of heaps
47
48//******************************************************************************
49//******************************************************************************
50Win32DllBase::Win32DllBase(HINSTANCE hinstance, WIN32DLLENTRY DllEntryPoint,
51 Win32ImageBase *parent)
52 : Win32ImageBase(hinstance),
53 referenced(0), fSkipThreadEntryCalls(FALSE), next(NULL), fInserted(FALSE),
54 fAttachedToProcess(FALSE), fUnloaded(FALSE),
55 nrDynamicLibRef(0), fDisableUnload(FALSE), fSkipEntryCalls(FALSE)
56{
57 dllEntryPoint = DllEntryPoint;
58
59 setUnloadOrder(parent);
60
61 dprintf(("Win32DllBase::Win32DllBase %x %s", hinstance, szModule));
62}
63//******************************************************************************
64//******************************************************************************
65Win32DllBase::~Win32DllBase()
66{
67 dprintf(("Win32DllBase::~Win32DllBase %s", szModule));
68
69 if(errorState == NO_ERROR && !fUnloaded)
70 {
71 detachProcess();
72 }
73
74 dlllistmutex.enter();
75 if(head == this) {
76 head = next;
77 }
78 else {
79 Win32DllBase *dll = head;
80 while(dll && dll->next != this) {
81 dll = dll->next;
82 }
83 if(dll == NULL) {
84 dprintf(("~Win32DllBase: Can't find dll!\n"));
85 dlllistmutex.leave();
86 return;
87 }
88 dll->next = next;
89 }
90 dlllistmutex.leave();
91}
92//******************************************************************************
93//******************************************************************************
94void Win32DllBase::incDynamicLib()
95{
96 if(nrDynamicLibRef == 0) {
97 //NOTE:
98 //Must be called *after* attachprocess, since attachprocess may also
99 //trigger LoadLibrary calls
100 //Those dlls must not be put in front of this dll in the dynamic
101 //dll list; or else the unload order is wrong:
102 //i.e. RPAP3260 loads PNRS3260 in DLL_PROCESS_ATTACH
103 // this means that in ExitProcess, PNRS3260 needs to be removed
104 // first since RPAP3260 depends on it
105
106 dlllistmutex.enter();
107 loadLibDlls.Push((ULONG)this);
108 dlllistmutex.leave();
109 }
110 nrDynamicLibRef++;
111}
112//******************************************************************************
113//******************************************************************************
114void Win32DllBase::decDynamicLib()
115{
116 nrDynamicLibRef--;
117 if(nrDynamicLibRef == 0) {
118 dlllistmutex.enter();
119 loadLibDlls.Remove((ULONG)this);
120 dlllistmutex.leave();
121 }
122}
123//******************************************************************************
124//unload of dlls needs to be done in reverse order of dependencies
125//Note: Only necessary for pe loader; the OS/2 loader takes care of this
126//for win32k/pe2lx
127//******************************************************************************
128void Win32DllBase::setUnloadOrder(Win32ImageBase *parent)
129{
130 Win32DllBase *dll;
131 Win32DllBase *parentdll = NULL;
132
133 dlllistmutex.enter();
134 if(parent) {
135 dll = head;
136 while(dll) {
137 if(dll->getInstanceHandle() == parent->getInstanceHandle()) {
138 parentdll = dll;
139 break;
140 }
141 dll = dll->next;
142 }
143 }
144
145 //first check if this dll is already at a lower position (further down the list)
146 //than the parent
147 if(parentdll && fInserted) {//already in the list?
148 dll = parentdll->next;
149 while(dll) {
150 if(dll->getInstanceHandle() == getInstanceHandle()) {
151 dlllistmutex.leave();
152 return; //it's at a lower position, so no need to change anything
153 }
154 dll = dll->next;
155 }
156
157 //it's already in the list but not at the right position; remove it now
158 if(head == this) {
159 head = next;
160 }
161 else {
162 dll = head;
163 while(dll->next) {
164 if(dll->next == this) {
165 dll->next = next;
166 break;
167 }
168 dll = dll->next;
169 }
170 }
171 }
172 else
173 if(fInserted) {//already in the list?
174 dlllistmutex.leave();
175 return;
176 }
177 //(re)insert it in the list after it's parent
178 if(parentdll) {
179 next = parentdll->next;
180 parentdll->next = this;
181 }
182 else {//no parent or exe, just add it at the start of the list
183 next = head;
184 head = this;
185 }
186 fInserted = TRUE;
187
188 //Now do the same thing for the child dependencies
189 QueueItem *item;
190
191 item = loadedDlls.Head();
192 while(item) {
193 dll = (Win32DllBase *)loadedDlls.getItem(item);
194 //Check for circular dependencies (i.e. in Lotus Notes)
195 if(dll != parentdll) {
196 dll->setUnloadOrder(this);
197 }
198
199 item = loadedDlls.getNext(item);
200 }
201
202 dlllistmutex.leave();
203}
204//******************************************************************************
205//******************************************************************************
206#ifdef DEBUG
207ULONG Win32DllBase::AddRef(char *parentname)
208#else
209ULONG Win32DllBase::AddRef()
210#endif
211{
212 Win32DllBase *dll;
213
214 dprintf(("Win32DllBase::AddRef %s->%s %d", parentname, getModuleName(), referenced+1));
215 ++referenced;
216#ifdef DEBUG
217 if(referenced == 1) {
218#ifdef DEBUG_ENABLELOG_LEVEL2
219 printListOfDlls();
220#endif
221 //printDependencies(NULL);
222 }
223#endif
224
225 return referenced;
226}
227//******************************************************************************
228//******************************************************************************
229ULONG Win32DllBase::Release()
230{
231 Queue queue;
232 QueueItem *item;
233 Win32DllBase *dll;
234 LONG ret;
235
236 dprintf(("Win32DllBase::Release %s %d", getModuleName(), referenced-1));
237
238 ret = --referenced;
239 if(ret <= 0) {
240 //make copy of linked list of dependencies
241 queue = loadedDlls;
242
243 //remove any circular dependencies on this dll that might be present
244 item = queue.Head();
245 while(item) {
246 dll = (Win32DllBase *)queue.getItem(item);
247 if(dll == NULL) {
248 dprintf(("ERROR: Win32DllBase::Release: dll item == NULL!!"));
249 DebugInt3();
250 return -1;
251 }
252 dll->RemoveCircularDependency(this);
253 item = queue.getNext(item);
254 }
255#ifdef DEBUG
256 //printDependencies(NULL);
257#endif
258 dprintf(("Win32DllBase::Release %s referenced == 0", getModuleName()));
259
260 //delete dll object
261 delete this;
262
263 //unreference all of it's dependencies
264 item = queue.Head();
265 while(item) {
266 dll = (Win32DllBase *)queue.getItem(item);
267 if(dll == NULL) {
268 dprintf(("ERROR: Win32DllBase::Release: dll item == NULL!!"));
269 DebugInt3();
270 return -1;
271 }
272 dll->Release();
273 item = queue.getNext(item);
274 }
275 }
276 return(ret);
277}
278//******************************************************************************
279//Lotus Notes has several ugly circular dependencies in it's dlls.
280//Remove them before they cause problems.
281//******************************************************************************
282BOOL Win32DllBase::RemoveCircularDependency(Win32DllBase *parent)
283{
284 QueueItem *item, *tmp;
285 Win32DllBase *dll;
286 BOOL ret = FALSE;
287
288 //remove any circular dependencies on this dll that might be present
289 item = loadedDlls.Head();
290 while(item) {
291 dll = (Win32DllBase *)loadedDlls.getItem(item);
292 if(dll == NULL) {
293 dprintf(("ERROR: Win32DllBase::Release: dll item == NULL!!"));
294 DebugInt3();
295 return FALSE;
296 }
297 tmp = loadedDlls.getNext(item);
298 if(dll == parent) {
299 dprintf(("Removing CIRCULAR dependency %s->%s", parent->getModuleName(), dll->getModuleName()));
300 loadedDlls.Remove(item);
301 ret = TRUE;
302 }
303//// else ret |= dll->RemoveCircularDependency(parent);
304 item = tmp;
305 }
306 //TODO: Send process detach message here??
307 return ret;
308}
309//******************************************************************************
310//There's a slight problem with our dependency procedure.
311//example: gdi32 is loaded -> depends on kernel32 (which is already loaded)
312// kernel32's reference count isn't updated
313// (when we load gdi32, we don't know which dlls it depends on and which
314// of those are already loaded and which aren't)
315//-> solution: Determine reference counts of dependant lx dlls and update those
316// reference counts
317//******************************************************************************
318void Win32DllBase::updateDependencies()
319{
320 QueueItem *item;
321 Win32DllBase *dll, *depdll;
322 ULONG refcount;
323
324 dlllistmutex.enter();
325 item = loadedDlls.Head();
326 while(item) {
327 depdll = (Win32DllBase *)loadedDlls.getItem(item);
328 if(depdll == NULL) {
329 dprintf(("updateDependencies: depdll == NULL!!"));
330 DebugInt3();
331 return;
332 }
333 refcount = 0;
334 dll = head;
335
336 while(dll) {
337 if(dll->dependsOn(depdll)) {
338 refcount++;
339 }
340 dll = dll->getNext();
341 }
342 if(refcount > depdll->referenced) {
343 dprintf(("Win32DllBase::updateDependencies changing refcount of %s to %d (old=%d)", depdll->getModuleName(), refcount, depdll->referenced));
344 depdll->referenced = refcount;
345 }
346
347 item = loadedDlls.getNext(item);
348 }
349 dlllistmutex.leave();
350}
351//******************************************************************************
352//******************************************************************************
353#ifdef DEBUG
354void Win32DllBase::printDependencies(char *parent)
355{
356 QueueItem *item;
357 Win32DllBase *dll;
358 ULONG ret;
359
360 dprintf(("Dependency list: %s->%s %d", parent, getModuleName(), referenced));
361 item = loadedDlls.Head();
362 while(item) {
363 dll = (Win32DllBase *)loadedDlls.getItem(item);
364 if(dll == NULL) {
365 return;
366 }
367 dll->printDependencies(getModuleName());
368 item = loadedDlls.getNext(item);
369 }
370}
371//******************************************************************************
372//******************************************************************************
373#ifdef DEBUG_ENABLELOG_LEVEL2
374void Win32DllBase::printListOfDlls()
375{
376 Win32DllBase *dll;
377
378 dll = head;
379
380 dprintf2(("Win32DllBase::Win32DllBase: List of loaded dlls:"));
381 while(dll) {
382 dprintf2(("DLL %s %d", dll->szModule, dll->referenced));
383 dll = dll->next;
384 }
385}
386#endif
387#endif
388//******************************************************************************
389//******************************************************************************
390BOOL Win32DllBase::attachProcess()
391{
392 WINEXCEPTION_FRAME exceptFrame;
393 USHORT sel;
394 THDB *thdb;
395 BOOL rc, fSetExceptionHandler;
396
397 if(fAttachedToProcess || fSkipEntryCalls)
398 return TRUE;
399
400 fAttachedToProcess = TRUE;
401
402 thdb = GetThreadTHDB();
403 fSetExceptionHandler = (!thdb || thdb->teb_sel != GetFS());
404
405 //Note: The Win32 exception structure references by FS:[0] is the same
406 // in OS/2
407 if(fSetExceptionHandler) {
408 OS2SetExceptionHandler((void *)&exceptFrame);
409 sel = SetWin32TIB();
410 }
411
412 //Allocate TLS index for this module
413 tlsAlloc();
414 tlsAttachThread(); //setup TLS (main thread)
415
416 if(dllEntryPoint == NULL) {
417 dprintf(("attachProcess not required for dll %s", szModule));
418 if(fSetExceptionHandler) {
419 SetFS(sel);
420 OS2UnsetExceptionHandler((void *)&exceptFrame);
421 }
422 return(TRUE);
423 }
424
425 dprintf(("attachProcess to dll %s", szModule));
426
427 // @@@PH 2000/06/13 lpvReserved, Starcraft STORM.DLL
428 // if DLL_PROCESS_ATTACH, lpvReserved is NULL for dynamic loads
429 // and non-NULL for static loads.
430 // same goes for process termination
431 LPVOID lpvReserved;
432
433 if (isDynamicLib())
434 lpvReserved = NULL;
435 else
436 lpvReserved = (LPVOID)0xdeadface; // some arbitrary value
437
438 rc = dllEntryPoint(hinstance, DLL_PROCESS_ATTACH, lpvReserved);
439
440 dprintf(("attachProcess to dll %s DONE", szModule));
441
442 if(fSetExceptionHandler) {
443 SetFS(sel);
444 OS2UnsetExceptionHandler((void *)&exceptFrame);
445 }
446 else
447 if(thdb) {
448 if(thdb->teb_sel != GetFS()) {
449 dprintf(("Win32DllBase::attachProcess: FS was changed by dll entrypoint!!!!"));
450 DebugInt3();
451 }
452 }
453 return rc;
454}
455//******************************************************************************
456//******************************************************************************
457BOOL Win32DllBase::detachProcess()
458{
459 WINEXCEPTION_FRAME exceptFrame;
460 USHORT sel;
461 BOOL rc;
462
463 if(fSkipEntryCalls) {
464 fUnloaded = TRUE;
465 return TRUE;
466 }
467
468 if(dllEntryPoint == NULL) {
469 tlsDetachThread(); //destroy TLS (main thread)
470 fUnloaded = TRUE;
471 return(TRUE);
472 }
473
474 dprintf(("detachProcess from dll %s", szModule));
475
476 //Note: The Win32 exception structure references by FS:[0] is the same
477 // in OS/2
478 OS2SetExceptionHandler((void *)&exceptFrame);
479
480 fUnloaded = TRUE;
481 sel = SetWin32TIB();
482
483 // @@@PH 2000/06/13 lpvReserved, Starcraft STORM.DLL
484 // if DLL_PROCESS_ATTACH, lpvReserved is NULL for dynamic loads
485 // and non-NULL for static loads.
486 // same goes for process termination
487 LPVOID lpvReserved;
488
489 if (isDynamicLib())
490 lpvReserved = NULL;
491 else
492 lpvReserved = (LPVOID)0xdeadface; // some arbitrary value
493
494 rc = dllEntryPoint(hinstance, DLL_PROCESS_DETACH, lpvReserved);
495
496 SetFS(sel);
497 tlsDetachThread(); //destroy TLS (main thread)
498 tlsDelete();
499
500 OS2UnsetExceptionHandler((void *)&exceptFrame);
501
502 return rc;
503}
504//******************************************************************************
505//******************************************************************************
506BOOL Win32DllBase::attachThread()
507{
508 WINEXCEPTION_FRAME exceptFrame;
509 BOOL rc;
510
511 if(fSkipThreadEntryCalls || dllEntryPoint == NULL)
512 return(TRUE);
513
514 dprintf(("attachThread to dll %s", szModule));
515
516 rc = dllEntryPoint(hinstance, DLL_THREAD_ATTACH, 0);
517
518 dprintf(("attachThread to dll %s DONE", szModule));
519
520 return rc;
521}
522//******************************************************************************
523//******************************************************************************
524BOOL Win32DllBase::detachThread()
525{
526 WINEXCEPTION_FRAME exceptFrame;
527 BOOL rc;
528
529 if(fSkipThreadEntryCalls || dllEntryPoint == NULL)
530 return(TRUE);
531
532 dprintf(("detachThread from dll %s", szModule));
533
534 rc = dllEntryPoint(hinstance, DLL_THREAD_DETACH, 0);
535 return rc;
536}
537//******************************************************************************
538//Send DLL_THREAD_ATTACH message to all dlls for a new thread
539//******************************************************************************
540void Win32DllBase::attachThreadToAllDlls()
541{
542 dlllistmutex.enter();
543 Win32DllBase *dll = Win32DllBase::head;
544 while(dll) {
545 dll->attachThread();
546 dll = dll->getNext();
547 }
548 dlllistmutex.leave();
549}
550//******************************************************************************
551//Send DLL_THREAD_DETACH message to all dlls for thread that's about to die
552//******************************************************************************
553void Win32DllBase::detachThreadFromAllDlls()
554{
555 dlllistmutex.enter();
556 Win32DllBase *dll = Win32DllBase::head;
557 while(dll) {
558 dll->detachThread();
559 dll = dll->getNext();
560 }
561 dlllistmutex.leave();
562}
563//******************************************************************************
564//Setup TLS structure for all dlls for a new thread
565//******************************************************************************
566void Win32DllBase::tlsAttachThreadToAllDlls()
567{
568 dlllistmutex.enter();
569 Win32DllBase *dll = Win32DllBase::head;
570 while(dll) {
571 dll->tlsAttachThread();
572 dll = dll->getNext();
573 }
574 dlllistmutex.leave();
575}
576//******************************************************************************
577//Destroy TLS structure for all dlls for a thread that's about to die
578//******************************************************************************
579void Win32DllBase::tlsDetachThreadFromAllDlls()
580{
581 dlllistmutex.enter();
582 Win32DllBase *dll = Win32DllBase::head;
583 while(dll) {
584 dll->tlsDetachThread();
585 dll = dll->getNext();
586 }
587 dlllistmutex.leave();
588}
589//******************************************************************************
590//******************************************************************************
591void Win32DllBase::deleteAll()
592{
593 Win32DllBase *dll = Win32DllBase::head;
594
595 dprintf(("Win32DllBase::deleteAll"));
596
597#ifdef DEBUG_ENABLELOG_LEVEL2
598 if(dll) dll->printListOfDlls();
599#endif
600
601 dlllistmutex.enter();
602 while(dll) {
603 dll->Release();
604 dll = Win32DllBase::head;
605 }
606 dlllistmutex.leave();
607 dprintf(("Win32DllBase::deleteAll Done!"));
608}
609//******************************************************************************
610//Delete dlls loaded by LoadLibrary(Ex) in LIFO order
611//******************************************************************************
612void Win32DllBase::deleteDynamicLibs()
613{
614 Win32DllBase *dll = head;
615 QueueItem *item;
616
617 dprintf(("Win32DllBase::deleteDynamicLibs"));
618#ifdef DEBUG_ENABLELOG_LEVEL2
619 if(dll) dll->printListOfDlls();
620#endif
621
622 dlllistmutex.enter();
623
624 item = loadLibDlls.Head();
625 while(item) {
626 dll = (Win32DllBase *)loadLibDlls.getItem(item);
627 int dynref = dll->nrDynamicLibRef;
628 if(dynref) {
629 while(dynref) {
630 dynref--;
631 dll->decDynamicLib();
632 dll->Release();
633 }
634 }
635 else DebugInt3();
636 item = loadLibDlls.Head(); //queue could have been changed, so start from the beginning
637 }
638
639 dlllistmutex.leave();
640 dprintf(("Win32DllBase::deleteDynamicLibs end"));
641}
642//******************************************************************************
643//******************************************************************************
644Win32DllBase *Win32DllBase::getFirst()
645{
646 return head;
647}
648//******************************************************************************
649//Add renaming profile strings for ole32 & netapi32 to odin.ini if they aren't
650//already there
651//******************************************************************************
652void Win32DllBase::setDefaultRenaming()
653{
654 char renameddll[CCHMAXPATH];
655
656 if(PROFILE_GetOdinIniString(DLLRENAMEWIN_SECTION, "OLE32", "", renameddll,
657 sizeof(renameddll)-1) <= 1)
658 {
659 PROFILE_SetOdinIniString(DLLRENAMEWIN_SECTION, "OLE32", "OLE32OS2");
660 PROFILE_SetOdinIniString(DLLRENAMEOS2_SECTION, "OLE32OS2", "OLE32");
661 }
662 if(PROFILE_GetOdinIniString(DLLRENAMEWIN_SECTION, "OLEAUT32", "", renameddll,
663 sizeof(renameddll)-1) <= 1)
664 {
665 PROFILE_SetOdinIniString(DLLRENAMEWIN_SECTION, "OLEAUT32", "OLAUTOS2");
666 PROFILE_SetOdinIniString(DLLRENAMEOS2_SECTION, "OLAUTOS2", "OLEAUT32");
667 }
668 if(PROFILE_GetOdinIniString(DLLRENAMEWIN_SECTION, "NETAPI32", "", renameddll,
669 sizeof(renameddll)-1) <= 1)
670 {
671 PROFILE_SetOdinIniString(DLLRENAMEWIN_SECTION, "NETAPI32", "WNETAP32");
672 PROFILE_SetOdinIniString(DLLRENAMEOS2_SECTION, "WNETAP32", "NETAPI32");
673 }
674}
675//******************************************************************************
676//rename dll if necessary:
677// Win32 to OS/2 : (i.e. OLE32 -> OLE32OS2)
678// or
679// OS/2 to Win32 : (i.e. OLE32OS2 -> OLE32)
680//******************************************************************************
681void Win32DllBase::renameDll(char *dllname, BOOL fWinToOS2)
682{
683 char modname[CCHMAXPATH];
684 char renameddll[CCHMAXPATH];
685 char *namestart;
686 char *sectionname;
687
688 if(fWinToOS2) {
689 sectionname = DLLRENAMEWIN_SECTION;
690 }
691 else {
692 sectionname = DLLRENAMEOS2_SECTION;
693 }
694 namestart = OSLibStripPath(dllname);
695 strcpy(modname, namestart);
696 char *dot = strrchr(modname, '.');
697 if(dot)
698 *dot = 0;
699 strupr(modname);
700 if(PROFILE_GetOdinIniString(sectionname, modname, "", renameddll,
701 sizeof(renameddll)-1) > 1)
702 {
703 if(namestart == dllname) {
704 strcpy(dllname, renameddll);
705 }
706 else {
707 *namestart = 0;
708 strcat(dllname, renameddll);
709 }
710 strcat(dllname, ".dll");
711 }
712 return;
713}
714//******************************************************************************
715//******************************************************************************
716Win32DllBase *Win32DllBase::findModule(char *dllname, BOOL fRenameFirst)
717{
718 Win32DllBase *dll;
719 char szDllName[CCHMAXPATH];
720 char *dot, *temp;
721
722//// dprintf2(("findModule %s", dllname));
723
724 strcpy(szDllName, OSLibStripPath(dllname));
725 strupr(szDllName);
726
727 if(fRenameFirst) {
728 renameDll(szDllName, FALSE);
729 }
730
731 dot = strstr(szDllName, ".");
732 if(dot)
733 *dot = 0;
734
735 dlllistmutex.enter();
736 dll = head;
737 while(dll) {
738 if(strcmpi(szDllName, dll->szModule) == 0) {
739 dlllistmutex.leave();
740 return(dll);
741 }
742
743 dll = dll->next;
744 }
745 dlllistmutex.leave();
746 return(NULL);
747}
748//******************************************************************************
749//******************************************************************************
750Win32DllBase *Win32DllBase::findModule(WIN32DLLENTRY DllEntryPoint)
751{
752 dprintf2(("findModule %X", DllEntryPoint));
753
754 dlllistmutex.enter();
755 Win32DllBase *mod = Win32DllBase::head;
756 while(mod != NULL) {
757 dbgCheckObj(mod);
758 if(mod->dllEntryPoint == DllEntryPoint) {
759 dlllistmutex.leave();
760 return(mod);
761 }
762 mod = mod->next;
763 }
764 dlllistmutex.leave();
765 return(NULL);
766}
767//******************************************************************************
768//******************************************************************************
769Win32DllBase *Win32DllBase::findModule(HINSTANCE hinstance)
770{
771 dlllistmutex.enter();
772
773 Win32DllBase *mod = Win32DllBase::head;
774 while(mod != NULL) {
775 dbgCheckObj(mod);
776 if(mod->hinstance == hinstance) {
777 dlllistmutex.leave();
778 return(mod);
779 }
780 mod = mod->next;
781 }
782 dlllistmutex.leave();
783 return(NULL);
784}
785//******************************************************************************
786//******************************************************************************
787Win32DllBase *Win32DllBase::findModuleByAddr(ULONG address)
788{
789 dlllistmutex.enter();
790
791 Win32DllBase *mod = Win32DllBase::head;
792 while(mod != NULL) {
793 dbgCheckObj(mod);
794 if(mod->insideModule(address)) {
795 dlllistmutex.leave();
796 return(mod);
797 }
798 mod = mod->next;
799 }
800 dlllistmutex.leave();
801 return(NULL);
802}
803//******************************************************************************
804//******************************************************************************
805BOOL Win32DllBase::isDll()
806{
807 return TRUE;
808}
809//******************************************************************************
810//******************************************************************************
811Win32DllBase *Win32DllBase::head = NULL;
812Queue Win32DllBase::loadLibDlls;
Note: See TracBrowser for help on using the repository browser.