windows/hook.c

   1 /*
   2  * Windows hook functions
   3  *
   4  * Copyright 1994, 1995 Alexandre Julliard
   5  *
   6  * Based on investigations by Alex Korobka
   7  */
   8
   9 /*
  10  * Warning!
  11  * A HHOOK is a 32-bit handle for compatibility with Windows 3.0 where it was
  12  * a pointer to the next function. Now it is in fact composed of a USER heap
  13  * handle in the low 16 bits and of a HOOK_MAGIC value in the high 16 bits.
  14  */
  15
  16 #define NO_TRANSITION_TYPES  /* This file is Win32-clean */
  17 #include "hook.h"
  18 #include "callback.h"
  19 #include "queue.h"
  20 #include "user.h"
  21 #include "stddebug.h"
  22 #include "debug.h"
  23
  24   /* This should probably reside in USER heap */
  25 static HANDLE16 HOOK_systemHooks[WH_NB_HOOKS] = { 0, };
  26
  27
  28 /***********************************************************************
  29  *           HOOK_GetNextHook
  30  *
  31  * Get the next hook of a given hook.
  32  */
  33 static HANDLE16 HOOK_GetNextHook( HANDLE16 hook )
  34 {
  35     HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR( hook );
  36     if (!data || !hook) return 0;
  37     if (data->next) return data->next;
  38     if (!data->ownerQueue) return 0;  /* Already system hook */
  39     /* Now start enumerating the system hooks */
  40     return HOOK_systemHooks[data->id - WH_FIRST_HOOK];
  41 }
  42
  43
  44 /***********************************************************************
  45  *           HOOK_GetHook
  46  *
  47  * Get the first hook for a given type.
  48  */
  49 HANDLE16 HOOK_GetHook( INT16 id , HQUEUE16 hQueue )
  50 {
  51     MESSAGEQUEUE *queue;
  52     HANDLE16 hook = 0;
  53
  54     if ((queue = (MESSAGEQUEUE *)GlobalLock16( hQueue )) != NULL)
  55         hook = queue->hooks[id - WH_FIRST_HOOK];
  56     if (!hook) hook = HOOK_systemHooks[id - WH_FIRST_HOOK];
  57     return hook;
  58 }
  59
  60
  61 /***********************************************************************
  62  *           HOOK_SetHook
  63  *
  64  * Install a given hook.
  65  */
  66 static HANDLE16 HOOK_SetHook( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst,
  67                               HTASK16 hTask )
  68 {
  69     HOOKDATA *data;
  70     HANDLE16 handle;
  71     HQUEUE16 hQueue = 0;
  72
  73     if ((id < WH_FIRST_HOOK) || (id > WH_LAST_HOOK)) return 0;
  74     if (!(hInst = GetExePtr( hInst ))) return 0;
  75
  76     dprintf_hook( stddeb, "Setting hook %d: %08x %04x %04x\n",
  77                   id, (UINT32)proc, hInst, hTask );
  78
  79     if (hTask)  /* Task-specific hook */
  80     {
  81         if ((id == WH_JOURNALRECORD) || (id == WH_JOURNALPLAYBACK) ||
  82             (id == WH_SYSMSGFILTER)) return 0;  /* System-only hooks */
  83         if (!(hQueue = GetTaskQueue( hTask ))) return 0;
  84     }
  85
  86     if (id == WH_CBT || id == WH_DEBUG || id == WH_SHELL)
  87     {
  88         fprintf( stdnimp, "Unimplemented hook set: (%d,%08lx,%04x,%04x)!\n",
  89                  id, (DWORD)proc, hInst, hTask );
  90     }
  91
  92     /* Create the hook structure */
  93
  94     if (!(handle = USER_HEAP_ALLOC( sizeof(HOOKDATA) ))) return 0;
  95     data = (HOOKDATA *) USER_HEAP_LIN_ADDR( handle );
  96     data->proc        = proc;
  97     data->id          = id;
  98     data->ownerQueue  = hQueue;
  99     data->ownerModule = hInst;
 100     data->inHookProc  = 0;
 101     dprintf_hook( stddeb, "Setting hook %d: ret=%04x\n", id, handle );
 102
 103     /* Insert it in the correct linked list */
 104
 105     if (hQueue)
 106     {
 107         MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( hQueue );
 108         data->next = queue->hooks[id - WH_FIRST_HOOK];
 109         queue->hooks[id - WH_FIRST_HOOK] = handle;
 110     }
 111     else
 112     {
 113         data->next = HOOK_systemHooks[id - WH_FIRST_HOOK];
 114         HOOK_systemHooks[id - WH_FIRST_HOOK] = handle;
 115     }
 116     return handle;
 117 }
 118
 119
 120 /***********************************************************************
 121  *           HOOK_RemoveHook
 122  *
 123  * Remove a hook from the list.
 124  */
 125 static BOOL32 HOOK_RemoveHook( HANDLE16 hook )
 126 {
 127     HOOKDATA *data;
 128     HANDLE16 *prevHook;
 129
 130     dprintf_hook( stddeb, "Removing hook %04x\n", hook );
 131
 132     if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook))) return FALSE;
 133     if (data->inHookProc)
 134     {
 135         /* Mark it for deletion later on */
 136         dprintf_hook( stddeb, "Hook still running, deletion delayed\n" );
 137         data->proc = (HOOKPROC16)0;
 138         return TRUE;
 139     }
 140
 141     /* Remove it from the linked list */
 142
 143     if (data->ownerQueue)
 144     {
 145         MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( data->ownerQueue );
 146         if (!queue) return FALSE;
 147         prevHook = &queue->hooks[data->id - WH_FIRST_HOOK];
 148     }
 149     else prevHook = &HOOK_systemHooks[data->id - WH_FIRST_HOOK];
 150
 151     while (*prevHook && *prevHook != hook)
 152         prevHook = &((HOOKDATA *)USER_HEAP_LIN_ADDR(*prevHook))->next;
 153
 154      if (!*prevHook) return FALSE;
 155     *prevHook = data->next;
 156     USER_HEAP_FREE( hook );
 157     return TRUE;
 158 }
 159
 160
 161 /***********************************************************************
 162  *           HOOK_CallHook
 163  *
 164  * Call a hook procedure.
 165  */
 166 static LRESULT HOOK_CallHook( HANDLE16 hook, INT16 code,
 167                               WPARAM16 wParam, LPARAM lParam )
 168 {
 169     HOOKDATA *data;
 170     MESSAGEQUEUE *queue;
 171     HANDLE16 prevHook;
 172     LRESULT ret;
 173
 174     /* Find the first hook with a valid proc */
 175
 176     for (;;)
 177     {
 178         if (!hook) return 0;
 179         if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook))) return 0;
 180         if (data->proc) break;
 181         hook = data->next;
 182     }
 183
 184     /* Now call it */
 185
 186     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 187     prevHook = queue->hCurHook;
 188     queue->hCurHook = hook;
 189     data->inHookProc = 1;
 190
 191     dprintf_hook( stddeb, "Calling hook %04x: %d %04lx %08lx\n",
 192                   hook, code, (DWORD)wParam, lParam );
 193     ret = CallHookProc( data->proc, code, wParam, lParam );
 194     dprintf_hook( stddeb, "Ret hook %04x = %08lx\n", hook, ret );
 195
 196     data->inHookProc = 0;
 197     queue->hCurHook = prevHook;
 198     if (!data->proc) HOOK_RemoveHook( hook );
 199     return ret;
 200 }
 201
 202
 203 /***********************************************************************
 204  *           HOOK_CallHooks
 205  *
 206  * Call a hook chain.
 207  */
 208 LRESULT HOOK_CallHooks( INT16 id, INT16 code, WPARAM16 wParam, LPARAM lParam )
 209 {
 210     HANDLE16 hook = HOOK_GetHook( id , GetTaskQueue(0) );
 211     if (!hook) return 0;
 212     return HOOK_CallHook( hook, code, wParam, lParam );
 213 }
 214
 215
 216 /***********************************************************************
 217  *           HOOK_FreeModuleHooks
 218  */
 219 void HOOK_FreeModuleHooks( HMODULE16 hModule )
 220 {
 221  /* remove all system hooks registered by this module */
 222
 223   HOOKDATA*     hptr;
 224   HHOOK         hook, next;
 225   int           id;
 226
 227   for( id = WH_FIRST_HOOK; id <= WH_LAST_HOOK; id++ )
 228     {
 229        hook = HOOK_systemHooks[id - WH_FIRST_HOOK];
 230        while( hook )
 231           if( (hptr = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook)) )
 232             {
 233               next = hptr->next;
 234               if( hptr->ownerModule == hModule )
 235                 {
 236                   hptr->inHookProc = 0;
 237                   HOOK_RemoveHook(hook);
 238                 }
 239               hook = next;
 240             }
 241           else hook = 0;
 242     }
 243 }
 244
 245 /***********************************************************************
 246  *           HOOK_FreeQueueHooks
 247  */
 248 void HOOK_FreeQueueHooks( HQUEUE16 hQueue )
 249 {
 250   /* remove all hooks registered by this queue */
 251
 252   HOOKDATA*     hptr = NULL;
 253   HHOOK         hook, next;
 254   int           id;
 255
 256   for( id = WH_FIRST_HOOK; id <= WH_LAST_HOOK; id++ )
 257     {
 258        hook = HOOK_GetHook( id, hQueue );
 259        while( hook )
 260         {
 261           next = HOOK_GetNextHook(hook);
 262
 263           hptr = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
 264           if( hptr && hptr->ownerQueue == hQueue )
 265             {
 266               hptr->inHookProc = 0;
 267               HOOK_RemoveHook(hook);
 268             }
 269           hook = next;
 270         }
 271     }
 272 }
 273
 274 /***********************************************************************
 275  *           SetWindowsHook   (USER.121)
 276  */
 277 FARPROC16 SetWindowsHook( INT16 id, HOOKPROC16 proc )
 278 {
 279     HINSTANCE16 hInst = __winelib ? 0 : FarGetOwner( HIWORD(proc) );
 280     /* WH_MSGFILTER is the only task-specific hook for SetWindowsHook() */
 281     HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
 282
 283     HANDLE16 handle = HOOK_SetHook( id, proc, hInst, hTask );
 284     if (!handle) return (FARPROC16)-1;
 285     if (!((HOOKDATA *)USER_HEAP_LIN_ADDR( handle ))->next) return 0;
 286     /* Not sure if the return value is correct; should not matter much
 287      * since it's never used (see DefHookProc). -- AJ */
 288     return (FARPROC16)MAKELONG( handle, HOOK_MAGIC );
 289 }
 290
 291
 292 /***********************************************************************
 293  *           UnhookWindowsHook   (USER.234)
 294  */
 295 BOOL16 UnhookWindowsHook( INT16 id, HOOKPROC16 proc )
 296 {
 297     HANDLE16 hook = HOOK_GetHook( id , 0 );
 298
 299     dprintf_hook( stddeb, "UnhookWindowsHook: %d %08lx\n", id, (DWORD)proc );
 300
 301     while (hook)
 302     {
 303         HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
 304         if (data->proc == proc) break;
 305         hook = HOOK_GetNextHook( hook );
 306     }
 307     if (!hook) return FALSE;
 308     return HOOK_RemoveHook( hook );
 309 }
 310
 311
 312 /***********************************************************************
 313  *           DefHookProc   (USER.235)
 314  */
 315 LRESULT DefHookProc( INT16 code, WPARAM16 wParam, LPARAM lParam, HHOOK *hhook )
 316 {
 317     /* Note: the *hhook parameter is never used, since we rely on the
 318      * current hook value from the task queue to find the next hook. */
 319     MESSAGEQUEUE *queue;
 320     HANDLE16 next;
 321
 322     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 323     if (!(next = HOOK_GetNextHook( queue->hCurHook ))) return 0;
 324     return HOOK_CallHook( next, code, wParam, lParam );
 325 }
 326
 327
 328 /***********************************************************************
 329  *           CallMsgFilter   (USER.123)
 330  */
 331 BOOL16 CallMsgFilter( SEGPTR msg, INT16 code )
 332 {
 333     if (GetSysModalWindow16()) return FALSE;
 334     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg )) return TRUE;
 335     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg );
 336 }
 337
 338
 339 /***********************************************************************
 340  *           SetWindowsHookEx   (USER.291)
 341  */
 342 HHOOK SetWindowsHookEx( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst,
 343                         HTASK16 hTask )
 344 {
 345     HANDLE16 handle = HOOK_SetHook( id, proc, hInst, hTask );
 346     return MAKELONG( handle, HOOK_MAGIC );
 347 }
 348
 349
 350 /***********************************************************************
 351  *           UnhookWindowHookEx   (USER.292)
 352  */
 353 BOOL16 UnhookWindowsHookEx( HHOOK hhook )
 354 {
 355     if (HIWORD(hhook) != HOOK_MAGIC) return FALSE;  /* Not a new format hook */
 356     return HOOK_RemoveHook( LOWORD(hhook) );
 357 }
 358
 359
 360 /***********************************************************************
 361  *           CallNextHookEx   (USER.293)
 362  */
 363 LRESULT CallNextHookEx(HHOOK hhook, INT16 code, WPARAM16 wParam, LPARAM lParam)
 364 {
 365     HANDLE16 next;
 366     if (HIWORD(hhook) != HOOK_MAGIC) return 0;  /* Not a new format hook */
 367     if (!(next = HOOK_GetNextHook( LOWORD(hhook) ))) return 0;
 368     return HOOK_CallHook( next, code, wParam, lParam );
 369 }