Changeset 2763 for trunk/synergy/lib/platform/CPMSynergyHook.cpp

Timestamp:

Aug 13, 2006, 12:50:25 PM (19 years ago)

Author:

bird

Message:

Grr. HK_MSGINPUT / PM sucks. Got mouse working, but the hook code contains seriously bad hacks.

File:

• trunk/synergy/lib/platform/CPMSynergyHook.cpp (modified) (13 diffs)

trunk/synergy/lib/platform/CPMSynergyHook.cpp

@@ -17 +17 @@
 #include "ProtocolTypes.h"
 #include <sys/builtin.h>
+#if 0
 #include <stdlib.h>
 #include <unistd.h>
+#include <InnoTekLIBC/FastInfoBlocks.h>
+#else
+unsigned long fibGetMsCount(void )
+{
+    ULONG ul = 0;
+    DosQuerySysInfo(QSV_MS_COUNT, QSV_MS_COUNT, &ul, sizeof(ul));
+    return ul;
+}
+
+int getpid(void)
+{
+    PTIB pTib;
+    PPIB pPib;
+    DosGetInfoBlocks(&pTib, &pPib);
+    return pPib->pib_ulpid;
+}
+
+int _gettid(void)
+{
+    PTIB pTib;
+    PPIB pPib;
+    DosGetInfoBlocks(&pTib, &pPib);
+    return pTib->tib_ptib2->tib2_ultid;
+}
+
+void _assert (__const__ char * pszExpr, __const__ char *pszFile, unsigned iLine)
+{
+    __asm__ ("int3\n");
+}
+
+#endif 
 
 //
-// globals - system wide (defined in .asm)
+// globals - system wide
 //
-extern "C" {
 /** @name The synergy server/client thread
  * @{ */
-extern HMQ                  g_hmqSynergy;
-extern int                  g_pidSynergy;
-extern int                  g_tidSynergy;
+HMQ                  g_hmqSynergy;
+int                  g_pidSynergy;
+int                  g_tidSynergy;
 /** @} */
 
 /** The current mode.*/
-extern EHookMode volatile   g_enmMode;
+EHookMode volatile   g_enmMode;
 
 /** Which sides do we have warp zones on. */
-extern UInt32               g_zoneSides;
+UInt32               g_zoneSides;
 /** The warp zone size in pixels. */
-extern SInt32               g_zoneSize;
+SInt32               g_zoneSize;
 /** @name The screen size.
  * @{ */
-extern SInt32               g_xScreen;
-extern SInt32               g_yScreen;
-extern SInt32               g_cxScreen;
-extern SInt32               g_cyScreen;
+SInt32               g_xScreen;
+SInt32               g_yScreen;
+SInt32               g_cxScreen;
+SInt32               g_cyScreen;
 /** @} */
 
 /** Set if the hook is installed. */
-extern bool                 g_fInputHookInstalled;
+bool                 g_fInputHookInstalled;
 /** Set if we're faking input. */
-extern bool                 g_fFakingInput;
-
-} /* extern "C" */
+bool                 g_fFakingInput;
+
+/** @name Input Message Faking.
+ * @{ */
+/** The event semaphore we're waiting on while faking messages. */
+HEV                  g_hev;
+/** The pending message. */
+QMSG                 g_qmsg;
+/** Indicator set by the MsgInputHook function when the message 'skipped'. */
+volatile bool        g_fMsgInjected;
+/** Error description. */
+const char          *g_pszErrorMsg;
+/** Set if the dummy hook is installed. */
+bool                 g_fDummyHook;
+/** @} */
+
+/** The handle of the hook dll. */
+HMODULE             g_hmod = NULLHANDLE;
+/** Indicator whether the init() function has been called successfully. */
+bool                g_fSynergyInitialized = false;
+
 
 
 //
-// Globals - per process.
+// Internal Functions
 //
