windows/hook.c

   1 /*
   2  * Windows hook functions
   3  *
   4  * Copyright 1994, 1995 Alexandre Julliard
   5  *                 1996 Andrew Lewycky
   6  *
   7  * Based on investigations by Alex Korobka
   8  */
   9
  10 /*
  11  * Warning!
  12  * A HHOOK is a 32-bit handle for compatibility with Windows 3.0 where it was
  13  * a pointer to the next function. Now it is in fact composed of a USER heap
  14  * handle in the low 16 bits and of a HOOK_MAGIC value in the high 16 bits.
  15  */
  16
  17 #define NO_TRANSITION_TYPES  /* This file is Win32-clean */
  18 #include "windows.h"
  19 #include "hook.h"
  20 #include "queue.h"
  21 #include "user.h"
  22 #include "heap.h"
  23 #include "struct32.h"
  24 #include "string32.h"
  25 #include "stddebug.h"
  26 #include "debug.h"
  27
  28 #pragma pack(1)
  29
  30   /* Hook data (pointed to by a HHOOK) */
  31 typedef struct
  32 {
  33     HANDLE16   next;               /* 00 Next hook in chain */
  34     HOOKPROC32 proc WINE_PACKED;   /* 02 Hook procedure */
  35     INT16      id;                 /* 06 Hook id (WH_xxx) */
  36     HQUEUE16   ownerQueue;         /* 08 Owner queue (0 for system hook) */
  37     HMODULE16  ownerModule;        /* 0a Owner module */
  38     WORD       inHookProc;         /* 0c TRUE if in this->proc */
  39     INT32      flags;
  40 } HOOKDATA;
  41
  42 #pragma pack(4)
  43
  44 #define HOOK_MAGIC  ((int)'H' | (int)'K' << 8)  /* 'HK' */
  45
  46   /* This should probably reside in USER heap */
  47 static HANDLE16 HOOK_systemHooks[WH_NB_HOOKS] = { 0, };
  48
  49 typedef VOID (*HOOK_MapFunc)(INT32, INT32, WPARAM32 *, LPARAM *);
  50 typedef VOID (*HOOK_UnMapFunc)(INT32, INT32, WPARAM32, LPARAM, WPARAM32,
  51                                LPARAM);
  52
  53
  54 /***********************************************************************
  55  *           Hook Mapping Functions
  56  */
  57
  58
  59 /***********************************************************************
  60  *           HOOK_Map16To32Common
  61  */
  62 static void HOOK_Map16To32Common(INT32 id, INT32 code, WPARAM32 *pwParam,
  63                                  LPARAM *plParam)
  64 {
  65     switch (id)
  66     {
  67     case WH_MSGFILTER:
  68     case WH_SYSMSGFILTER:
  69     case WH_GETMESSAGE:
  70     case WH_JOURNALRECORD:
  71         {
  72             LPMSG16 lpmsg16 = PTR_SEG_TO_LIN(*plParam);
  73             LPMSG32 lpmsg32 = HeapAlloc( SystemHeap, 0, sizeof(*lpmsg32) );
  74
  75             STRUCT32_MSG16to32( lpmsg16, lpmsg32 );
  76             *plParam = (LPARAM)lpmsg32;
  77             break;
  78         }
  79     case WH_JOURNALPLAYBACK:
  80         {
  81             LPEVENTMSG16 lpem16 = PTR_SEG_TO_LIN(*plParam);
  82             LPEVENTMSG32 lpem32 = HeapAlloc( SystemHeap, 0, sizeof(*lpem32) );
  83
  84             lpem32->message = lpem16->message;
  85             lpem32->paramL = lpem16->paramL;
  86             lpem32->paramH = lpem16->paramH;
  87             lpem32->time = lpem16->time;
  88             lpem32->hwnd = 0;   /* FIXME */
  89
  90             *plParam = (LPARAM)lpem32;
  91             break;
  92         }
  93     case WH_CBT:
  94         switch (code)
  95         {
  96         case HCBT_ACTIVATE:
  97             {
  98                 LPCBTACTIVATESTRUCT16 lpcas16 = PTR_SEG_TO_LIN(*plParam);
  99                 LPCBTACTIVATESTRUCT32 lpcas32 = HeapAlloc( SystemHeap, 0,
 100                                                            sizeof(*lpcas32) );
 101                 lpcas32->fMouse = lpcas16->fMouse;
 102                 lpcas32->hWndActive = lpcas16->hWndActive;
 103                 *plParam = (LPARAM)lpcas32;
 104                 break;
 105             }
 106         case HCBT_CLICKSKIPPED:
 107             {
 108                 LPMOUSEHOOKSTRUCT16 lpms16 = PTR_SEG_TO_LIN(*plParam);
 109                 LPMOUSEHOOKSTRUCT32 lpms32 = HeapAlloc( SystemHeap, 0,
 110                                                         sizeof(*lpms32) );
 111
 112                 STRUCT32_POINT16to32( &lpms16->pt, &lpms32->pt );
 113
 114                 /* wHitTestCode may be negative, so convince compiler to do
 115                    correct sign extension. Yay. :| */
 116                 lpms32->wHitTestCode = (INT32)((INT16)lpms16->wHitTestCode);
 117
 118                 lpms32->dwExtraInfo = lpms16->dwExtraInfo;
 119                 lpms32->hwnd = lpms16->hwnd;
 120                 *plParam = (LPARAM)lpms32;
 121                 break;
 122             }
 123         case HCBT_MOVESIZE:
 124             {
 125                 LPRECT16 lprect16 = PTR_SEG_TO_LIN(*plParam);
 126                 LPRECT32 lprect32 = HeapAlloc( SystemHeap, 0,
 127                                                sizeof(*lprect32) );
 128
 129                 STRUCT32_RECT16to32( lprect16, lprect32 );
 130                 *plParam = (LPARAM)lprect32;
 131                 break;
 132             }
 133         }
 134         break;
 135     case WH_MOUSE:
 136         {
 137             LPMOUSEHOOKSTRUCT16 lpms16 = PTR_SEG_TO_LIN(*plParam);
 138             LPMOUSEHOOKSTRUCT32 lpms32 = HeapAlloc( SystemHeap, 0,
 139                                                     sizeof(*lpms32) );
 140
 141             STRUCT32_POINT16to32( &lpms16->pt, &lpms32->pt );
 142
 143             /* wHitTestCode may be negative, so convince compiler to do
 144                correct sign extension. Yay. :| */
 145             lpms32->wHitTestCode = (INT32)((INT16)lpms16->wHitTestCode);
 146             lpms32->dwExtraInfo = lpms16->dwExtraInfo;
 147             lpms32->hwnd = lpms16->hwnd;
 148             *plParam = (LPARAM)lpms32;
 149             break;
 150         }
 151     case WH_DEBUG:
 152         {
 153             LPDEBUGHOOKINFO16 lpdh16 = PTR_SEG_TO_LIN(*plParam);
 154             LPDEBUGHOOKINFO32 lpdh32 = HeapAlloc( SystemHeap, 0,
 155                                                   sizeof(*lpdh32) );
 156
 157             lpdh32->idThread = 0;               /* FIXME */
 158             lpdh32->idThreadInstaller = 0;      /* FIXME */
 159             lpdh32->lParam = lpdh16->lParam;    /* FIXME Check for sign ext */
 160             lpdh32->wParam = lpdh16->wParam;
 161             lpdh32->code = lpdh16->code;
 162
 163             /* do sign extension if it was WH_MSGFILTER */
 164             if (*pwParam == 0xffff) *pwParam = WH_MSGFILTER;
 165
 166             *plParam = (LPARAM)lpdh32;
 167             break;
 168         }
 169     case WH_SHELL:
 170     case WH_KEYBOARD:
 171         break;
 172
 173     case WH_CALLWNDPROC:
 174     case WH_HARDWARE:
 175         break;  /* NYI */
 176
 177     default:
 178         fprintf(stderr, "Unknown hook id: %d\n", id);
 179         return;
 180     }
 181 }
 182
 183
 184 /***********************************************************************
 185  *           HOOK_Map16To32A
 186  */
 187 static void HOOK_Map16To32A(INT32 id, INT32 code, WPARAM32 *pwParam,
 188                             LPARAM *plParam)
 189 {
 190     if (id == WH_CBT && code == HCBT_CREATEWND)
 191     {
 192         LPCBT_CREATEWND16 lpcbtcw16 = PTR_SEG_TO_LIN(*plParam);
 193         LPCBT_CREATEWND32A lpcbtcw32 = HeapAlloc( SystemHeap, 0,
 194                                                   sizeof(*lpcbtcw32) );
 195         lpcbtcw32->lpcs = HeapAlloc( SystemHeap, 0,
 196                                      sizeof(*lpcbtcw32->lpcs) );
 197
 198         STRUCT32_CREATESTRUCT16to32A( lpcbtcw16->lpcs, lpcbtcw32->lpcs );
 199
 200         if (HIWORD(lpcbtcw16->lpcs->lpszName))
 201             lpcbtcw32->lpcs->lpszName
 202                 = PTR_SEG_TO_LIN(lpcbtcw16->lpcs->lpszName);
 203         else
 204             lpcbtcw32->lpcs->lpszName = (LPSTR)lpcbtcw16->lpcs->lpszName;
 205
 206         if (HIWORD(lpcbtcw16->lpcs->lpszClass))
 207             lpcbtcw32->lpcs->lpszClass
 208                 = PTR_SEG_TO_LIN(lpcbtcw16->lpcs->lpszClass);
 209         else
 210             lpcbtcw32->lpcs->lpszClass = (LPSTR)lpcbtcw16->lpcs->lpszClass;
 211
 212         lpcbtcw32->hwndInsertAfter = lpcbtcw16->hwndInsertAfter;
 213
 214         *plParam = (LPARAM)lpcbtcw32;
 215     }
 216     else
 217         HOOK_Map16To32Common( id, code, pwParam, plParam );
 218 }
 219
 220
 221 /***********************************************************************
 222  *           HOOK_Map16To32W
 223  */
 224 static void HOOK_Map16To32W(INT32 id, INT32 code, WPARAM32 *pwParam,
 225                             LPARAM *plParam)
 226 {
 227     if (id == WH_CBT && code == HCBT_CREATEWND)
 228     {
 229         LPCBT_CREATEWND16 lpcbtcw16 = PTR_SEG_TO_LIN(*plParam);
 230         LPCREATESTRUCT16 lpcs16 = PTR_SEG_TO_LIN(lpcbtcw16->lpcs);
 231         LPCBT_CREATEWND32W lpcbtcw32 = HeapAlloc( SystemHeap, 0,
 232                                                   sizeof(*lpcbtcw32) );
 233         lpcbtcw32->lpcs = HeapAlloc( SystemHeap, 0,
 234                                      sizeof(*lpcbtcw32->lpcs) );
 235
 236         STRUCT32_CREATESTRUCT16to32A( lpcs16,
 237                                       (LPCREATESTRUCT32A)lpcbtcw32->lpcs );
 238
 239         if (HIWORD(lpcs16->lpszName))
 240             lpcbtcw32->lpcs->lpszName =
 241                 STRING32_DupAnsiToUni( PTR_SEG_TO_LIN(lpcs16->lpszName) );
 242         else
 243             lpcbtcw32->lpcs->lpszName = (LPWSTR)lpcs16->lpszName;
 244
 245         if (HIWORD(lpcs16->lpszClass))
 246             lpcbtcw32->lpcs->lpszClass =
 247                 STRING32_DupAnsiToUni( PTR_SEG_TO_LIN(lpcs16->lpszClass) );
 248         else
 249             lpcbtcw32->lpcs->lpszClass = (LPWSTR)lpcs16->lpszClass;
 250
 251         lpcbtcw32->hwndInsertAfter = lpcbtcw16->hwndInsertAfter;
 252
 253         *plParam = (LPARAM)lpcbtcw32;
 254     }
 255     else HOOK_Map16To32Common( id, code, pwParam, plParam );
 256 }
 257
 258
 259 /***********************************************************************
 260  *           HOOK_UnMap16To32Common
 261  */
 262 static void HOOK_UnMap16To32Common(INT32 id, INT32 code, WPARAM32 wParamOrig,
 263                                    LPARAM lParamOrig, WPARAM32 wParam,
 264                                    LPARAM lParam)
 265 {
 266     switch (id)
 267     {
 268       case WH_MSGFILTER:
 269       case WH_SYSMSGFILTER:
 270       case WH_JOURNALRECORD:
 271       case WH_JOURNALPLAYBACK:
 272       {
 273           HeapFree( SystemHeap, 0, (LPVOID)lParam );
 274           break;
 275       }
 276
 277       case WH_GETMESSAGE:
 278       {
 279           LPMSG16 lpmsg16 = PTR_SEG_TO_LIN(lParamOrig);
 280           STRUCT32_MSG32to16( (LPMSG32)lParam, lpmsg16 );
 281           HeapFree( SystemHeap, 0, (LPVOID)lParam );
 282           break;
 283       }
 284
 285       case WH_MOUSE:
 286       case WH_DEBUG:
 287         HeapFree( SystemHeap, 0, (LPVOID)lParam );
 288         break;
 289
 290         /* I don't think any of these need to be copied */
 291       case WH_CBT:
 292         switch (code)
 293         {
 294           case HCBT_ACTIVATE:
 295           case HCBT_CLICKSKIPPED:
 296           case HCBT_MOVESIZE:
 297             HeapFree( SystemHeap, 0, (LPVOID)lParam);
 298             break;
 299         }
 300         break;
 301
 302       case WH_SHELL:
 303       case WH_KEYBOARD:
 304         break;
 305
 306       case WH_CALLWNDPROC:
 307       case WH_HARDWARE:
 308         fprintf(stderr, "Can't map hook id: %d\n", id);
 309         break;
 310
 311       default:
 312         fprintf(stderr, "Unknown hook id: %d\n", id);
 313         return;
 314     }
 315 }
 316
 317
 318 /***********************************************************************
 319  *           HOOK_UnMap16To32A
 320  */
 321 static void HOOK_UnMap16To32A(INT32 id, INT32 code, WPARAM32 wParamOrig,
 322                               LPARAM lParamOrig, WPARAM32 wParam,
 323                               LPARAM lParam)
 324 {
 325     if (id == WH_CBT && code == HCBT_CREATEWND)
 326     {
 327         LPCBT_CREATEWND32A lpcbtcw32 = (LPCBT_CREATEWND32A)lParam;
 328         HeapFree( SystemHeap, 0, lpcbtcw32->lpcs );
 329         HeapFree( SystemHeap, 0, lpcbtcw32 );
 330     }
 331     else
 332       HOOK_UnMap16To32Common( id, code, wParamOrig, lParamOrig, wParam,
 333                               lParam);
 334     return;
 335 }
 336
 337
 338 /***********************************************************************
 339  *           HOOK_UnMap16To32W
 340  */
 341 static void HOOK_UnMap16To32W(INT32 id, INT32 code, WPARAM32 wParamOrig,
 342                               LPARAM lParamOrig, WPARAM32 wParam,
 343                               LPARAM lParam)
 344 {
 345     if (id == WH_CBT && code == HCBT_CREATEWND)
 346     {
 347         LPCBT_CREATEWND32W lpcbtcw32 = (LPCBT_CREATEWND32W)lParam;
 348         if (HIWORD(lpcbtcw32->lpcs->lpszName))
 349           free( (LPWSTR)lpcbtcw32->lpcs->lpszName );
 350         if (HIWORD(lpcbtcw32->lpcs->lpszClass))
 351           free( (LPWSTR)lpcbtcw32->lpcs->lpszClass );
 352         HeapFree( SystemHeap, 0, lpcbtcw32->lpcs );
 353         HeapFree( SystemHeap, 0, lpcbtcw32 );
 354     }
 355     else
 356       HOOK_UnMap16To32Common(id, code, wParamOrig, lParamOrig, wParam, lParam);
 357 }
 358
 359
 360 /***********************************************************************
 361  *           HOOK_Map32To16Common
 362  */
 363 static void HOOK_Map32To16Common(INT32 id, INT32 code, WPARAM32 *pwParam,
 364                                  LPARAM *plParam)
 365 {
 366     switch (id)
 367     {
 368       case WH_MSGFILTER:
 369       case WH_SYSMSGFILTER:
 370       case WH_GETMESSAGE:
 371       case WH_JOURNALRECORD:
 372       {
 373           LPMSG32 lpmsg32 = (LPMSG32)*plParam;
 374           LPMSG16 lpmsg16 = SEGPTR_NEW( MSG16 );
 375
 376           STRUCT32_MSG32to16( lpmsg32, lpmsg16 );
 377
 378           *plParam = (LPARAM)SEGPTR_GET( lpmsg16 );
 379           break;
 380       }
 381
 382       case WH_JOURNALPLAYBACK:
 383       {
 384           LPEVENTMSG32 lpem32 = (LPEVENTMSG32)*plParam;
 385           LPEVENTMSG16 lpem16 = SEGPTR_NEW( EVENTMSG16 );
 386
 387           lpem16->message = lpem32->message;
 388           lpem16->paramL  = lpem32->paramL;
 389           lpem16->paramH  = lpem32->paramH;
 390           lpem16->time    = lpem32->time;
 391
 392           *plParam = (LPARAM)SEGPTR_GET( lpem16 );
 393           break;
 394       }
 395
 396       case WH_CBT:
 397         switch (code)
 398         {
 399           case HCBT_ACTIVATE:
 400           {
 401               LPCBTACTIVATESTRUCT32 lpcas32 = (LPCBTACTIVATESTRUCT32)*plParam;
 402               LPCBTACTIVATESTRUCT16 lpcas16 =SEGPTR_NEW( CBTACTIVATESTRUCT16 );
 403
 404               lpcas16->fMouse     = lpcas32->fMouse;
 405               lpcas16->hWndActive = lpcas32->hWndActive
 406 ;
 407               *plParam = (LPARAM)SEGPTR_GET( lpcas16 );
 408               break;
 409           }
 410
 411           case HCBT_CLICKSKIPPED:
 412           {
 413               LPMOUSEHOOKSTRUCT32 lpms32 = (LPMOUSEHOOKSTRUCT32)*plParam;
 414               LPMOUSEHOOKSTRUCT16 lpms16 = SEGPTR_NEW( MOUSEHOOKSTRUCT16 );
 415
 416               STRUCT32_POINT32to16( &lpms32->pt, &lpms16->pt );
 417
 418               lpms16->hwnd         = lpms32->hwnd;
 419               lpms16->wHitTestCode = lpms32->wHitTestCode;
 420               lpms16->dwExtraInfo  = lpms32->dwExtraInfo;
 421
 422               *plParam = (LPARAM)SEGPTR_GET( lpms16 );
 423               break;
 424           }
 425
 426           case HCBT_MOVESIZE:
 427           {
 428               LPRECT32 lprect32 = (LPRECT32)*plParam;
 429               LPRECT16 lprect16 = SEGPTR_NEW( RECT16 );
 430
 431               STRUCT32_RECT32to16( lprect32, lprect16 );
 432
 433               *plParam = (LPARAM)SEGPTR_GET( lprect16 );
 434               break;
 435           }
 436         }
 437         break;
 438
 439       case WH_MOUSE:
 440       {
 441           LPMOUSEHOOKSTRUCT32 lpms32 = (LPMOUSEHOOKSTRUCT32)*plParam;
 442           LPMOUSEHOOKSTRUCT16 lpms16 = SEGPTR_NEW( MOUSEHOOKSTRUCT16 );
 443
 444           STRUCT32_POINT32to16( &lpms32->pt, &lpms16->pt );
 445
 446           lpms16->hwnd = lpms32->hwnd;
 447           lpms16->wHitTestCode = lpms32->wHitTestCode;
 448           lpms16->dwExtraInfo = lpms32->dwExtraInfo;
 449
 450           *plParam = (LPARAM)SEGPTR_GET( lpms16 );
 451           break;
 452       }
 453
 454       case WH_DEBUG:
 455       {
 456           LPDEBUGHOOKINFO32 lpdh32 = (LPDEBUGHOOKINFO32)*plParam;
 457           LPDEBUGHOOKINFO16 lpdh16 = SEGPTR_NEW( DEBUGHOOKINFO16 );
 458
 459           lpdh16->hModuleHook = 0;      /* FIXME */
 460           lpdh16->reserved    = 0;
 461           lpdh16->lParam      = lpdh32->lParam;
 462           lpdh16->wParam      = lpdh32->wParam;
 463           lpdh16->code        = lpdh32->code;
 464
 465           *plParam = (LPARAM)SEGPTR_GET( lpdh16 );
 466           break;
 467       }
 468
 469       case WH_SHELL:
 470       case WH_KEYBOARD:
 471         break;
 472
 473       case WH_CALLWNDPROC:
 474       case WH_HARDWARE:
 475         fprintf(stderr, "Can't map hook id: %d\n", id);
 476         break;
 477
 478       default:
 479         fprintf(stderr, "Unknown hook id: %d\n", id);
 480         return;
 481     }
 482 }
 483
 484
 485 /***********************************************************************
 486  *           HOOK_Map32ATo16
 487  */
 488 static void HOOK_Map32ATo16(INT32 id, INT32 code, WPARAM32 *pwParam,
 489                             LPARAM *plParam)
 490 {
 491     if (id == WH_CBT && code == HCBT_CREATEWND)
 492     {
 493         LPCBT_CREATEWND32A lpcbtcw32 = (LPCBT_CREATEWND32A)*plParam;
 494         LPCBT_CREATEWND16 lpcbtcw16 = SEGPTR_NEW( CBT_CREATEWND16 );
 495         LPCREATESTRUCT16 lpcs16 = SEGPTR_NEW( CREATESTRUCT16 );
 496
 497         lpcbtcw16->lpcs = (LPCREATESTRUCT16)SEGPTR_GET( lpcs16 );
 498         STRUCT32_CREATESTRUCT32Ato16( lpcbtcw32->lpcs, lpcs16 );
 499
 500         if (HIWORD(lpcbtcw32->lpcs->lpszName))
 501           lpcs16->lpszName =
 502             SEGPTR_GET( SEGPTR_STRDUP( lpcbtcw32->lpcs->lpszName ) );
 503         else
 504           lpcs16->lpszName = (SEGPTR)lpcbtcw32->lpcs->lpszName;
 505
 506         if (HIWORD(lpcbtcw32->lpcs->lpszClass))
 507           lpcs16->lpszClass =
 508             SEGPTR_GET( SEGPTR_STRDUP( lpcbtcw32->lpcs->lpszClass ) );
 509         else
 510           lpcs16->lpszClass = (SEGPTR)lpcbtcw32->lpcs->lpszClass;
 511
 512         lpcbtcw16->hwndInsertAfter = lpcbtcw32->hwndInsertAfter;
 513
 514         *plParam = (LPARAM)SEGPTR_GET( lpcbtcw16 );
 515     }
 516     else HOOK_Map32To16Common(id, code, pwParam, plParam);
 517 }
 518
 519
 520 /***********************************************************************
 521  *           HOOK_Map32WTo16
 522  */
 523 static void HOOK_Map32WTo16(INT32 id, INT32 code, WPARAM32 *pwParam,
 524                             LPARAM *plParam)
 525 {
 526     if (id == WH_CBT && code == HCBT_CREATEWND)
 527     {
 528         LPCBT_CREATEWND32W lpcbtcw32 = (LPCBT_CREATEWND32W)*plParam;
 529         LPCBT_CREATEWND16 lpcbtcw16 = SEGPTR_NEW( CBT_CREATEWND16 );
 530         LPCREATESTRUCT16 lpcs16 = SEGPTR_NEW( CREATESTRUCT16 );
 531
 532         lpcbtcw16->lpcs = (LPCREATESTRUCT16)SEGPTR_GET( lpcs16 );
 533         STRUCT32_CREATESTRUCT32Ato16( (LPCREATESTRUCT32A)lpcbtcw32->lpcs,
 534                                       lpcs16 );
 535
 536         if (HIWORD(lpcbtcw32->lpcs->lpszName))
 537         {
 538             LPSTR str = SEGPTR_ALLOC( lstrlen32W(lpcbtcw32->lpcs->lpszName) );
 539             STRING32_UniToAnsi( str, lpcbtcw32->lpcs->lpszName );
 540             lpcs16->lpszName = SEGPTR_GET( str );
 541         }
 542         else
 543           lpcs16->lpszName = (SEGPTR)lpcbtcw32->lpcs->lpszName;
 544
 545         if (HIWORD(lpcbtcw32->lpcs->lpszClass))
 546         {
 547             LPSTR str = SEGPTR_ALLOC( lstrlen32W(lpcbtcw32->lpcs->lpszClass) );
 548             STRING32_UniToAnsi( str, lpcbtcw32->lpcs->lpszClass );
 549             lpcs16->lpszClass = SEGPTR_GET( str );
 550         }
 551         else
 552           lpcs16->lpszClass = (SEGPTR)lpcbtcw32->lpcs->lpszClass;
 553
 554         lpcbtcw16->hwndInsertAfter = lpcbtcw32->hwndInsertAfter;
 555
 556         *plParam = (LPARAM)SEGPTR_GET( lpcbtcw16 );
 557     }
 558     else HOOK_Map32To16Common(id, code, pwParam, plParam);
 559 }
 560
 561
 562 /***********************************************************************
 563  *           HOOK_UnMap32To16Common
 564  */
 565 static void HOOK_UnMap32To16Common(INT32 id, INT32 code, WPARAM32 wParamOrig,
 566                                    LPARAM lParamOrig, WPARAM32 wParam,
 567                                    LPARAM lParam)
 568 {
 569     switch (id)
 570     {
 571       case WH_MSGFILTER:
 572       case WH_SYSMSGFILTER:
 573       case WH_JOURNALRECORD:
 574       case WH_JOURNALPLAYBACK:
 575       case WH_MOUSE:
 576       case WH_DEBUG:
 577         SEGPTR_FREE( PTR_SEG_TO_LIN(lParam) );
 578         break;
 579
 580       case WH_GETMESSAGE:
 581       {
 582           LPMSG32 lpmsg32 = (LPMSG32)lParamOrig;
 583
 584           STRUCT32_MSG16to32( (LPMSG16)PTR_SEG_TO_LIN(lParam), lpmsg32 );
 585           SEGPTR_FREE( PTR_SEG_TO_LIN(lParam) );
 586           break;
 587       }
 588
 589       case WH_CBT:
 590         switch (code)
 591         {
 592           case HCBT_ACTIVATE:
 593           case HCBT_CLICKSKIPPED:
 594           case HCBT_MOVESIZE:
 595             SEGPTR_FREE( (LPVOID)lParam );
 596             break;
 597         }
 598         break;
 599
 600       case WH_SHELL:
 601       case WH_KEYBOARD:
 602         break;
 603
 604       case WH_CALLWNDPROC:
 605       case WH_HARDWARE:
 606         fprintf(stderr, "Can't map hook id: %d\n", id);
 607         break;
 608
 609       default:
 610         fprintf(stderr, "Unknown hook id: %d\n", id);
 611         return;
 612     }
 613 }
 614
 615
 616 /***********************************************************************
 617  *           HOOK_UnMap32ATo16
 618  */
 619 static void HOOK_UnMap32ATo16(INT32 id, INT32 code, WPARAM32 wParamOrig,
 620                               LPARAM lParamOrig, WPARAM32 wParam,
 621                               LPARAM lParam)
 622 {
 623     if (id == WH_CBT && code == HCBT_CREATEWND)
 624     {
 625         LPCBT_CREATEWND16 lpcbtcw16 = PTR_SEG_TO_LIN(lParam);
 626         LPCREATESTRUCT16 lpcs16 = PTR_SEG_TO_LIN(lpcbtcw16->lpcs);
 627
 628         if (HIWORD(lpcs16->lpszName))
 629           SEGPTR_FREE( PTR_SEG_TO_LIN(lpcs16->lpszName) );
 630
 631         if (HIWORD(lpcs16->lpszClass))
 632           SEGPTR_FREE( PTR_SEG_TO_LIN(lpcs16->lpszClass) );
 633
 634         SEGPTR_FREE( lpcs16 );
 635         SEGPTR_FREE( lpcbtcw16 );
 636     }
 637     else
 638       return HOOK_UnMap32To16Common( id, code, wParamOrig, lParamOrig, wParam,
 639                                      lParam );
 640     return;
 641 }
 642
 643
 644 /***********************************************************************
 645  *           HOOK_UnMap32WTo16
 646  */
 647 static void HOOK_UnMap32WTo16(INT32 id, INT32 code, WPARAM32 wParamOrig,
 648                               LPARAM lParamOrig, WPARAM32 wParam,
 649                               LPARAM lParam)
 650 {
 651     HOOK_UnMap32ATo16( id, code, wParamOrig, lParamOrig, wParam, lParam );
 652 }
 653
 654
 655 /***********************************************************************
 656  *           HOOK_Map32ATo32W
 657  */
 658 static void HOOK_Map32ATo32W(INT32 id, INT32 code, WPARAM32 *pwParam,
 659                              LPARAM *plParam)
 660 {
 661     if (id == WH_CBT && code == HCBT_CREATEWND)
 662     {
 663         LPCBT_CREATEWND32A lpcbtcwA = (LPCBT_CREATEWND32A)*plParam;
 664         LPCBT_CREATEWND32W lpcbtcwW = HeapAlloc( SystemHeap, 0,
 665                                                  sizeof(*lpcbtcwW) );
 666         lpcbtcwW->lpcs = HeapAlloc( SystemHeap, 0, sizeof(*lpcbtcwW->lpcs) );
 667
 668         lpcbtcwW->hwndInsertAfter = lpcbtcwA->hwndInsertAfter;
 669         *lpcbtcwW->lpcs = *(LPCREATESTRUCT32W)lpcbtcwA->lpcs;
 670
 671         if (HIWORD(lpcbtcwA->lpcs->lpszName))
 672         {
 673             lpcbtcwW->lpcs->lpszName =
 674               STRING32_DupAnsiToUni( lpcbtcwA->lpcs->lpszName );
 675         }
 676         else
 677           lpcbtcwW->lpcs->lpszName = (LPWSTR)lpcbtcwA->lpcs->lpszName;
 678
 679         if (HIWORD(lpcbtcwA->lpcs->lpszClass))
 680         {
 681             lpcbtcwW->lpcs->lpszClass =
 682               STRING32_DupAnsiToUni( lpcbtcwA->lpcs->lpszClass);
 683         }
 684         else
 685           lpcbtcwW->lpcs->lpszClass = (LPCWSTR)lpcbtcwA->lpcs->lpszClass;
 686     }
 687     return;
 688 }
 689
 690
 691 /***********************************************************************
 692  *           HOOK_UnMap32ATo32W
 693  */
 694 static void HOOK_UnMap32ATo32W(INT32 id, INT32 code, WPARAM32 wParamOrig,
 695                                LPARAM lParamOrig, WPARAM32 wParam,
 696                                LPARAM lParam)
 697 {
 698     if (id == WH_CBT && code == HCBT_CREATEWND)
 699     {
 700         LPCBT_CREATEWND32W lpcbtcwW = (LPCBT_CREATEWND32W)lParam;
 701         if (HIWORD(lpcbtcwW->lpcs->lpszName))
 702             free( (LPWSTR)lpcbtcwW->lpcs->lpszName );
 703         if (HIWORD(lpcbtcwW->lpcs->lpszClass))
 704             free( (LPWSTR)lpcbtcwW->lpcs->lpszClass );
 705         HeapFree( SystemHeap, 0, lpcbtcwW->lpcs );
 706         HeapFree( SystemHeap, 0, lpcbtcwW );
 707     }
 708     return;
 709 }
 710
 711
 712 /***********************************************************************
 713  *           HOOK_Map32WTo32A
 714  */
 715 static void HOOK_Map32WTo32A(INT32 id, INT32 code, WPARAM32 *pwParam,
 716                              LPARAM *plParam)
 717 {
 718     if (id == WH_CBT && code == HCBT_CREATEWND)
 719     {
 720         LPCBT_CREATEWND32W lpcbtcwW = (LPCBT_CREATEWND32W)*plParam;
 721         LPCBT_CREATEWND32A lpcbtcwA = HeapAlloc( SystemHeap, 0,
 722                                                  sizeof(*lpcbtcwA) );
 723         lpcbtcwA->lpcs = HeapAlloc( SystemHeap, 0, sizeof(*lpcbtcwA->lpcs) );
 724
 725         lpcbtcwA->hwndInsertAfter = lpcbtcwW->hwndInsertAfter;
 726         *lpcbtcwA->lpcs = *(LPCREATESTRUCT32A)lpcbtcwW->lpcs;
 727
 728         if (HIWORD(lpcbtcwW->lpcs->lpszName))
 729           lpcbtcwA->lpcs->lpszName =
 730             STRING32_DupUniToAnsi( lpcbtcwW->lpcs->lpszName );
 731         else
 732           lpcbtcwA->lpcs->lpszName = (LPSTR)lpcbtcwW->lpcs->lpszName;
 733
 734         if (HIWORD(lpcbtcwW->lpcs->lpszClass))
 735           lpcbtcwA->lpcs->lpszClass =
 736             STRING32_DupUniToAnsi( lpcbtcwW->lpcs->lpszClass);
 737         else
 738           lpcbtcwA->lpcs->lpszClass = (LPSTR)lpcbtcwW->lpcs->lpszClass;
 739     }
 740     return;
 741 }
 742
 743
 744 /***********************************************************************
 745  *           HOOK_UnMap32WTo32A
 746  */
 747 static void HOOK_UnMap32WTo32A(INT32 id, INT32 code, WPARAM32 wParamOrig,
 748                                LPARAM lParamOrig, WPARAM32 wParam,
 749                                LPARAM lParam)
 750 {
 751     if (id == WH_CBT && code == HCBT_CREATEWND)
 752     {
 753         LPCBT_CREATEWND32A lpcbtcwA = (LPCBT_CREATEWND32A)lParam;
 754         if (HIWORD(lpcbtcwA->lpcs->lpszName))
 755           free( (LPSTR)lpcbtcwA->lpcs->lpszName );
 756         if (HIWORD(lpcbtcwA->lpcs->lpszClass))
 757           free( (LPSTR)lpcbtcwA->lpcs->lpszClass );
 758         HeapFree( SystemHeap, 0, lpcbtcwA->lpcs );
 759         HeapFree( SystemHeap, 0, lpcbtcwA );
 760     }
 761     return;
 762 }
 763
 764
 765 /***********************************************************************
 766  *           Map Function Tables
 767  */
 768 static const HOOK_MapFunc HOOK_MapFuncs[3][3] =
 769 {
 770     { NULL,            HOOK_Map16To32A,  HOOK_Map16To32W },
 771     { HOOK_Map32ATo16, NULL,             HOOK_Map32ATo32W },
 772     { HOOK_Map32WTo16, HOOK_Map32WTo32A, NULL }
 773 };
 774
 775 static const HOOK_UnMapFunc HOOK_UnMapFuncs[3][3] =
 776 {
 777     { NULL,              HOOK_UnMap16To32A,  HOOK_UnMap16To32W },
 778     { HOOK_UnMap32ATo16, NULL,               HOOK_UnMap32ATo32W },
 779     { HOOK_UnMap32WTo16, HOOK_UnMap32WTo32A, NULL }
 780 };
 781
 782
 783 /***********************************************************************
 784  *           Internal Functions
 785  */
 786
 787 /***********************************************************************
 788  *           HOOK_GetNextHook
 789  *
 790  * Get the next hook of a given hook.
 791  */
 792 static HANDLE16 HOOK_GetNextHook( HANDLE16 hook )
 793 {
 794     HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR( hook );
 795
 796     if (!data || !hook) return 0;
 797     if (data->next) return data->next;
 798     if (!data->ownerQueue) return 0;  /* Already system hook */
 799
 800     /* Now start enumerating the system hooks */
 801     return HOOK_systemHooks[data->id - WH_MINHOOK];
 802 }
 803
 804
 805 /***********************************************************************
 806  *           HOOK_GetHook
 807  *
 808  * Get the first hook for a given type.
 809  */
 810 static HANDLE16 HOOK_GetHook( INT16 id, HQUEUE16 hQueue )
 811 {
 812     MESSAGEQUEUE *queue;
 813     HANDLE16 hook = 0;
 814
 815     if ((queue = (MESSAGEQUEUE *)GlobalLock16( hQueue )) != NULL)
 816         hook = queue->hooks[id - WH_MINHOOK];
 817     if (!hook) hook = HOOK_systemHooks[id - WH_MINHOOK];
 818     return hook;
 819 }
 820
 821
 822 /***********************************************************************
 823  *           HOOK_SetHook
 824  *
 825  * Install a given hook.
 826  */
 827 static HANDLE16 HOOK_SetHook( INT16 id, LPVOID proc, INT32 type,
 828                               HINSTANCE16 hInst, HTASK16 hTask )
 829 {
 830     HOOKDATA *data;
 831     HANDLE16 handle;
 832     HQUEUE16 hQueue = 0;
 833
 834     if ((id < WH_MINHOOK) || (id > WH_MAXHOOK)) return 0;
 835     if (!(hInst = GetExePtr( hInst ))) return 0;
 836
 837     dprintf_hook( stddeb, "Setting hook %d: %08x %04x %04x\n",
 838                   id, (UINT32)proc, hInst, hTask );
 839
 840     if (id == WH_JOURNALPLAYBACK) EnableHardwareInput(FALSE);
 841
 842     if (hTask)  /* Task-specific hook */
 843     {
 844         if ((id == WH_JOURNALRECORD) || (id == WH_JOURNALPLAYBACK) ||
 845             (id == WH_SYSMSGFILTER)) return 0;  /* System-only hooks */
 846         if (!(hQueue = GetTaskQueue( hTask ))) return 0;
 847     }
 848
 849     /* Create the hook structure */
 850
 851     if (!(handle = USER_HEAP_ALLOC( sizeof(HOOKDATA) ))) return 0;
 852     data = (HOOKDATA *) USER_HEAP_LIN_ADDR( handle );
 853     data->proc        = proc;
 854     data->id          = id;
 855     data->ownerQueue  = hQueue;
 856     data->ownerModule = hInst;
 857     data->inHookProc  = 0;
 858     data->flags       = type;
 859
 860     /* Insert it in the correct linked list */
 861
 862     if (hQueue)
 863     {
 864         MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( hQueue );
 865         data->next = queue->hooks[id - WH_MINHOOK];
 866         queue->hooks[id - WH_MINHOOK] = handle;
 867     }
 868     else
 869     {
 870         data->next = HOOK_systemHooks[id - WH_MINHOOK];
 871         HOOK_systemHooks[id - WH_MINHOOK] = handle;
 872     }
 873     dprintf_hook( stddeb, "Setting hook %d: ret=%04x [next=%04x]\n",
 874                            id, handle, data->next );
 875     return handle;
 876 }
 877
 878
 879 /***********************************************************************
 880  *           HOOK_RemoveHook
 881  *
 882  * Remove a hook from the list.
 883  */
 884 static BOOL32 HOOK_RemoveHook( HANDLE16 hook )
 885 {
 886     HOOKDATA *data;
 887     HANDLE16 *prevHook;
 888
 889     dprintf_hook( stddeb, "Removing hook %04x\n", hook );
 890
 891     if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook))) return FALSE;
 892     if (data->inHookProc)
 893     {
 894         /* Mark it for deletion later on */
 895         dprintf_hook( stddeb, "Hook still running, deletion delayed\n" );
 896         data->proc = (HOOKPROC32)0;
 897         return TRUE;
 898     }
 899
 900     if (data->id == WH_JOURNALPLAYBACK) EnableHardwareInput(TRUE);
 901
 902     /* Remove it from the linked list */
 903
 904     if (data->ownerQueue)
 905     {
 906         MESSAGEQUEUE *queue = (MESSAGEQUEUE *)GlobalLock16( data->ownerQueue );
 907         if (!queue) return FALSE;
 908         prevHook = &queue->hooks[data->id - WH_MINHOOK];
 909     }
 910     else prevHook = &HOOK_systemHooks[data->id - WH_MINHOOK];
 911
 912     while (*prevHook && *prevHook != hook)
 913         prevHook = &((HOOKDATA *)USER_HEAP_LIN_ADDR(*prevHook))->next;
 914
 915     if (!*prevHook) return FALSE;
 916     *prevHook = data->next;
 917     USER_HEAP_FREE( hook );
 918     return TRUE;
 919 }
 920
 921
 922 /***********************************************************************
 923  *           HOOK_FindValidHook
 924  */
 925 static HANDLE16 HOOK_FindValidHook( HANDLE16 hook )
 926 {
 927     HOOKDATA *data;
 928
 929     for (;;)
 930     {
 931         if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook))) return 0;
 932         if (data->proc) return hook;
 933         hook = data->next;
 934     }
 935 }
 936
 937
 938 /***********************************************************************
 939  *           HOOK_CallHook
 940  *
 941  * Call a hook procedure.
 942  */
 943 static LRESULT HOOK_CallHook( HANDLE16 hook, INT32 fromtype, INT32 code,
 944                               WPARAM32 wParam, LPARAM lParam )
 945 {
 946     MESSAGEQUEUE *queue;
 947     HANDLE16 prevHook;
 948     HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
 949     LRESULT ret;
 950
 951     WPARAM32 wParamOrig = wParam;
 952     LPARAM lParamOrig = lParam;
 953     HOOK_MapFunc MapFunc;
 954     HOOK_UnMapFunc UnMapFunc;
 955
 956     MapFunc = HOOK_MapFuncs[fromtype][data->flags & HOOK_MAPTYPE];
 957     UnMapFunc = HOOK_UnMapFuncs[fromtype][data->flags & HOOK_MAPTYPE];
 958
 959     if (MapFunc)
 960       MapFunc( data->id, code, &wParam, &lParam );
 961
 962     /* Now call it */
 963
 964     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
 965     prevHook = queue->hCurHook;
 966     queue->hCurHook = hook;
 967     data->inHookProc = TRUE;
 968
 969     dprintf_hook( stddeb, "Calling hook %04x: %d %08x %08lx\n",
 970                   hook, code, wParam, lParam );
 971
 972     ret = data->proc(code, wParam, lParam);
 973
 974     dprintf_hook( stddeb, "Ret hook %04x = %08lx\n", hook, ret );
 975
 976     data->inHookProc = FALSE;
 977     queue->hCurHook = prevHook;
 978
 979     if (UnMapFunc)
 980       UnMapFunc( data->id, code, wParamOrig, lParamOrig, wParam, lParam );
 981
 982     if (!data->proc) HOOK_RemoveHook( hook );
 983
 984     return ret;
 985 }
 986
 987 /***********************************************************************
 988  *           Exported Functions & APIs
 989  */
 990
 991 /***********************************************************************
 992  *           HOOK_GetProc16
 993  *
 994  * Don't call this unless you are the if1632/thunk.c.
 995  */
 996 HOOKPROC16 HOOK_GetProc16( HHOOK hhook )
 997 {
 998     HOOKDATA *data;
 999     if (HIWORD(hhook) != HOOK_MAGIC) return NULL;
1000     if (!(data = (HOOKDATA *)USER_HEAP_LIN_ADDR( LOWORD(hhook) ))) return NULL;
1001     if (data->flags & HOOK_WIN32) return NULL;
1002     return (HOOKPROC16)data->proc;
1003 }
1004
1005
1006 /***********************************************************************
1007  *           HOOK_IsHooked
1008  *
1009  * Replacement for calling HOOK_GetHook from other modules.
1010  */
1011 BOOL32 HOOK_IsHooked( INT16 id )
1012 {
1013     return HOOK_GetHook( id, GetTaskQueue(0) ) != 0;
1014 }
1015
1016
1017 /***********************************************************************
1018  *           HOOK_CallHooks16
1019  *
1020  * Call a hook chain.
1021  */
1022 LRESULT HOOK_CallHooks16( INT16 id, INT16 code, WPARAM16 wParam,
1023                           LPARAM lParam )
1024 {
1025     HANDLE16 hook;
1026
1027     if (!(hook = HOOK_GetHook( id , GetTaskQueue(0) ))) return 0;
1028     if (!(hook = HOOK_FindValidHook(hook))) return 0;
1029     return HOOK_CallHook( hook, HOOK_WIN16, code, wParam, lParam );
1030 }
1031
1032 /***********************************************************************
1033  *           HOOK_CallHooks32A
1034  *
1035  * Call a hook chain.
1036  */
1037 LRESULT HOOK_CallHooks32A( INT32 id, INT32 code, WPARAM32 wParam,
1038                            LPARAM lParam )
1039 {
1040     HANDLE16 hook;
1041
1042     if (!(hook = HOOK_GetHook( id , GetTaskQueue(0) ))) return 0;
1043     if (!(hook = HOOK_FindValidHook(hook))) return 0;
1044     return HOOK_CallHook( hook, HOOK_WIN32, code, wParam, lParam );
1045 }
1046
1047 /***********************************************************************
1048  *           HOOK_CallHooks32W
1049  *
1050  * Call a hook chain.
1051  */
1052 LRESULT HOOK_CallHooks32W( INT32 id, INT32 code, WPARAM32 wParam,
1053                            LPARAM lParam )
1054 {
1055     HANDLE16 hook;
1056
1057     if (!(hook = HOOK_GetHook( id , GetTaskQueue(0) ))) return 0;
1058     if (!(hook = HOOK_FindValidHook(hook))) return 0;
1059     return HOOK_CallHook( hook, HOOK_WIN32 | HOOK_UNICODE, code, wParam,
1060                           lParam );
1061 }
1062
1063
1064 /***********************************************************************
1065  *           HOOK_ResetQueueHooks
1066  */
1067 void HOOK_ResetQueueHooks( HQUEUE16 hQueue )
1068 {
1069     MESSAGEQUEUE *queue;
1070
1071     if ((queue = (MESSAGEQUEUE *)GlobalLock16( hQueue )) != NULL)
1072     {
1073         HOOKDATA*       data;
1074         HHOOK           hook;
1075         int             id;
1076         for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
1077         {
1078             hook = queue->hooks[id - WH_MINHOOK];
1079             while( hook )
1080             {
1081                 if( (data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook)) )
1082                 {
1083                   data->ownerQueue = hQueue;
1084                   hook = data->next;
1085                 } else break;
1086             }
1087         }
1088     }
1089 }
1090
1091 /***********************************************************************
1092  *           HOOK_FreeModuleHooks
1093  */
1094 void HOOK_FreeModuleHooks( HMODULE16 hModule )
1095 {
1096  /* remove all system hooks registered by this module */
1097
1098   HOOKDATA*     hptr;
1099   HHOOK         hook, next;
1100   int           id;
1101
1102   for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
1103     {
1104        hook = HOOK_systemHooks[id - WH_MINHOOK];
1105        while( hook )
1106           if( (hptr = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook)) )
1107             {
1108               next = hptr->next;
1109               if( hptr->ownerModule == hModule )
1110                 {
1111                   hptr->inHookProc = 0;
1112                   HOOK_RemoveHook(hook);
1113                 }
1114               hook = next;
1115             }
1116           else hook = 0;
1117     }
1118 }
1119
1120 /***********************************************************************
1121  *           HOOK_FreeQueueHooks
1122  */
1123 void HOOK_FreeQueueHooks( HQUEUE16 hQueue )
1124 {
1125   /* remove all hooks registered by this queue */
1126
1127   HOOKDATA*     hptr = NULL;
1128   HHOOK         hook, next;
1129   int           id;
1130
1131   for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
1132     {
1133        hook = HOOK_GetHook( id, hQueue );
1134        while( hook )
1135         {
1136           next = HOOK_GetNextHook(hook);
1137
1138           hptr = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
1139           if( hptr && hptr->ownerQueue == hQueue )
1140             {
1141               hptr->inHookProc = 0;
1142               HOOK_RemoveHook(hook);
1143             }
1144           hook = next;
1145         }
1146     }
1147 }
1148
1149
1150 /***********************************************************************
1151  *           SetWindowsHook16   (USER.121)
1152  */
1153 FARPROC16 SetWindowsHook16( INT16 id, HOOKPROC16 proc )
1154 {
1155     HANDLE16 handle;
1156     HINSTANCE16 hInst = __winelib ? 0 : FarGetOwner( HIWORD(proc) );
1157
1158     /* WH_MSGFILTER is the only task-specific hook for SetWindowsHook() */
1159     HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
1160
1161     if (id == WH_DEBUG)
1162     {
1163         fprintf( stdnimp, "WH_DEBUG is broken in 16-bit Windows.\n");
1164         return 0;
1165     }
1166
1167     handle = HOOK_SetHook( id, proc, HOOK_WIN16, hInst, hTask );
1168     return (handle) ? (FARPROC16)MAKELONG( handle, HOOK_MAGIC ) : NULL;
1169 }
1170
1171
1172 /***********************************************************************
1173  *           SetWindowsHook32A   (USER32.524)
1174  *
1175  * FIXME: I don't know if this is correct
1176  */
1177 HHOOK SetWindowsHook32A( INT32 id, HOOKPROC32 proc )
1178 {
1179     HINSTANCE16 hInst = __winelib ? 0 : FarGetOwner( HIWORD(proc) );
1180
1181     /* WH_MSGFILTER is the only task-specific hook for SetWindowsHook() */
1182     HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
1183
1184     HANDLE16 handle = HOOK_SetHook( id, proc, HOOK_WIN32, hInst, hTask );
1185     return (handle) ? (HHOOK)MAKELONG( handle, HOOK_MAGIC ) : 0;
1186 }
1187
1188
1189 /***********************************************************************
1190  *           SetWindowsHook32W   (USER32.527)
1191  *
1192  * FIXME: I don't know if this is correct
1193  */
1194 HHOOK SetWindowsHook32W( INT32 id, HOOKPROC32 proc )
1195 {
1196     HINSTANCE16 hInst = __winelib ? 0 : FarGetOwner( HIWORD(proc) );
1197
1198     /* WH_MSGFILTER is the only task-specific hook for SetWindowsHook() */
1199     HTASK16 hTask = (id == WH_MSGFILTER) ? GetCurrentTask() : 0;
1200
1201     HANDLE16 handle = HOOK_SetHook( id, proc, HOOK_WIN32 | HOOK_UNICODE,
1202                                     hInst, hTask );
1203     return (handle) ? (HHOOK)MAKELONG( handle, HOOK_MAGIC ) : 0;
1204 }
1205
1206
1207 /***********************************************************************
1208  *           SetWindowsHookEx16   (USER.291)
1209  */
1210 HHOOK SetWindowsHookEx16( INT16 id, HOOKPROC16 proc, HINSTANCE16 hInst,
1211                           HTASK16 hTask )
1212 {
1213     HANDLE16 handle = HOOK_SetHook( id, proc, HOOK_WIN16, hInst, hTask );
1214     return (handle) ? (HHOOK)MAKELONG( handle, HOOK_MAGIC ) : (HHOOK)NULL;
1215 }
1216
1217
1218 /***********************************************************************
1219  *           SetWindowsHookEx32A   (USER32.525)
1220  */
1221 HHOOK SetWindowsHookEx32A( INT32 id, HOOKPROC32 proc, HINSTANCE32 hInst,
1222                            DWORD dwThreadID )
1223 {
1224     HANDLE16 handle;
1225     HTASK16 hTask;
1226
1227     if (dwThreadID == GetCurrentThreadId())
1228       hTask = GetCurrentTask();
1229     else
1230       hTask = LOWORD(dwThreadID);
1231
1232     handle = HOOK_SetHook( id, proc, HOOK_WIN32, hInst, hTask );
1233     return (handle) ? (HHOOK)MAKELONG( handle, HOOK_MAGIC ) : (HHOOK)NULL;
1234 }
1235
1236
1237 /***********************************************************************
1238  *           SetWindowsHookEx32W   (USER32.526)
1239  */
1240 HHOOK SetWindowsHookEx32W( INT32 id, HOOKPROC32 proc, HINSTANCE32 hInst,
1241                            DWORD dwThreadID )
1242 {
1243     HANDLE16 handle;
1244     HTASK16 hTask;
1245
1246     if (dwThreadID == GetCurrentThreadId())
1247       hTask = GetCurrentTask();
1248     else
1249       hTask = LOWORD(dwThreadID);
1250
1251     handle = HOOK_SetHook( id, proc, HOOK_WIN32 | HOOK_UNICODE, hInst, hTask );
1252     return (handle) ? (HHOOK)MAKELONG( handle, HOOK_MAGIC ) : (HHOOK)NULL;
1253 }
1254
1255
1256 /***********************************************************************
1257  *           UnhookWindowsHook16   (USER.234)
1258  */
1259 BOOL16 UnhookWindowsHook16( INT16 id, HOOKPROC16 proc )
1260 {
1261     HANDLE16 hook = HOOK_GetHook( id , GetTaskQueue(0) );
1262
1263     dprintf_hook( stddeb, "UnhookWindowsHook: %d %08lx\n", id, (DWORD)proc );
1264
1265     while (hook)
1266     {
1267         HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
1268         if (data->proc == (HOOKPROC32)proc) break;
1269         hook = HOOK_GetNextHook( hook );
1270     }
1271     if (!hook) return FALSE;
1272     return HOOK_RemoveHook( hook );
1273 }
1274
1275
1276 /***********************************************************************
1277  *           UnhookWindowsHook32   (USER32.556)
1278  */
1279 BOOL32 UnhookWindowsHook32( INT32 id, HOOKPROC32 proc )
1280 {
1281     HANDLE16 hook = HOOK_GetHook( id , GetTaskQueue(0) );
1282
1283     dprintf_hook( stddeb, "UnhookWindowsHook: %d %08lx\n", id, (DWORD)proc );
1284
1285     while (hook)
1286     {
1287         HOOKDATA *data = (HOOKDATA *)USER_HEAP_LIN_ADDR(hook);
1288         if (data->proc == proc) break;
1289         hook = HOOK_GetNextHook( hook );
1290     }
1291     if (!hook) return FALSE;
1292     return HOOK_RemoveHook( hook );
1293 }
1294
1295
1296 /***********************************************************************
1297  *           UnhookWindowHookEx16   (USER.292)
1298  */
1299 BOOL16 UnhookWindowsHookEx16( HHOOK hhook )
1300 {
1301     if (HIWORD(hhook) != HOOK_MAGIC) return FALSE;  /* Not a new format hook */
1302     return HOOK_RemoveHook( LOWORD(hhook) );
1303 }
1304
1305
1306 /***********************************************************************
1307  *           UnhookWindowHookEx32   (USER32.557)
1308  */
1309 BOOL32 UnhookWindowsHookEx32( HHOOK hhook )
1310 {
1311     return UnhookWindowsHookEx16( hhook );
1312 }
1313
1314
1315 /***********************************************************************
1316  *           CallNextHookEx16     (USER.293)
1317  *
1318  * I wouldn't have separated this into 16 and 32 bit versions, but I
1319  * need a way to figure out if I need to do a mapping or not.
1320  */
1321 LRESULT CallNextHookEx16( HHOOK hhook, INT16 code, WPARAM16 wParam,
1322                           LPARAM lParam )
1323 {
1324     HANDLE16 next;
1325
1326     if (HIWORD(hhook) != HOOK_MAGIC) return 0;  /* Not a new format hook */
1327     if (!(next = HOOK_GetNextHook( LOWORD(hhook) ))) return 0;
1328
1329     return HOOK_CallHook( next, HOOK_WIN16, code, wParam, lParam );
1330 }
1331
1332
1333 /***********************************************************************
1334  *           CallNextHookEx32    (USER32.16)
1335  *
1336  * There aren't ANSI and UNICODE versions of this.
1337  */
1338 LRESULT CallNextHookEx32( HHOOK hhook, INT32 code, WPARAM32 wParam,
1339                           LPARAM lParam )
1340 {
1341     HANDLE16 next;
1342     INT32 fromtype;     /* figure out Ansi/Unicode */
1343     HOOKDATA *oldhook;
1344
1345     if (HIWORD(hhook) != HOOK_MAGIC) return 0;  /* Not a new format hook */
1346     if (!(next = HOOK_GetNextHook( LOWORD(hhook) ))) return 0;
1347
1348     oldhook = (HOOKDATA *)USER_HEAP_LIN_ADDR( LOWORD(hhook) );
1349     fromtype = oldhook->flags & HOOK_MAPTYPE;
1350
1351     if (!(fromtype & HOOK_WIN32))
1352       fprintf(stderr, "CallNextHookEx32: called from 16bit hook!\n");
1353
1354     return HOOK_CallHook( next, fromtype, code, wParam, lParam );
1355 }
1356
1357
1358 /***********************************************************************
1359  *           DefHookProc16   (USER.235)
1360  */
1361 LRESULT DefHookProc16( INT16 code, WPARAM16 wParam, LPARAM lParam,
1362                        HHOOK *hhook )
1363 {
1364     /* Note: the *hhook parameter is never used, since we rely on the
1365      * current hook value from the task queue to find the next hook. */
1366     MESSAGEQUEUE *queue;
1367
1368     if (!(queue = (MESSAGEQUEUE *)GlobalLock16( GetTaskQueue(0) ))) return 0;
1369     return CallNextHookEx16( queue->hCurHook, code, wParam, lParam );
1370 }
1371
1372
1373 /***********************************************************************
1374  *           CallMsgFilter16   (USER.123)
1375  */
1376 BOOL16 CallMsgFilter16( SEGPTR msg, INT16 code )
1377 {
1378     if (GetSysModalWindow16()) return FALSE;
1379     if (HOOK_CallHooks16( WH_SYSMSGFILTER, code, 0, (LPARAM)msg )) return TRUE;
1380     return HOOK_CallHooks16( WH_MSGFILTER, code, 0, (LPARAM)msg );
1381 }
1382
1383
1384 /***********************************************************************
1385  *           CallMsgFilter32A   (USER32.14)
1386  */
1387 /*
1388  * FIXME: There are ANSI and UNICODE versions of this, plus an unspecified
1389  * version, plus USER (the 16bit one) has a CallMsgFilter32 function.
1390  */
1391 BOOL32 CallMsgFilter32A( LPMSG32 msg, INT32 code )
1392 {
1393     if (GetSysModalWindow16()) return FALSE;    /* ??? */
1394     if (HOOK_CallHooks32A( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
1395       return TRUE;
1396     return HOOK_CallHooks32A( WH_MSGFILTER, code, 0, (LPARAM)msg );
1397 }
1398
1399
1400 /***********************************************************************
1401  *           CallMsgFilter32W   (USER32.15)
1402  */
1403 BOOL32 CallMsgFilter32W( LPMSG32 msg, INT32 code )
1404 {
1405     if (GetSysModalWindow16()) return FALSE;    /* ??? */
1406     if (HOOK_CallHooks32W( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
1407       return TRUE;
1408     return HOOK_CallHooks32W( WH_MSGFILTER, code, 0, (LPARAM)msg );
1409 }