![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to spyhk32.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / spy|
Return to spyhk32.c CVS log | Up to [OS/2 SDKs] / os232sdk / toolkt20 / c / samples / spy |
1.1 root 1: /***********************************************************************\
2: * spyhook.C - Spy Global input hook interface library.
3: *
4: * Created: Microsoft, IBM Corporation 1990
5: *
6: * DISCLAIMER OF WARRANTIES. The following [enclosed] code is
7: * sample code created by Microsoft Corporation and/or IBM
8: * Corporation. This sample code is not part of any standard
9: * Microsoft or IBM product and is provided to you solely for
10: * the purpose of assisting you in the development of your
11: * applications. The code is provided "AS IS", without
12: * warranty of any kind. Neither Microsoft nor IBM shall be
13: * liable for any damages arising out of your use of the sample
14: * code, even if they have been advised of the possibility of
15: * such damages.
16: *
17: * Purpose: This dynlink is needed because global input hooks must
18: * reside in a DLL.
19: *
20: \***********************************************************************/
21: #define INCL_PM
22: #define INCL_DOSPROCESS
23: #define INCL_DOSMODULEMGR
24: #define INCL_DOSSEMAPHORES
25: #define INCL_ERRORS
26: #include <os2.h>
27: #include "spyhk32.h"
28:
29: // Needed to make a dll link properly
30: int _acrtused = 0;
31:
32: HMTX hmtxSpyHook; /* global semaphore for this module */
33: HEV hevSpyMsg; /* global semaphore for this module */
34:
35: HMODULE hmodSpy; /* dynlink module handle */
36: SHORT SpybHooks; /* Whichs Hook do we use */
37:
38: HAB habOwner = (HAB)0; /* Hook owner's anchore block */
39: HMQ hmqOwner = (HMQ)0; /* Hook owner's message queue */
40: BOOL fRecording = FALSE; /* Are we recording now? */
41: BOOL fAnythingToWatch = FALSE; /* Is there anything to watch */
42: BOOL fDispMsgsNotInList = TRUE; /* Disp msgs not in list? */
43:
44: /* Define array of window handles that we are going to process */
45: BOOL fInitialized = FALSE;
46: BOOL fProcessAllFrames = FALSE; /* Are we processing all frame messages */
47: BOOL fProcessAllWindows = FALSE;/* Are we processing all windows */
48: HWND *pahwndSpy = NULL; /* Array of hwnds to spy on, no max here */
49: int chwndSpy = 0; /* Max windows to spy */
50:
51: /* Define array of HMQ's to spy on */
52: HMQ *pahmqSpy = NULL; /* HMQ list to spy on */
53: int chmqSpy = 0; /* Count of hmqs we are spying on */
54:
55:
56: /* Define message filter array */
57: UCHAR rgMessageFilter[MAXMSGFILTERBYTES] = "";
58: UCHAR GMsgEnableAndType(USHORT); /* Is message in message list */
59: VOID GrabMsgDataWords(SHORT, UCHAR); /* Get extra words for message */
60: BOOL CopyStruct(UCHAR *pbSrc, UCHAR *pbDst, SHORT cb); /* Copy bytes */
61: void DebugBreak(void);
62:
63: /* Define an array of messages to pass to whomever calls us */
64:
65: QMSGSPY rgqmsgSpy[MAXMSGCNT]; /* Array of messages to process */
66: SHORT cmsgSpy = 0; /* Count of messages yet to be read */
67: SHORT imsgWrite = 0; /* Index to message to write out */
68: SHORT imsgRead = 0; /* Index to message to read */
69:
70: /* Use the Dos Sub allocate functions to make sure to use shared memory */
71: #define HEAPSIZE 16384 /* 16K should be plenty? */
72: PVOID pheapSpyHook; /* Heap to use for Spy Hook DLL */
73:
74: PBYTE AllocMem(ULONG cb);
75: VOID FreeMem(PBYTE pMem, ULONG cb);
76: BOOL EnterSem(ULONG ulWait);
77: BOOL LeaveSem(VOID);
78: BOOL SignalEvent(VOID);
79:
80:
81:
82: SHORT acbMPTypes[MP_MASK+1] = { /* Number of desired bytes to extract */
83: 0, /* Normal fields, no pointers */
84: sizeof(SWP), /* MPT_SWP */
85: sizeof(RECTL), /* MPT_RECTL */
86: 0, /* MPT_WNDPRMS we dont process yet */
87: sizeof(QMSG) /* MPT_QMSG */
88: };
89:
90:
91: /* Information for geting selector information in diffent PID context */
92: PIT pit = {0xffff, 0, 0L, NULL, 0};
93: USHORT selectorLNSpy = 0; /* Which Selector */
94: VOID SpyCheckPIDForIntercept(VOID);
95: ULONG EXPENTRY Init(ULONG hPDLL, HMODULE hmod);
96:
97: /***********************************************************************\
98: * VOID Init( hmod )
99: *
100: * Effect: Saves the Spy module handle
101: \***********************************************************************/
102: ULONG EXPENTRY Init(hPDLL, hmod)
103: ULONG hPDLL;
104: HMODULE hmod;
105: {
106: /* Save the module handle */
107: hmodSpy = hmod;
108:
109: return (ULONG)hmodSpy;
110:
111: /* Unreferenced formal parameters referenced here to prevent compiler
112: warning */
113: hPDLL;
114: }
115:
116:
117:
118:
119: /***************************** Exported Function ***********************\
120: * BOOL EXPENTRY SpyInputHook( hab, lpqmsg, fs)
121: * HAB hab;
122: * PQMSG lpqmsg;
123: * USHORT fs;
124: *
125: * Effect: This is the global input hook procedure. Note that hook
126: * procedures can be chained, so we always return FALSE to pass the
127: * message to the next guy in chain.
128: *
129: * Return value: FALSE to pass message to next hook procedure.
130: \***********************************************************************/
131: BOOL EXPENTRY SpyInputHook( hab, lpqmsg, fs )
132: HAB hab;
133: PQMSG lpqmsg;
134: USHORT fs;
135: {
136: UCHAR bMPType;
137:
138: /*
139: * Check first to see if we are looking for a process symbols
140: */
141: if (pit.pid != 0xffff)
142: SpyCheckPIDForIntercept();
143:
144: /*
145: * First check to see if we are processing any hook messages
146: */
147: if (!fRecording || !fAnythingToWatch || (cmsgSpy >= MAXMSGCNT))
148: return (FALSE); /* No let the next one have it now */
149:
150: /*
151: * See if we have any messages to process - Recheck to make sure we
152: * Dont overwrite our queue.
153: */
154: if (!EnterSem(100L)) {
155: DebugBreak();
156: return (FALSE);
157: }
158: if (cmsgSpy < MAXMSGCNT) {
159: if (SpyFWindowInList(lpqmsg->hwnd, FALSE) &&
160: (bMPType = GMsgEnableAndType(lpqmsg->msg))) {
161: rgqmsgSpy[imsgWrite].fs = fs; /* Save the flags */
162: rgqmsgSpy[imsgWrite].qmsg = *lpqmsg; /* Save the message */
163:
164: GrabMsgDataWords(imsgWrite, bMPType);
165: imsgWrite++;
166:
167: if (imsgWrite == MAXMSGCNT)
168: imsgWrite = 0; /* Wrap around */
169: cmsgSpy++;
170: SignalEvent();
171: }
172: }
173:
174: LeaveSem();
175: return FALSE; /* Let system take normal action. */
176:
177: /* Unreferenced formal parameters referenced here to prevent compiler
178: warning */
179: hab;
180:
181: }
182:
183:
184: /***************************** Exported Function ***********************\
185: * BOOL EXPENTRY SpySendMsgHook( hab, lpsmh, fInterTask)
186: * HAB hab;
187: * PQMSG lpqmsg;
188: *
189: * Effect: This is the global input hook procedure. Note that hook
190: * procedures can be chained, so we always return FALSE to pass the
191: * message to the next guy in chain.
192: *
193: * Return value: FALSE to pass message to next hook procedure.
194: \***********************************************************************/
195: BOOL EXPENTRY SpySendMsgHook( hab, lpsmh, fInterTask )
196: HAB hab;
197: PSMHSTRUCT lpsmh;
198: BOOL fInterTask;
199: {
200: UCHAR bMPType;
201: PPIB ppib;
202: PTIB ptib;
203:
204: /*
205: * Check first to see if we are looking for a process symbols
206: */
207: if (pit.pid != 0xffff)
208: SpyCheckPIDForIntercept();
209:
210: /*
211: * First check to see if we are processing any hook messages
212: */
213: if (!fRecording || !fAnythingToWatch || (cmsgSpy >= MAXMSGCNT))
214: return (FALSE); /* No let the next one have it now */
215:
216: /*
217: * See if we have any messages to process
218: */
219: if (!EnterSem(100L)) {
220: DebugBreak();
221: return (FALSE);
222: }
223: /* Make sure no one got in by mistake */
224: if (cmsgSpy < MAXMSGCNT) {
225: if (SpyFWindowInList(lpsmh->hwnd, FALSE) &&
226: (bMPType = GMsgEnableAndType(lpsmh->msg))) {
227: /*
228: * Store out message, must move pieces seperatly
229: */
230: rgqmsgSpy[imsgWrite].fs = fInterTask;
231: rgqmsgSpy[imsgWrite].qmsg.hwnd = lpsmh->hwnd;
232: rgqmsgSpy[imsgWrite].qmsg.msg = lpsmh->msg;
233: rgqmsgSpy[imsgWrite].qmsg.mp1 = lpsmh->mp1;
234: rgqmsgSpy[imsgWrite].qmsg.mp2 = lpsmh->mp2;
235: rgqmsgSpy[imsgWrite].qmsg.time = (ULONG)-1;
236: rgqmsgSpy[imsgWrite].qmsg.ptl.x = 0;
237: rgqmsgSpy[imsgWrite].qmsg.ptl.y = 0;
238:
239: GrabMsgDataWords(imsgWrite, bMPType);
240:
241: /* Now get the PID/TID info, and do the stack backtrace */
242: DosGetThreadInfo(&ptib, &ppib);
243: rgqmsgSpy[imsgWrite].pidSend = ppib->pib_ulpid;
244: rgqmsgSpy[imsgWrite].tidSend = ptib->tib_ultid;
245:
246: imsgWrite++;
247: if (imsgWrite == MAXMSGCNT)
248: imsgWrite = 0; /* Wrap around */
249: cmsgSpy++;
250: SignalEvent();
251: }
252: }
253:
254: LeaveSem();
255: return FALSE; /* Let system take normal action. */
256:
257: /* Unreferenced formal parameters referenced here to prevent compiler
258: warning */
259: hab;
260:
261: }
262:
263:
264: /*************************** Public Function ***************************\
265: * BOOL EXPENTRY SpyInstallHook( hab, hmq, fSendMessage, bHooks)
266: *
267: * Effect: This routine installs a system-wide HK_INPUT hook. The hab
268: * hmq are remembered for message posting. Note that we only allow
269: * one input hook to be installed through this routine, but other
270: * apps may call WinSetHook directly.
271: *
272: * Returns value: TRUE if hook installed successfully, FALSE otherwise.
273: \***********************************************************************/
274: BOOL EXPENTRY SpyInstallHook( hab, hmq, bHooks )
275: HAB hab;
276: HMQ hmq;
277: USHORT bHooks;
278: {
279: BOOL fRet;
280: ULONG ulPostCt;
281:
282: EnterSem(-1L);
283:
284:
285: /*
286: * Look at hook index if == HK_INPUT Install a system-wide input hook.
287: * else set system wide SENDMSG hook
288: */
289: SpybHooks = bHooks;
290: if (SpybHooks & SPYH_INPUT)
291: fRet = WinSetHook( hab, (HMQ)0, HK_INPUT, (PFN)SpyInputHook,
292: hmodSpy );
293:
294: if (SpybHooks & SPYH_SENDMSG)
295: fRet = WinSetHook( hab, (HMQ)0, HK_SENDMSG, (PFN)SpySendMsgHook,
296: hmodSpy );
297: if (fRet) {
298: habOwner = hab;
299: hmqOwner = hmq;
300: }
301:
302: DosResetEventSem(hevSpyMsg, &ulPostCt); /* Init, no messages avail */
303: LeaveSem();
304:
305: return fRet;
306: }
307:
308:
309:
310: /*************************** Public Function ***************************\
311: * BOOL EXPENTRY SpySetWindowList( chwnd, rghwnd)
312: *
313: * Effect: This routine sets the list of window that we are interested
314: * in watching the messages for.
315: *
316: * Returns value: TRUE
317: \***********************************************************************/
318: BOOL EXPENTRY SpySetWindowList( chwnd, rghwnd )
319: SHORT chwnd;
320: HWND *rghwnd;
321: {
322: SHORT i;
323: HWND *phwndT;
324:
325: EnterSem(-1L);
326:
327: if (pahwndSpy) {
328: FreeMem((char *)pahwndSpy, sizeof(HWND) * chwndSpy);
329: pahwndSpy = NULL;
330: }
331:
332:
333: chwndSpy = chwnd;
334:
335: if (chwndSpy > 0 ) {
336:
337: phwndT = pahwndSpy = (HWND *)AllocMem(sizeof(HWND) * chwndSpy);
338:
339: if (phwndT != NULL) {
340: for (i=0; i < chwnd; i++) {
341: *phwndT++ = *rghwnd++;
342: }
343: } else
344: chwndSpy = 0;
345: }
346:
347: fAnythingToWatch = (chwndSpy > 0) || (chmqSpy > 0) ||
348: fProcessAllWindows || fProcessAllFrames;
349:
350: LeaveSem();
351: return(TRUE);
352: }
353:
354:
355: /*************************** Public Function ***************************\
356: * BOOL EXPENTRY SpyGetWindowList( chwnd, rghwnd)
357: *
358: * Effect: This routine sets the list of window that we are interested
359: * in watching the messages for.
360: *
361: * Returns value: TRUE
362: \***********************************************************************/
363: SHORT EXPENTRY SpyGetWindowList( chwnd, rghwnd )
364: SHORT chwnd;
365: HWND *rghwnd;
366: {
367: SHORT i;
368: HWND *phwndT;
369:
370: EnterSem(-1L);
371:
372: if (chwnd > chwndSpy)
373: chwnd = chwndSpy;
374:
375: phwndT = pahwndSpy;
376: for (i=0; i < chwnd; i++) {
377: *rghwnd++ = *phwndT++;
378: }
379:
380: LeaveSem();
381:
382: return(chwnd);
383: }
384:
385:
386:
387:
388: /*************************** Public Function ***************************\
389: * BOOL EXPENTRY SpySetQueueList( chmq, rghmq)
390: *
391: * Effect: This routine sets the list of Queue that we are interested
392: * in watching the messages for.
393: *
394: * Returns value: TRUE
395: \***********************************************************************/
396: BOOL EXPENTRY SpySetQueueList( chmq, rghmq )
397: SHORT chmq;
398: HMQ *rghmq;
399: {
400: SHORT i;
401: HMQ *phmqT;
402:
403: EnterSem(-1L);
404:
405: /*
406: * If we previously had a list of HMQs to spy on, free the old list
407: * now
408: */
409: if (pahmqSpy != NULL) {
410: FreeMem((char *)pahmqSpy, sizeof(HMQ) * chmqSpy);
411: pahmqSpy = NULL;
412: }
413:
414: chmqSpy = chmq;
415:
416: if (chmqSpy > 0) {
417: phmqT = pahmqSpy = (HMQ *)AllocMem(sizeof(HMQ) * chmqSpy);
418:
419: if (phmqT != NULL) {
420: for (i=0; i < chmq; i++) {
421: *phmqT++ = *rghmq++;
422: }
423: } else
424: chmqSpy = 0;
425: }
426:
427: fAnythingToWatch = (chwndSpy > 0) || (chmqSpy > 0) ||
428: fProcessAllWindows || fProcessAllFrames;
429: LeaveSem();
430:
431: return(TRUE);
432: }
433:
434:
435: /*************************** Public Function ***************************\
436: * BOOL EXPENTRY SpyGetQueueList( chmq, rghmq)
437: *
438: * Effect: This routine sets the list of Queue that we are interested
439: * in watching the messages for.
440: *
441: * Returns value: TRUE
442: \***********************************************************************/
443: SHORT EXPENTRY SpyGetQueueList( chmq, rghmq )
444: SHORT chmq;
445: HMQ *rghmq;
446: {
447: SHORT i;
448: HMQ *phmqT;
449:
450: EnterSem(-1L);
451:
452: if (chmq > chmqSpy)
453: chmq = chmqSpy;
454:
455: phmqT = pahmqSpy;
456:
457: for (i=0; i < chmq; i++) {
458: *rghmq++ = *phmqT++;
459: }
460:
461: LeaveSem();
462:
463: return(chmq);
464: }
465:
466:
467: /*************************** Public Function ***************************\
468: * BOOL EXPENTRY SpySetMessageList(UCHAR *prgNewMsgFilter,
469: * BOOL fNewDispMsgsNotInList)
470: *
471: * Effect: This routine sets the list of window that we are interested
472: * in watching the messages for.
473: *
474: * Returns value: TRUE
475: \***********************************************************************/
476: BOOL EXPENTRY SpySetMessageList(prgNewMsgFilter, fNewDispMsgsNotInList)
477: UCHAR *prgNewMsgFilter;
478: BOOL fNewDispMsgsNotInList;
479: {
480: SHORT i;
481: unsigned char *prgb;
482:
483: EnterSem(-1L);
484:
485: prgb = rgMessageFilter;
486:
487:
488: fDispMsgsNotInList = fNewDispMsgsNotInList;
489:
490: for (i=0; i < MAXMSGFILTERBYTES; i++) {
491: *prgb++ = *prgNewMsgFilter++;
492: }
493:
494: LeaveSem();
495:
496: return(TRUE);
497: }
498:
499:
500: /*************************** Public Function ***************************\
501: * BOOL EXPENTRY SpyFWindowInList (hwnd, fInWindowListOnly)
502: *
503: * Effect: This function checks our current list of windows, and returns
504: * TRUE if the window is in the list, else returns FALSE.
505: * Returns value: TRUE if window is in list. Also if We are in the special
506: * state we will pass through all frame windows.
507: \***********************************************************************/
508: BOOL EXPENTRY SpyFWindowInList (hwnd, fInWindowListOnly)
509: register HWND hwnd;
510: BOOL fInWindowListOnly;
511: {
512: register int i;
513: char szClassName[10]; /* Class name of window */
514: CLASSINFO classinfo; /* Information about class */
515: HMQ hmqWindow; /* HMQ of window */
516: HMQ *phmqT; /* Temporary pointer in hmq list */
517: HWND *phwndT; /* Temporary pointer to HWND list */
518: PPIB ppib;
519: PTIB ptib;
520: MQINFO mqinfo; /* Queue info */
521:
522:
523:
524: phwndT = pahwndSpy;
525: for (i=0; i < chwndSpy; i++) {
526: if (hwnd == *phwndT++)
527: return (TRUE);
528: }
529:
530: /* See if we are restricting to only windows in list */
531: if (fInWindowListOnly)
532: return (FALSE);
533:
534: if (fProcessAllWindows)
535: return (TRUE); /* All windows pass through */
536:
537: /*
538: * See if we are watching any message queues
539: */
540: if (phmqT = pahmqSpy) {
541: if (hwnd != NULL) {
542: /*
543: * Sent to specific window First see if the user has specified
544: * that the want all messages that are sent to this message
545: * queue
546: */
547: hmqWindow = (HMQ)WinQueryWindowULong(hwnd, QWL_HMQ);
548: for (i=0; i < chmqSpy; i++) {
549: if (*phmqT++ == hmqWindow)
550: return (TRUE);
551: }
552: } else {
553: // For NULL window handle, see if the current process has HMQ
554: /*
555: * Null Window handle, so instead we need to go through the
556: * list of queues we are watching and see if their PID and TID
557: * matches our current thread.
558: */
559: DosGetThreadInfo(&ptib, &ppib);
560: for (i=0; i < chmqSpy; i++) {
561: if (WinQueryQueueInfo(*phmqT, &mqinfo, sizeof(mqinfo))) {
562: if ((mqinfo.pid == ppib->pib_ulpid) &&
563: (mqinfo.tid == ptib->tib_ultid))
564: return (TRUE); // Yes we want this queue!
565:
566: }
567: phmqT++;
568: }
569: }
570: }
571:
572: if (fProcessAllFrames) {
573: /* See if frame class */
574: if (hwnd == NULL)
575: return (TRUE); /* pass queue messages through */
576: WinQueryClassName(hwnd, sizeof(szClassName),
577: (PSZ)szClassName);
578: WinQueryClassInfo((HAB)NULL, (PSZ)szClassName,
579: &classinfo);
580: if (classinfo.flClassStyle & CS_FRAME)
581: return (TRUE);
582: }
583:
584: return (FALSE);
585: }
586:
587:
588: /*************************** Public Function ***************************\
589: * BOOL EXPENTRY SpyReleaseHook(fZeroQueue)
590: *
591: * Effect: This routine releases the input hook, if it is installed.
592: *
593: * Returns value: TRUE if hook is released, FALSE otherwise.
594: \***********************************************************************/
595: BOOL EXPENTRY SpyReleaseHook(fZeroQueue)
596: BOOL fZeroQueue;
597: {
598: BOOL fRet;
599:
600: EnterSem(-1L);
601:
602: if ( habOwner ) {
603: if (SpybHooks & SPYH_INPUT)
604: fRet = WinReleaseHook( habOwner, (HMQ)0, HK_INPUT,
605: (PFN)SpyInputHook, hmodSpy );
606:
607: if (SpybHooks & SPYH_SENDMSG)
608: fRet = WinReleaseHook( habOwner, (HMQ)0, HK_SENDMSG,
609: (PFN)SpySendMsgHook, hmodSpy );
610: if ( fRet ) {
611: habOwner = (HAB)0;
612: hmqOwner = (HMQ)0;
613: }
614: }
615:
616: /*
617: * When the hook is freed, we want to clear message count out,
618: * make sure any process waiting will abort
619: * Only do this if the Zeroqueu flag was passed
620: */
621: if (fZeroQueue) {
622: cmsgSpy = 0;
623: imsgWrite = 0;
624: imsgRead = 0;
625: if (pahwndSpy != NULL)
626: FreeMem((char *)pahwndSpy, sizeof(HWND) * chwndSpy);
627: pahwndSpy = NULL;
628: chwndSpy = 0; /* Max windows to spy */
629: fRecording = FALSE; /* Set recording to off */
630: if (pahmqSpy != NULL)
631: FreeMem((char *)pahmqSpy, sizeof(HMQ) * chmqSpy);
632:
633: pahmqSpy = NULL;
634: chmqSpy = 0;
635: fAnythingToWatch = FALSE;
636: SignalEvent(); /* Free any process */
637: }
638: LeaveSem();
639:
640: return fRet;
641: }
642:
643:
644: /*************************** Public Function ***************************\
645: * BOOL EXPENTRY SpyHookOnOrOff( fOn)
646: *
647: * Effect: This routine allows the application to turn the hook
648: * processing on or off.
649: *
650: * Returns value:
651: \***********************************************************************/
652: BOOL EXPENTRY SpyHookOnOrOff(fOn)
653: BOOL fOn;
654: {
655: EnterSem(-1L);
656:
657: fRecording = fOn;
658:
659: LeaveSem();
660: return (TRUE);
661: }
662:
663:
664:
665: /*************************** Public Function ***************************\
666: * BOOL EXPENTRY SpySetAllFrameOpt(fAllFrames)
667: *
668: * Effect: Special state if TRUE will cause the window filter to pass
669: * all frame windows through. This is usefull when debuging
670: * interactions between frame windows, when the windows are
671: * net yet created.
672: *
673: * Returns value:
674: \***********************************************************************/
675: BOOL EXPENTRY SpySetAllFrameOpt(fAllFrames)
676: BOOL fAllFrames;
677: {
678: fProcessAllFrames = fAllFrames;
679: fAnythingToWatch = (chwndSpy > 0) || (chmqSpy > 0) ||
680: fProcessAllWindows || fProcessAllFrames;
681: return (TRUE);
682: }
683:
684: /*************************** Public Function ***************************\
685: * BOOL EXPENTRY SpySetAllWindowOpt(fAllWindows)
686: *
687: * Effect: Special state if TRUE will cause the window filter to pass
688: * all windows through. This is usefull when debuging
689: * interactions between all of the windows
690: *
691: * Returns value:
692: \***********************************************************************/
693: BOOL EXPENTRY SpySetAllWindowOpt(fAllWindows)
694: BOOL fAllWindows;
695: {
696: fProcessAllWindows = fAllWindows;
697: fAnythingToWatch = (chwndSpy > 0) || (chmqSpy > 0) ||
698: fProcessAllWindows || fProcessAllFrames;
699: return (TRUE);
700: }
701:
702:
703: /*************************** Public Function ***************************\
704: * BOOL EXPENTRY SpySetPIDIntercept(PID pid, USHORT usPIT, ULONG ulInfo);
705: *
706: *
707: * Effect: Hack to tell the hook to be on the look out for a specific
708: * PID. If it finds it is running in the context of the specified
709: * process, it will get the selector information for the specified
710: * selector.
711: *
712: * Returns value:
713: \***********************************************************************/
714: BOOL EXPENTRY SpySetPIDIntercept(pid, usPIT, ulInfo)
715: PID pid;
716: USHORT usPIT;
717: ULONG ulInfo;
718: {
719: if (pit.pid == 0xffff) {
720: pit.pid = pid;
721: pit.usPIT = usPIT;
722: pit.ulInfo = ulInfo;
723: return (TRUE);
724: } else
725: return (FALSE);
726: }
727:
728:
729:
730: /***************************** Exported Function ***********************\
731: * VOID SpyCheckPIDForIntercept(VOID)
732: *
733: * Effect: Only called when we are looking for a symbol
734: *
735: \***********************************************************************/
736: VOID SpyCheckPIDForIntercept()
737: {
738: PPIB ppib;
739: PTIB ptib;
740:
741: /*
742: * Get the spy semaphore to serialize access and see if we are the
743: * correct PID;
744: */
745: DosGetThreadInfo(&ptib, &ppib);
746: if (!EnterSem(100L))
747: return;
748:
749: if (ppib->pib_ulpid == pit.pid) {
750: /*
751: * We are the correct process, so continue to try go get the
752: * symbol information.
753: */
754: pit.pid = 0xffff; /* reset to not enter again */
755:
756: switch (pit.usPIT) {
757: break;
758: case PIT_ACCEL:
759: // Allocate memory for the Accel table.
760: pit.cbData = WinCopyAccelTable((HACCEL)pit.ulInfo,
761: (PACCELTABLE)NULL, 0);
762: pit.pvoidData = AllocMem(pit.cbData);
763: if (pit.pvoidData == NULL) {
764: pit.cbData = 0;
765: break;
766: }
767: WinCopyAccelTable((HACCEL)pit.ulInfo,
768: (PACCELTABLE)pit.pvoidData, pit.cbData);
769: break;
770: }
771: }
772:
773: LeaveSem();
774: }
775:
776:
777:
778: /*************************** Public Function ***************************\
779: * int EXPENTRY SpyGetLNSymbolSelector(pwhoinfo)
780: *
781: * Effect: Hack to get the information about the specified selector.
782: * If the specified process has not been executed since the
783: * function SpySetPIDIntercept has been called, it will return -1,
784: * else it will return what was returned from IdentifyCodeSelector.
785: *
786: * Returns value:
787: \***********************************************************************/
788: USHORT EXPENTRY SpyGetPIDInterceptData(pvoidBuffer, cbBuffer, pmresult)
789: PVOID pvoidBuffer;
790: USHORT cbBuffer;
791: PMRESULT pmresult;
792: {
793: if (pvoidBuffer != NULL) {
794: if (pit.pvoidData != NULL) {
795: if (cbBuffer > pit.cbData)
796: cbBuffer = pit.cbData;
797: CopyStruct(pit.pvoidData, pvoidBuffer, cbBuffer);
798: FreeMem(pit.pvoidData, pit.cbData);
799: pit.pvoidData = NULL;
800: }
801: }
802:
803: if (pmresult != NULL)
804: *pmresult = pit.mresult;
805:
806: return (pit.cbData);
807: }
808:
809:
810:
811:
812: /*************************** Public Function **************************\
813: * VOID GrabMsgDataWords (SHORT imsg, UCHAR bMPType)
814: *
815: * Effect:
816: * Get the next message from the list - if timeout != 0 an message
817: * processing threads, you may have problems, - If lpqmsg==NULL, this
818: * function acts like a query or wait function.
819: *
820: * Returns value:
821: \***********************************************************************/
822: VOID GrabMsgDataWords(imsg, bMPType)
823: SHORT imsg;
824: UCHAR bMPType;
825: {
826: UCHAR bMP1Type;
827: UCHAR bMP2Type;
828: SHORT cbMPs;
829: SHORT cbMP1;
830: SHORT cbMP2;
831: UCHAR *rgBuf;
832:
833: /*
834: * This function will use the MPType data to know if MP1 and/or MP2
835: * are pointers to any known data, that we want to extract off
836: * and save for spy to display later
837: */
838: rgqmsgSpy[imsg].bMPType = bMPType;
839: bMP1Type = bMPType & MP_MASK;
840: cbMPs = cbMP1 = rgqmsgSpy[imsg].cbDataMP1 = acbMPTypes[bMP1Type];
841:
842: bMP2Type = (bMPType >> 3) & MP_MASK;
843: cbMPs += (cbMP2 = rgqmsgSpy[imsg].cbDataMP2 = acbMPTypes[bMP2Type]);
844:
845: if (cbMPs > 0) {
846: /* Allocate memory to save the data into */
847: rgBuf = rgqmsgSpy[imsg].rgData = AllocMem(cbMPs);
848:
849: if (rgBuf != NULL) {
850: /* Copy the data down, Note: if count is 0 will NOP */
851: if (cbMP1) {
852: rgqmsgSpy[imsg].fMP1Valid = CopyStruct(
853: (CHAR *)rgqmsgSpy[imsg].qmsg.mp1, rgBuf, cbMP1);
854: rgBuf += cbMP1;
855: }
856:
857: if (cbMP2) {
858: rgqmsgSpy[imsg].fMP2Valid = CopyStruct(
859: (CHAR *)rgqmsgSpy[imsg].qmsg.mp2, rgBuf, cbMP2);
860: }
861: }
862:
863: } else {
864: rgqmsgSpy[imsg].rgData = NULL;
865: }
866: }
867:
868:
869:
870:
871:
872:
873: /*************************** Public Function **************************\
874: * SpyGetNextMessage (lpqmsg, lpBuf, cbBuf, lTimeOut)
875: *
876: * Effect:
877: * Get the next message from the list - if timeout != 0 an message
878: * processing threads, you may have problems, - If lpqmsg==NULL, this
879: * function acts like a query or wait function.
880: *
881: * Returns value:
882: \***********************************************************************/
883: BOOL EXPENTRY SpyGetNextMessage(lpqmsg, lpBuf, cbBuf, lTimeOut)
884: PQMSGSPY lpqmsg; /* Pointer where the user wants the message stored */
885: PSZ lpBuf; /* pointer to buffer */
886: SHORT cbBuf; /* size of buffer in bytes */
887: LONG lTimeOut; /* Timeout value */
888: {
889:
890: SHORT cbMsg; /* Count of bytes associated with message */
891: ULONG ulPostCt; /* Count of posts to semaphore before reset */
892:
893: /* Quick escape hatch */
894: if ((lTimeOut == 0) && (cmsgSpy == 0))
895: return (FALSE); /* Dont Wait */
896:
897: /*
898: * Now lets possibly wait for a message
899: */
900: if (cmsgSpy == 0) {
901: if (DosWaitEventSem(hevSpyMsg, lTimeOut) != 0)
902: return (FALSE); /* No messages after timeout */
903: if (cmsgSpy == 0)
904: return (FALSE); /* Still no messages, return condition */
905: }
906:
907: /*
908: * If the lpqmsg is NULL, the user is simply asking if there is
909: * a message and/or waiting for the message, so dont extract
910: * the message, but simply return the status.
911: */
912: if (lpqmsg != NULL) {
913: if (DosRequestMutexSem(hmtxSpyHook, lTimeOut) == 0) {
914: *lpqmsg = rgqmsgSpy[imsgRead]; /* Extract the message */
915:
916: cbMsg = rgqmsgSpy[imsgRead].cbDataMP1
917: + rgqmsgSpy[imsgRead].cbDataMP2;
918:
919: if ((cbMsg > 0) && (lpBuf != NULL)) {
920: if (cbMsg < cbBuf)
921: cbBuf = cbMsg; /* Number of bytes to copy */
922: CopyStruct(rgqmsgSpy[imsgRead].rgData, lpBuf, cbBuf);
923: }
924:
925: if (cbMsg > 0)
926: FreeMem(rgqmsgSpy[imsgRead].rgData, cbMsg);
927:
928: /* Also give the caller any additional information on message */
929:
930: imsgRead++;
931: if (imsgRead == MAXMSGCNT)
932: imsgRead = 0; /* Wrap around */
933:
934: /*
935: * Decrement count of messages, if we go to zero, set
936: * the semaphore, so that the next read will suspend until
937: * the next message
938: */
939: cmsgSpy--;
940: if (cmsgSpy == 0)
941: DosResetEventSem(hevSpyMsg, &ulPostCt);
942:
943: LeaveSem();
944: }
945: }
946:
947: return (TRUE);
948: }
949:
950:
951:
952:
953: /*************************** Private Function **************************\
954: * VOID SpyInitializeHookt(void)
955: *
956: * Effect:
957: *
958: *
959: * Returns value:
960: \***********************************************************************/
961: BOOL EXPENTRY SpyInitializeHook (VOID)
962: {
963:
964: if (fInitialized) {
965: return (TRUE);
966: }
967:
968: fInitialized = TRUE;
969:
970: /* Make an event semaphore to signal spy program with */
971: DosCreateMutexSem(NULL, &hmtxSpyHook, DC_SEM_SHARED, FALSE);
972: DosCreateEventSem(NULL, &hevSpyMsg, DC_SEM_SHARED, FALSE);
973:
974: /* Initialize our local heap */
975: DosAllocSharedMem(&pheapSpyHook, NULL, HEAPSIZE,
976: PAG_COMMIT | PAG_READ | PAG_WRITE | OBJ_GETTABLE);
977: DosSubSet((PVOID)pheapSpyHook, 1, HEAPSIZE);
978:
979: /* Get the module handle. */
980: return TRUE;
981:
982: }
983:
984:
985: /*************************** Private Function **************************\
986: * VOID SpyTerminateHook( )
987: *
988: * Effect:
989: *
990: *
991: * Returns value:
992: \***********************************************************************/
993: BOOL EXPENTRY SpyTerminateHook (VOID)
994: {
995:
996:
997: if (!fInitialized) {
998: return (FALSE);
999: }
1000:
1001: fInitialized = FALSE;
1002:
1003: /* Close the semaphore off now */
1004: DosCloseMutexSem(hmtxSpyHook);
1005: DosCloseEventSem(hevSpyMsg);
1006:
1007: /* Also need to free memory */
1008:
1009:
1010: }
1011:
1012:
1013: /*************************** Private Function **************************\
1014: * UCHAR GMsgEnableAndType (USHORT msg)
1015: *
1016: * Effect:
1017: * Should the message be processed. If the message is out of range,
1018: * or bit is set in message bitmask return TRUE
1019: *
1020: * Returns value:
1021: * BOOL
1022: \***********************************************************************/
1023: UCHAR GMsgEnableAndType(msg)
1024: USHORT msg;
1025: {
1026: if (msg > MAXMSGFILTER)
1027: return ((UCHAR)(fDispMsgsNotInList? MP_ENABLED : 0));
1028:
1029: return (rgMessageFilter[msg]); /* One byte per message */
1030: }
1031:
1032:
1033: /*************************** Private Function **************************\
1034: * PBYTE AllocMem (ULONG cb)
1035: *
1036: * Effect:
1037: * Allocates memory from our local heap, and hides that we are no longer
1038: * calling WinAllocMem.
1039: *
1040: * Returns value:
1041: * PBYTE
1042: \***********************************************************************/
1043: PBYTE AllocMem(ULONG cb)
1044: {
1045: PVOID pbT;
1046: ULONG ulCb;
1047: ULONG ulFlag;
1048:
1049: if (DosQueryMem(pheapSpyHook, &ulCb, &ulFlag)) {
1050: if (DosGetSharedMem(pheapSpyHook, PAG_READ | PAG_WRITE)) {
1051: DebugBreak;
1052: return (NULL);
1053: }
1054: }
1055:
1056: if (DosSubAlloc((PVOID)pheapSpyHook, (PPVOID)&pbT, cb))
1057: return(NULL);
1058:
1059: return(pbT);
1060: }
1061:
1062:
1063: /*************************** Private Function **************************\
1064: * UCHAR FreeMem (PBYTE pMem, ULONG cb)
1065: *
1066: * Effect:
1067: * Frees any memory previously allocated by Allocmem
1068: *
1069: * Returns value:
1070: * NULL
1071: \***********************************************************************/
1072:
1073: VOID FreeMem(PBYTE pMem, ULONG cb)
1074: {
1075: DosSubFree((PVOID)pheapSpyHook, (PVOID)pMem, cb);
1076: }
1077:
1078:
1079: /*************************** Private Function **************************\
1080: * BOOL EnterSem
1081: *
1082: * Effect:
1083: * Enters the Main spy Mutex semaphore
1084: *
1085: * Returns value:
1086: * BOOL;
1087: \***********************************************************************/
1088:
1089: BOOL EnterSem(ULONG ulWait)
1090: {
1091: ULONG rc;
1092: HMTX hmtx;
1093:
1094: if ((rc = DosRequestMutexSem(hmtxSpyHook, ulWait)) == 0)
1095: return (TRUE);
1096:
1097: if (rc != ERROR_INVALID_HANDLE)
1098: return (FALSE);
1099: #ifdef LATER
1100: * We should Close semaphore when we are done???
1101: #endif
1102:
1103: hmtx = hmtxSpyHook;
1104: if (DosOpenMutexSem(NULL, &hmtx) != 0)
1105: return (FALSE);
1106:
1107: DosGetSharedMem(pheapSpyHook, PAG_READ | PAG_WRITE);
1108:
1109: return (DosRequestMutexSem(hmtxSpyHook, 100L) == 0);
1110:
1111: }
1112:
1113: /*************************** Private Function **************************\
1114: * BOOL LeaveSem
1115: *
1116: * Effect:
1117: * Enters the Main spy Mutex semaphore
1118: *
1119: * Returns value:
1120: * BOOL;
1121: \***********************************************************************/
1122:
1123: BOOL LeaveSem()
1124: {
1125: return (DosReleaseMutexSem(hmtxSpyHook) == 0);
1126:
1127: }
1128:
1129:
1130:
1131: /*************************** Private Function **************************\
1132: * BOOL SignalEvent
1133: *
1134: * Effect:
1135: * Signal an event to spy to let him know something is available.
1136: *
1137: * Returns value:
1138: * BOOL;
1139: \***********************************************************************/
1140:
1141: BOOL SignalEvent()
1142: {
1143: ULONG rc;
1144: HEV hev;
1145:
1146: if ((rc = DosPostEventSem(hevSpyMsg)) == 0)
1147: return (TRUE);
1148:
1149: if (rc != ERROR_INVALID_HANDLE)
1150: return (FALSE);
1151: #ifdef LATER
1152: * We should Close semaphore when we are done???
1153: #endif
1154:
1155: hev = hevSpyMsg;
1156: if (DosOpenEventSem(NULL, &hev) != 0)
1157: return (FALSE);
1158:
1159: return (DosPostEventSem(hevSpyMsg) == 0);
1160:
1161: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.