-
-/** The handle of the hook dll. */
-static HMODULE  g_hmod = NULLHANDLE;
-/** The pid of the current process. */
-static int      g_pid = 0;
 
 
@@ -244 +288 @@
 
 
+#define NO_DUMMY_HOOK 1
+#ifndef NO_DUMMY_HOOK
+/**
+ * Dummy hook.
+ */
+static VOID EXPENTRY SendMsgHook(HAB hab, PSMHSTRUCT psmh, BOOL fInterTask)
+{
+    /* nop */
+}
+#endif 
+
+
+
 //
 // external functions
@@ -255 +312 @@
     switch (ulReason) {
     /* init */
-    case 0:
+    case 0: {
+        HEV hev = g_hev;
+        if (hev != NULLHANDLE) {
+            DosOpenEventSem(NULL, &hev);
+        }
         g_hmod = hmod;
-        g_pid = getpid();
         break;
+    }
 
     /* term */
     case 1:
-        g_pid = 0;
-        g_hmod = NULLHANDLE;
-        break;
-
-    default:
+        if (g_hev != NULLHANDLE) {
+            DosCloseEventSem(g_hev);
+        }
         break;
     }
@@ -294 +353 @@
 
     /*
+     * Create the event semaphore.
+     */
+    ULONG cPosts;
+    if (    g_hev == NULLHANDLE
+        ||  DosQueryEventSem(g_hev, &cPosts) != NO_ERROR
+        ) {
+        g_hev = NULLHANDLE;
+        APIRET rc = DosCreateEventSem(NULL, &g_hev, DC_SEM_SHARED, FALSE);
+        if (rc != NO_ERROR)
+            return false;
+    }
+
+    /*
      * Initialize the globals.
      */
@@ -302 +374 @@
     /* only do this if the hook is inactive. */
     if (g_enmMode == kHOOK_DISABLE) {
-        g_enmMode      = kHOOK_DISABLE;
         g_zoneSides = 0;
         g_zoneSize  = 0;
@@ -311 +382 @@
     }
 
+#ifndef NO_DUMMY_HOOK
+    /*
+     * Install the fake hook.
+     */
+    if (g_fDummyHook)
+        WinReleaseHook(WinQueryAnchorBlock(HWND_DESKTOP), NULLHANDLE, HK_SENDMSG, (PFN)SendMsgHook, g_hmod);
+    g_fDummyHook = WinSetHook(WinQueryAnchorBlock(HWND_DESKTOP), NULLHANDLE, HK_SENDMSG, (PFN)SendMsgHook, g_hmod);
+    if (!g_fDummyHook) {
+        return false;
+    }
+#endif 
+
+    g_fSynergyInitialized = true;
     return true;
 }
