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