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_MINHOOK];
  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_MINHOOK];
  56     if (!hook) hook = HOOK_systemHooks[id - WH_MINHOOK];
  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_MINHOOK) || (id > WH_MAXHOOK)) 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_DEBUG)
  87     {
  88         fprintf( stdnimp,"WH_DEBUG is broken in 16-bit Windows.\n");
  89         return 0;
  90     }
  91     else if (id == WH_CBT || id == WH_SHELL)
  92     {
  93         fprintf( stdnimp, "Half-implemented hook set: (%s,%08lx,%04x,%04x)!\n",
  94                  (id==WH_CBT)?"WH_CBT":"WH_SHELL", (DWORD)proc, hInst, hTask );
  95     }
  96
  97     if (id == WH_JOURNALPLAYBACK) EnableHardwareInput(FALSE);
  98
  99     /* Create the hook structure */
 100
 101     if (!(handle = USER_HEAP_ALLOC( sizeof(HOOKDATA) ))) return 0;
 102     data = (HOOKDATA *) USER_HEAP_LIN_ADDR( handle );
 103     data->proc        = proc;
 104     data->id          = id;
 105     data->ownerQueue  = hQueue;
 106     data->ownerModule = hInst;
 107     data->inHookProc  = 0;
 108     dprintf_hook( stddeb, "Setting hook %d: ret=%04x\n", id, handle );
 109
 110     /* Insert it in the correct linked list */
 111
 112     if (hQueue)
 113     {
 114         MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( hQueue );
 115         data->next = queue->hooks[id - WH_MINHOOK];
 116         queue->hooks[id - WH_MINHOOK] = handle;
 117     }
 118     else
 119     {
 120         data->next = HOOK_systemHooks[id - WH_MINHOOK];
 121         HOOK_systemHooks[id - WH_MINHOOK] = handle;
 122     }
 123     return handle;
 124 }
 125
 126
 127 /***********************************************************************
 128  *           HOOK_RemoveHook
 129  *
 130  * Remove a hook from the list.
 131  */
 132 static BOOL32 HOOK_RemoveHook( HANDLE16 hook )
 133 {
 134     HOOKDATA *data;
 135     HANDLE16 *prevHook;
 136
 137     dprintf_hook( stddeb, "Removing hook %04x\n", hook );
 138
 139     if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook))) return FALSE;
 140     if (data->inHookProc)
 141     {
 142         /* Mark it for deletion later on */
 143         dprintf_hook( stddeb, "Hook still running, deletion delayed\n" );
 144         data->proc = (HOOKPROC16)0;
 145         return TRUE;
 146     }
 147
 148     if (data->id == WH_JOURNALPLAYBACK) EnableHardwareInput(TRUE);
 149
 150     /* Remove it from the linked list */
 151
 152     if (data->ownerQueue)
 153     {
 154         MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( data->ownerQueue );
 155         if (!queue) return FALSE;
 156         prevHook = &queue->hooks[data->id - WH_MINHOOK];
 157     }
 158     else prevHook = &HOOK_systemHooks[data->id - WH_MINHOOK];
 159
 160     while (*prevHook && *prevHook != hook)
 161         prevHook = &((HOOKDATA *)USER_HEAP_LIN_ADDR(*prevHook))->next;
 162
 163      if (!*prevHook) return FALSE;
 164     *prevHook = data->next;
 165     USER_HEAP_FREE( hook );
 166     return TRUE;
 167 }
 168
 169
 170 /***********************************************************************
 171  *           HOOK_CallHook
 172  *
 173  * Call a hook procedure.
 174  */
 175 static LRESULT HOOK_CallHook( HANDLE16 hook, INT16 code,
 176                               WPARAM16 wParam, LPARAM lParam )
 177 {
 178     HOOKDATA *data;
 179     MESSAGEQUEUE *queue;
 180     HANDLE16 prevHook;
 181     LRESULT ret;
 182
 183     /* Find the first hook with a valid proc */
 184
 185     for (;;)
 186     {
 187         if (!hook) return 0;
 188         if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook))) return 0;
 189         if (data->proc) break;
 190         hook = data->next;
 191     }
 192
 193     /* Now call it */
 194
 195     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 196     prevHook = queue->hCurHook;
 197     queue->hCurHook = hook;
 198     data->inHookProc = 1;
 199
 200     dprintf_hook( stddeb, "Calling hook %04x: %d %04lx %08lx\n",
 201                   hook, code, (DWORD)wParam, lParam );
 202     ret = CallHookProc( data->proc, code, wParam, lParam );
 203     dprintf_hook( stddeb, "Ret hook %04x = %08lx\n", hook, ret );
 204
 205     data->inHookProc = 0;
 206     queue->hCurHook = prevHook;
 207     if (!data->proc) HOOK_RemoveHook( hook );
 208     return ret;
 209 }
 210
 211
 212 /***********************************************************************
 213  *           HOOK_CallHooks
 214  *
 215  * Call a hook chain.
 216  */
 217 LRESULT HOOK_CallHooks( INT16 id, INT16 code, WPARAM16 wParam, LPARAM lParam )
 218 {
 219     HANDLE16 hook = HOOK_GetHook( id , GetTaskQueue(0) );
 220     if (!hook) return 0;
 221     return HOOK_CallHook( hook, code, wParam, lParam );
 222 }
 223
 224
 225 /***********************************************************************
 226  *           HOOK_FreeModuleHooks
 227  */
 228 void HOOK_FreeModuleHooks( HMODULE16 hModule )
 229 {
 230  /* remove all system hooks registered by this module */
 231
 232   HOOKDATA*     hptr;
 233   HHOOK         hook, next;
 234   int           id;
 235
 236   for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
 237     {
 238        hook = HOOK_systemHooks[id - WH_MINHOOK];
 239        while( hook )
 240           if( (hptr = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook)) )
 241             {
 242               next = hptr->next;
 243               if( hptr->ownerModule == hModule )
 244                 {
 245                   hptr->inHookProc = 0;
 246                   HOOK_RemoveHook(hook);
 247                 }
 248               hook = next;
 249             }
 250           else hook = 0;
 251     }
 252 }
 253
 254 /***********************************************************************
 255  *           HOOK_FreeQueueHooks
 256  */
 257 void HOOK_FreeQueueHooks( HQUEUE16 hQueue )
 258 {
 259   /* remove all hooks registered by this queue */
 260
 261   HOOKDATA*     hptr = NULL;
 262   HHOOK         hook, next;
 263   int           id;
 264
 265   for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
 266     {
 267        hook = HOOK_GetHook( id, hQueue );
 268        while( hook )
 269         {
 270           next = HOOK_GetNextHook(hook);
 271
 272           hptr = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
 273           if( hptr && hptr->ownerQueue == hQueue )
 274             {
 275               hptr->inHookProc = 0;
 276               HOOK_RemoveHook(hook);
 277             }
 278           hook = next;
 279         }
 280     }
 281 }
 282
 283 /***********************************************************************
 284  *           SetWindowsHook   (USER.121)
 285  */
 286 FARPROC16 SetWindowsHook( INT16 id, HOOKPROC16 proc )
 287 {
 288     HINSTANCE16 hInst = __winelib ? 0 : FarGetOwner( HIWORD(proc) );
 289     HTASK16     hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
 290     HANDLE16    handle = HOOK_SetHook( id, proc, hInst, hTask );
 291
 292     return (handle) ? (FARPROC16)MAKELONG( handle, HOOK_MAGIC ) : NULL;
 293 }
 294
 295
 296 /***********************************************************************
 297  *           UnhookWindowsHook   (USER.234)
 298  */
 299 BOOL16 UnhookWindowsHook( INT16 id, HOOKPROC16 proc )
 300 {
 301     HANDLE16 hook = HOOK_GetHook( id , 0 );
 302
 303     dprintf_hook( stddeb, "UnhookWindowsHook: %d %08lx\n", id, (DWORD)proc );
 304
 305     while (hook)
 306     {
 307         HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
 308         if (data->proc == proc) break;
 309         hook = HOOK_GetNextHook( hook );
 310     }
 311     if (!hook) return FALSE;
 312     return HOOK_RemoveHook( hook );
 313 }
 314
 315
 316 /***********************************************************************
 317  *           DefHookProc   (USER.235)
 318  */
 319 LRESULT DefHookProc( INT16 code, WPARAM16 wParam, LPARAM lParam, HHOOK *hhook )
 320 {
 321     /* Note: the *hhook parameter is never used, since we rely on the
 322      * current hook value from the task queue to find the next hook. */
 323     MESSAGEQUEUE *queue;
 324     HANDLE16 next;
 325
 326     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 327     if (!(next = HOOK_GetNextHook( queue->hCurHook ))) return 0;
 328     return HOOK_CallHook( next, code, wParam, lParam );
 329 }
 330
 331
 332 /***********************************************************************
 333  *           CallMsgFilter   (USER.123)
 334  */
 335 BOOL16 CallMsgFilter( SEGPTR msg, INT16 code )
 336 {
 337     if (GetSysModalWindow16()) return FALSE;
 338     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg )) return TRUE;
 339     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg );
 340 }
 341
 342
 343 /***********************************************************************
 344  *           SetWindowsHookEx   (USER.291)
 345  */
 346 HHOOK SetWindowsHookEx( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst,
 347                         HTASK16 hTask )
 348 {
 349     HANDLE16 handle = HOOK_SetHook( id, proc, hInst, hTask );
 350     return (handle) ? MAKELONG( handle, HOOK_MAGIC ) : NULL;
 351 }
 352
 353
 354 /***********************************************************************
 355  *           UnhookWindowHookEx   (USER.292)
 356  */
 357 BOOL16 UnhookWindowsHookEx( HHOOK hhook )
 358 {
 359     if (HIWORD(hhook) != HOOK_MAGIC) return FALSE;  /* Not a new format hook */
 360     return HOOK_RemoveHook( LOWORD(hhook) );
 361 }
 362
 363
 364 /***********************************************************************
 365  *           CallNextHookEx   (USER.293)
 366  */
 367 LRESULT CallNextHookEx(HHOOK hhook, INT16 code, WPARAM16 wParam, LPARAM lParam)
 368 {
 369     HANDLE16 next;
 370     if (HIWORD(hhook) != HOOK_MAGIC) return 0;  /* Not a new format hook */
 371     if (!(next = HOOK_GetNextHook( LOWORD(hhook) ))) return 0;
 372     return HOOK_CallHook( next, code, wParam, lParam );
 373 }