@@ -324 +408 @@
 {
     assert(g_hmod != NULLHANDLE);
+    assert(g_fSynergyInitialized == true);
 
     /*
@@ -336 +421 @@
     uninstall(hab);
 
+#ifndef NO_DUMMY_HOOK
+    // release the dummy hook.
+    if (WinReleaseHook(hab, NULLHANDLE, HK_SENDMSG, (PFN)SendMsgHook, g_hmod))
+        g_fDummyHook = false;
+#endif 
+
     g_hmqSynergy = NULLHANDLE;
     g_pidSynergy = 0;
     g_tidSynergy = 0;
+    g_fSynergyInitialized = false;
     return true;
 }
@@ -346 +438 @@
 {
     // must be initialized
-    if (g_tidSynergy == 0) {
+    if (    g_tidSynergy == 0
+        ||  !g_fSynergyInitialized) {
         return kHOOK_FAILED;
     }
@@ -384 +477 @@
     assert(g_pidSynergy == getpid());
     assert(g_tidSynergy == _gettid());
+    assert(g_fSynergyInitialized);
+    if (!g_fSynergyInitialized) {
+        return false;
+    }
 
     //// discard old dead keys
@@ -409 +506 @@
     assert(g_pidSynergy == getpid());
     assert(g_tidSynergy == _gettid());
-    __atomic_xchg((unsigned volatile *)&g_zoneSides, (unsigned)sides);
+    assert(g_fSynergyInitialized);
+    if (g_fSynergyInitialized) {
+        __atomic_xchg((unsigned volatile *)&g_zoneSides, (unsigned)sides);
+    }
 }
 
@@ -426 +526 @@
     assert(g_pidSynergy == getpid());
     assert(g_tidSynergy == _gettid());
-    __atomic_xchg((unsigned volatile *)&g_zoneSize, (unsigned)jumpZoneSize);
-    __atomic_xchg((unsigned volatile *)&g_xScreen,  (unsigned)x);
-    __atomic_xchg((unsigned volatile *)&g_yScreen,  (unsigned)y);
-    __atomic_xchg((unsigned volatile *)&g_cxScreen, (unsigned)cx);
-    __atomic_xchg((unsigned volatile *)&g_cyScreen, (unsigned)cy);
+    assert(g_fSynergyInitialized);
+    if (g_fSynergyInitialized) {
+        __atomic_xchg((unsigned volatile *)&g_zoneSize, (unsigned)jumpZoneSize);
+        __atomic_xchg((unsigned volatile *)&g_xScreen,  (unsigned)x);
+        __atomic_xchg((unsigned volatile *)&g_yScreen,  (unsigned)y);
+        __atomic_xchg((unsigned volatile *)&g_cxScreen, (unsigned)cx);
+        __atomic_xchg((unsigned volatile *)&g_cyScreen, (unsigned)cy);
+    }
 }
 
@@ -443 +546 @@
     assert(g_pidSynergy == getpid());
     assert(g_tidSynergy == _gettid());
-    if (mode != g_enmMode) {
-        switch (mode) {
-        case kHOOK_DISABLE:
-        case kHOOK_WATCH_JUMP_ZONE:
-        case kHOOK_RELAY_EVENTS:
-            __atomic_xchg((unsigned volatile *)&g_enmMode, (unsigned)mode);
-            break;
-        default:
-            __atomic_xchg((unsigned volatile *)&g_enmMode, kHOOK_DISABLE);
-            break;
+    assert(g_fSynergyInitialized);
+    if (g_fSynergyInitialized) {
+        if (mode != g_enmMode) {
+            switch (mode) {
+            case kHOOK_DISABLE:
+            case kHOOK_WATCH_JUMP_ZONE:
+            case kHOOK_RELAY_EVENTS:
+                __atomic_xchg((unsigned volatile *)&g_enmMode, (unsigned)mode);
+                break;
+            default:
+                __atomic_xchg((unsigned volatile *)&g_enmMode, kHOOK_DISABLE);
+                break;
+            }
         }
     }
 }
 
+
+/**
+ * Hook callback used to insert message into the system queue.
+ *
+ * @returns TRUE if we've got a message.
+ * @returns FALSE if we haven't got a message handy.
+ * @param   hab         The hab of the current thread.
+ * @param   pqmsg       Where to put the message.
+ * @param   fSkip       Skip message flag. 
+ *                      If TRUE we should just skip a message (pqmsg is NULL). If no futher
+ *                      messages are queued, we must release the hook.
+ *                      If FALSE we should return the current pending message.
+ * @param   pfNoRecord  Record message flag.
+ */
+static BOOL EXPENTRY MsgInputHook(HAB hab, PQMSG pqmsg, BOOL fSkip, PBOOL pfNoRecord)
+{
+    /*
+     * FUCKING HELL!
+     *
+     * For whatever fucking reason, PM fails to load the hook dll into 
+     * a bunch of processes. We still get here for some peculiar reasons, 
+     * and thus we can try deal with it...
+     */
+    BOOL fUnload = FALSE;
+    HMODULE hmod;
+    ULONG offObj, iObj;
+    APIRET rc = DosQueryModFromEIP(&hmod, &iObj, 0, NULL, &offObj, (ULONG)&MsgInputHook);
+    if (rc != NO_ERROR) {
+        if (DosLoadModule(NULL, 0, (PCSZ)"d:/coding/libc/trunk/out/os2.x86/debug/dist/bin/synrgyhk.dll", &hmod)) {
+            return FALSE;
+        }
+        fUnload = TRUE;
+    }
+
+    /*
+     * We've only got one message, so everything is dead simple.
+     */
+    if (fSkip) {
+        __atomic_xchg((unsigned volatile *)&g_fMsgInjected, 1);
+        if (WinReleaseHook(hab, NULLHANDLE, HK_MSGINPUT, (PFN)MsgInputHook, g_hmod)) {
+            HEV     hev = g_hev;
+            APIRET  rc = DosPostEventSem(hev);
+            if (    rc != ERROR_INVALID_HANDLE
+                ||  DosOpenEventSem(NULL, &hev) != NO_ERROR
+                ||  DosPostEventSem(hev) != NO_ERROR)
+                g_pszErrorMsg = "failed to post event semaphore";
+        } else {
+            g_pszErrorMsg = "failed to release hook";
+        }
+    } else {
+        *pqmsg = g_qmsg;
+    }
+
+    /* 
+     * If we loaded the dll we must unload it.
+     * Don't wanna have any DLLs stuck in foreign processes.
+     */
+    if (fUnload)
+        DosFreeModule(hmod);
+    return TRUE;
+}
+
+
+/**
+ * Inserts a fake input message.
+ *
+ * @returns NULL on success.
+ * @returns String describing the error on failure.
+ * @param   hab     The anchor block of the calling thread.
+ * @param   pQmsg   Pointer to the message.
+ * @remark  The caller must serialize calls to this function!
+ */
+CSYNERGYHOOK_API const char *fakeMsg(HAB hab, const QMSG *pQmsg)
+{
+    const char *pszRet;
+    assert(g_fSynergyInitialized);
+    if (g_fSynergyInitialized) {
+        /* 
+         * Reset the event semaphore and queue the message for MsgInputHook.
+         */
+        ULONG cPosts;
+        APIRET rc = DosResetEventSem(g_hev, &cPosts);
+        if (rc == NO_ERROR || rc == ERROR_ALREADY_RESET) {
+            g_qmsg = *pQmsg;
+            g_pszErrorMsg = NULL;
+            __atomic_xchg((unsigned volatile *)&g_fMsgInjected, 0);
+
+            /*
+             * Install the hook and wait for the message to be delivered.
+             */
+            WinCheckInput(hab);
+            if (WinSetHook(hab, NULLHANDLE, HK_MSGINPUT, (PFN)MsgInputHook, g_hmod)) {
+                WinCheckInput(hab);
+                rc = DosWaitEventSem(g_hev, 1000 /* 33 */);
+                if (rc == NO_ERROR || g_fMsgInjected) {
+                    return NULL;
+                }
+
+                /*
+                 * It took a bit longer than expected. We'll wait for some 2-3 
+                 * seconds before we give up. This might be a bit paranoid, but
+                 * I'd rather drop a message than locking up PM.
+                 */
+                if (rc == ERROR_TIMEOUT || rc == ERROR_SEM_TIMEOUT || rc == ERROR_INTERRUPT) {
+                    ULONG ulStart = fibGetMsCount(); /* monotone time in milliseconds */
+                    for (;;) {
+                        WinCheckInput(hab);
+                        rc = DosWaitEventSem(g_hev, 33);
+                        if (rc == NO_ERROR || g_fMsgInjected) {
+                            return NULL;
+                        }
+                        if (rc != ERROR_TIMEOUT && rc != ERROR_SEM_TIMEOUT && rc != ERROR_INTERRUPT) {
+                            break;
+                        } 
+                        if (fibGetMsCount() - ulStart > 2500) {
+                            break;
+                        }
+                    }
+                }
+
+                /* 
+                 * Since we probably didn't manage to inject the message, we should 
+                 * release the hook to make sure we're not overwriting g_qmsg while 
+                 * some other thread is reading it from MsgInputHook.
+                 */
+                WinReleaseHook(hab, NULLHANDLE, HK_MSGINPUT, (PFN)MsgInputHook, g_hmod);
+                DosSleep(10);
+                pszRet = g_pszErrorMsg;
+                return pszRet ? pszRet : "timed out";
+            } 
+            pszRet = "WinSetHook failed";
+        } else {
+            pszRet = "DosResetEventSem failed";
+        }
+    } else {
+        pszRet = "!g_fSynergyInitialized";
+    }
+    DosSleep(0);
+    return pszRet;
+}
+