Changeset 2763

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.

Location:

trunk/synergy

Files:

• Makefile.kmk (modified) (1 diff)
• lib/platform/CPMKeyState.cpp (modified) (1 diff)
• lib/platform/CPMScreen.cpp (modified) (9 diffs)
• lib/platform/CPMScreen.h (modified) (2 diffs)
• lib/platform/CPMSynergyHook.cpp (modified) (13 diffs)
• lib/platform/CPMSynergyHook.def (modified) (1 diff)
• lib/platform/CPMSynergyHook.h (modified) (2 diffs)
• lib/platform/CPMSynergyHookData.asm (modified) (1 diff)

trunk/synergy/Makefile.kmk

@@ -243 +243 @@
 synrgyhk_ASTOOL.os2 = NASM
 synrgyhk_ASFLAGS.os2 = -f obj
+synrgyhk_CXXFLAGS.os2 = -fno-exceptions 
+synrgyhk_LDFLAGS.os2 = -nostdlib -los2 -v -lend
 synrgyhk_SOURCES.nt = \
         lib/platform/CSynergyHook.cpp

trunk/synergy/lib/platform/CPMKeyState.cpp

@@ -650 +650 @@
         switch (keystroke.m_type) {
         case Keystroke::kButton: {
-                LOG((CLOG_DEBUG1 "  %03x (%08x) %s", keystroke.m_data.m_button.m_button, keystroke.m_data.m_button.m_client, keystroke.m_data.m_button.m_press ? "down" : "up"));
+                LOG((CLOG_DEBUG1 "  %03x (%08x) %s%s", keystroke.m_data.m_button.m_button, keystroke.m_data.m_button.m_client, 
+             keystroke.m_data.m_button.m_press ? "down" : "up", keystroke.m_data.m_button.m_repeat ? " repeate" : ""));
                 KeyButton button = keystroke.m_data.m_button.m_button;
 

trunk/synergy/lib/platform/CPMScreen.cpp

@@ -71 +71 @@
         assert(s_screen == NULL);
         s_screen = this;
+    LOG((CLOG_DEBUG1 "CPMScreen: isPrimary=%d", isPrimary));
     
     // create the event queue buffer first so we know there is a message queue.
@@ -93 +94 @@
 
         try {
-                if (m_isPrimary)
-                        m_hmodHook = openHookLibrary("synrgyhk");
+                m_hmodHook = openHookLibrary("synrgyhk");
                 m_screensaver = new CPMScreenSaver();
                 m_keyState    = new CPMKeyState(getEventTarget());
@@ -528 +528 @@
 }
 
+/**
+ * Injects a fake input message.
+ *
+ * @param   msg     The message id.
+ * @param   mp1     Message param 1.
+ * @param   mp1     Message param 2.
+ */
+void 
+CPMScreen::fakeMessage(ULONG msg, MPARAM mp1, MPARAM mp2) const
+{
+    QMSG qmsg;
+    qmsg.hwnd = NULLHANDLE;
+    qmsg.msg = msg;
+    qmsg.mp1 = mp1;
+    qmsg.mp2 = mp2;
+    qmsg.time = WinGetCurrentTime(m_hab);
+    qmsg.ptl.x = 0;     ///@todo check the qmsg.ptl.
+    qmsg.ptl.y = 0;
+    qmsg.reserved = 0;
+LOG((CLOG_DEBUG "fakeMessage: msg=%#lx mp1=%#lx mp2=%#lx...", msg, mp1, mp2));
+    const char *pszError = m_fakeMsg(m_hab, &qmsg);
+    if (pszError) {
+        LOG((CLOG_CRIT "fakeMessage: msg=%#lx mp1=%#lx mp2=%#lx failed: %s", msg, mp1, mp2, pszError));
+    }
+else LOG((CLOG_DEBUG "fakeMessage: done"));
+}
+
+/**
+ * Injects a fake input message generating mp2.
+ * @param   msg     The message id.
+ * @param   mp1     The mouse coordinates.
+ */
+void
+CPMScreen::fakeMouseMessage(ULONG msg, MPARAM mp1) const
+{
+    /* hittest stuff is taken care off.. dunno about KC_*. */
+    fakeMessage(msg, mp1, 0);
+}
+
 void
 CPMScreen::fakeMouseButton(ButtonID id, bool press) const
 {
-        //m_desks->fakeMouseButton(id, press);
+    // determin the message.
+    ULONG msg;
+    switch (id) {
+        case kButtonLeft:
+            msg = press ? WM_BUTTON1DOWN : WM_BUTTON1UP;
+            break;
+        case kButtonRight:
+            msg = press ? WM_BUTTON2DOWN : WM_BUTTON2UP;
+            break;
+        case kButtonMiddle:
+            msg = press ? WM_BUTTON3DOWN : WM_BUTTON3UP;
+            break;
+        default:
+            return;
+    }
+
+    // mp1
+    POINTL ptl;
+    if (!WinQueryPointerPos(HWND_DESKTOP, &ptl)) {
+        LOG((CLOG_CRIT "fakeMouseButton: failed %#lx", WinGetLastError(CPMUtil::getHAB())));
+        ptl.x = m_xCenter;
+        ptl.y = m_yCenter;
+    }
+
+    // forge the message.
+    fakeMouseMessage(msg, MPFROM2SHORT(ptl.x, ptl.y));
 }
 
@@ -539 +603 @@
     LOG((CLOG_DEBUG "fakeMouseMove: %d,%d (y=%d)", x, m_cy - y, y));
     if (WinSetPointerPos(HWND_DESKTOP, x, m_cy - y)) {
+        // check x limits
+        if (x > 0x7fff) x = 0x7fff;
+        else if (x < -0x8000) x = -0x8000;
+
+        // wrap y and check the limits.
+        y = m_cy - y;
+        if (y > 0x7fff) y = 0x7fff;
+        else if (y < -0x8000) y = -0x8000;
+
+        // forge the message.
+        fakeMouseMessage(WM_MOUSEMOVE, MPFROM2SHORT(x, y));
         return;
     }
@@ -550 +625 @@
     if (WinQueryPointerPos(HWND_DESKTOP, &ptl)) {
         LOG((CLOG_DEBUG "fakeMouseRelativeMove: %d,%d (%d,%d +/- %d,%d)", ptl.x + dx, ptl.y - dy, ptl.y, ptl.x, dx, dy));
-        if (WinSetPointerPos(HWND_DESKTOP, ptl.x + dx, ptl.y - dy)) {
-            return;
+        fakeMouseMove(ptl.x + dx, ptl.y - dy - m_cy);
+        return;
+    }
+    LOG((CLOG_CRIT "fakeMouseRelativeMove: failed %#lx", WinGetLastError(CPMUtil::getHAB())));
+}
+
+void
+CPMScreen::fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const
+{   
+#if 0 /** @todo send scroll messages the the window beneath the cursor. */
+    POINTL ptl;
+    if (WinQueryPointerPos(HWND_DESKTOP, &ptl)) {
+    }
+#else
+    /* dead simple arrow movement. */
+    yDelta /= 30;
+    while (yDelta != 0) {
+        if (yDelta < 0) {
+            yDelta++;
+            fakeMessage(WM_CHAR, MPFROMSH2CH(KC_VIRTUALKEY | KC_SCANCODE, 1, 0x66), MPFROM2SHORT(0x50e0, VK_DOWN));
+            fakeMessage(WM_CHAR, MPFROMSH2CH(KC_VIRTUALKEY | KC_SCANCODE | KC_KEYUP | KC_LONEKEY | KC_TOGGLE, 1, 0x66), MPFROM2SHORT(0x50e0, VK_DOWN));
+        } else {
+            yDelta--;
+            fakeMessage(WM_CHAR, MPFROMSH2CH(KC_VIRTUALKEY | KC_SCANCODE, 1, 0x61), MPFROM2SHORT(0x48e0, VK_UP));
+            fakeMessage(WM_CHAR, MPFROMSH2CH(KC_VIRTUALKEY | KC_SCANCODE | KC_KEYUP | KC_LONEKEY | KC_TOGGLE, 1, 0x61), MPFROM2SHORT(0x48e0, VK_UP));
         }
     }
-    LOG((CLOG_CRIT "fakeMouseRelativeMove: failed %#lx", WinGetLastError(CPMUtil::getHAB())));
-}
-
-void
-CPMScreen::fakeMouseWheel(SInt32 xDelta, SInt32 yDelta) const
-{
-        //m_desks->fakeMouseWheel(xDelta, yDelta);
+#endif 
 }
 
@@ -602 +694 @@
 CPMScreen::openHookLibrary(const char* name)
 {
-        // load the hook library
-        HMODULE hmod;
-        APIRET rc = DosLoadModule(NULL, 0, (PCSZ)name, &hmod);
+        // load the hook library - try with qualified name first.
+        HMODULE hmod = NULLHANDLE;
+    APIRET rc = ERROR_FILE_NOT_FOUND;
+    char szFullName[CCHMAXPATH + 10];
+    if (!_execname(szFullName, CCHMAXPATH)) {
+        char *psz = strrchr(szFullName, '\\');
+        if (!psz || strrchr(psz, '/')) {
+            psz = strrchr(psz, '/');
+        }
+        if (psz) {
+            strcat(strcpy(psz + 1, name), ".DLL");
+        }
+            rc = DosLoadModule(NULL, 0, (PCSZ)szFullName, &hmod);
+    }
+
+    // if that failed, try with the bare name.
+    if (rc != NO_ERROR) {
+            rc = DosLoadModule(NULL, 0, (PCSZ)name, &hmod);
+    } else {
+        name = szFullName;
+    }
         if (rc != NO_ERROR) {
                 LOG((CLOG_ERR "Failed to load hook library (%s), rc=%d ", name, rc));
@@ -611 +721 @@
 
         // look up functions
-        if (    (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_setSides",      (PPFN)&m_setSides)) != NO_ERROR
+        if (    (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_fakeMsg",       (PPFN)&m_fakeMsg )) != NO_ERROR
+        ||      (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_setSides",      (PPFN)&m_setSides)) != NO_ERROR
                 ||      (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_setZone",       (PPFN)&m_setZone )) != NO_ERROR
                 ||      (rc = DosQueryProcAddr(hmod, 0, (PCSZ)"_setMode",       (PPFN)&m_setMode )) != NO_ERROR
@@ -627 +738 @@
                 throw XScreenOpenFailure();
         }
+    LOG((CLOG_DEBUG1 "openHookLibrary: hmod=%#lx '%s'", hmod, name));
         return hmod;
 }
@@ -633 +745 @@
 CPMScreen::closeHookLibrary(HMODULE hmod) const
 {
+    LOG((CLOG_DEBUG1 "closeHookLibrary: hmod=%#lx\n", hmod));
         if (hmod != NULL) {
                 m_cleanup(m_hab);

trunk/synergy/lib/platform/CPMScreen.h

@@ -100 +100 @@
         HWND                            createWindow(const char* name);
         void                            destroyWindow(HWND) const;
+    
+    // fake message injection
+    void                fakeMessage(ULONG msg, MPARAM mp1, MPARAM mp2) const;
+    void                fakeMouseMessage(ULONG msg, MPARAM mp1) const;
 
         // convenience function to send events
@@ -227 +231 @@
         SetZoneFunc                     m_setZone;
         SetModeFunc                     m_setMode;
+        FakeMsgFunc                     m_fakeMsg;
 
         // keyboard stuff

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;
+}
+

trunk/synergy/lib/platform/CPMSynergyHook.def

@@ -1 +1 @@
 LIBRARY SYNRGYHK INITINSTANCE TERMINSTANCE
-;DATA MULTIPLE
-CODE SHARED
-SEGMENTS
-    'SHAREDDATA32' CLASS 'SHAREDDATA' SHARED READWRITE
+DATA SHARED
 

trunk/synergy/lib/platform/CPMSynergyHook.h

@@ -77 +77 @@
 typedef void            (*SetZoneFunc)(SInt32, SInt32, SInt32, SInt32, SInt32);
 typedef void            (*SetModeFunc)(int);
+typedef const char *    (*FakeMsgFunc)(HAB hab, const QMSG *pQmsg);
 
 CSYNERGYHOOK_API bool   init(HMQ hmq, int tid, int pid);
@@ -84 +85 @@
 CSYNERGYHOOK_API void   setSides(UInt32 sides);
 CSYNERGYHOOK_API void   setZone(SInt32 x, SInt32 y, SInt32 cx, SInt32 cy, SInt32 jumpZoneSize);
-CSYNERGYHOOK_API void   setMode(EHookMode mode);
+CSYNERGYHOOK_API const char * fakeMsg(HAB hab, const QMSG *pQmsg);
 
 #endif

trunk/synergy/lib/platform/CPMSynergyHookData.asm

@@ -13 +13 @@
 ; */
 
+;
+; no dll0/crt0.
+;
+SEGMENT CODE32 CLASS=CODE USE32 FLAT PUBLIC
+..start:
+    jmp _DLL_InitTerm
+extern _DLL_InitTerm
 
-SEGMENT SHAREDDATA32 CLASS=SHAREDDATA USE32 FLAT
-
-%define NAME(name) _ %+ name
-
-%macro GLOBALVAR 2,
-global NAME(%1)
-NAME(%1):
-dd %2
-%endmacro
-
-GLOBALVAR g_hmqSynergy, 0
-GLOBALVAR g_pidSynergy, 0
-GLOBALVAR g_tidSynergy, 0
-GLOBALVAR g_enmMode, 0
-GLOBALVAR g_zoneSides, 0
-GLOBALVAR g_zoneSize, 0
-GLOBALVAR g_xScreen, 0
-GLOBALVAR g_yScreen, 0
-GLOBALVAR g_cxScreen, 0
-GLOBALVAR g_cyScreen, 0
-GLOBALVAR g_fInputHookInstalled, 0
-GLOBALVAR g_fFakingInput, 0
-