dlls/user/hook.c

   1 /*
   2  * Windows hook functions
   3  *
   4  * Copyright 2002 Alexandre Julliard
   5  * Copyright 2005 Dmitry Timoshkov
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  *
  21  * NOTES:
  22  *   Status of the various hooks:
  23  *     WH_MSGFILTER                 OK
  24  *     WH_JOURNALRECORD             Partially implemented
  25  *     WH_JOURNALPLAYBACK           Partially implemented
  26  *     WH_KEYBOARD                  OK
  27  *     WH_GETMESSAGE                OK (FIXME: A/W mapping?)
  28  *     WH_CALLWNDPROC               OK (FIXME: A/W mapping?)
  29  *     WH_CBT
  30  *       HCBT_MOVESIZE              OK
  31  *       HCBT_MINMAX                OK
  32  *       HCBT_QS                    OK
  33  *       HCBT_CREATEWND             OK
  34  *       HCBT_DESTROYWND            OK
  35  *       HCBT_ACTIVATE              OK
  36  *       HCBT_CLICKSKIPPED          OK
  37  *       HCBT_KEYSKIPPED            OK
  38  *       HCBT_SYSCOMMAND            OK
  39  *       HCBT_SETFOCUS              OK
  40  *     WH_SYSMSGFILTER              OK
  41  *     WH_MOUSE                     OK
  42  *     WH_HARDWARE                  Not supported in Win32
  43  *     WH_DEBUG                     Not implemented
  44  *     WH_SHELL
  45  *       HSHELL_WINDOWCREATED       OK
  46  *       HSHELL_WINDOWDESTROYED     OK
  47  *       HSHELL_ACTIVATESHELLWINDOW Not implemented
  48  *       HSHELL_WINDOWACTIVATED     Not implemented
  49  *       HSHELL_GETMINRECT          Not implemented
  50  *       HSHELL_REDRAW              Not implemented
  51  *       HSHELL_TASKMAN             Not implemented
  52  *       HSHELL_LANGUAGE            Not implemented
  53  *       HSHELL_SYSMENU             Not implemented
  54  *       HSHELL_ENDTASK             Not implemented
  55  *       HSHELL_ACCESSIBILITYSTATE  Not implemented
  56  *       HSHELL_APPCOMMAND          Not implemented
  57  *       HSHELL_WINDOWREPLACED      Not implemented
  58  *       HSHELL_WINDOWREPLACING     Not implemented
  59  *     WH_FOREGROUNDIDLE            Not implemented
  60  *     WH_CALLWNDPROCRET            OK (FIXME: A/W mapping?)
  61  *     WH_KEYBOARD_LL               Implemented but should use SendMessage instead
  62  *     WH_MOUSE_LL                  Implemented but should use SendMessage instead
  63  */
  64
  65 #include "config.h"
  66 #include "wine/port.h"
  67
  68 #include <stdarg.h>
  69 #include <assert.h>
  70
  71 #include "windef.h"
  72 #include "winbase.h"
  73 #include "winuser.h"
  74 #include "winerror.h"
  75 #include "win.h"
  76 #include "user_private.h"
  77 #include "wine/server.h"
  78 #include "wine/unicode.h"
  79 #include "wine/debug.h"
  80 #include "winternl.h"
  81
  82 WINE_DEFAULT_DEBUG_CHANNEL(hook);
  83 WINE_DECLARE_DEBUG_CHANNEL(relay);
  84
  85 struct hook_info
  86 {
  87     FARPROC proc;
  88     void *handle;
  89     DWORD tid;
  90     WCHAR module[MAX_PATH];
  91 };
  92
  93 #define WH_WINEVENT (WH_MAXHOOK+1)
  94
  95 static const char * const hook_names[WH_WINEVENT - WH_MINHOOK + 1] =
  96 {
  97     "WH_MSGFILTER",
  98     "WH_JOURNALRECORD",
  99     "WH_JOURNALPLAYBACK",
 100     "WH_KEYBOARD",
 101     "WH_GETMESSAGE",
 102     "WH_CALLWNDPROC",
 103     "WH_CBT",
 104     "WH_SYSMSGFILTER",
 105     "WH_MOUSE",
 106     "WH_HARDWARE",
 107     "WH_DEBUG",
 108     "WH_SHELL",
 109     "WH_FOREGROUNDIDLE",
 110     "WH_CALLWNDPROCRET",
 111     "WH_KEYBOARD_LL",
 112     "WH_MOUSE_LL",
 113     "WH_WINEVENT"
 114 };
 115
 116
 117 /***********************************************************************
 118  *              get_ll_hook_timeout
 119  *
 120  */
 121 static UINT get_ll_hook_timeout(void)
 122 {
 123     /* FIXME: should retrieve LowLevelHooksTimeout in HKEY_CURRENT_USER\Control Panel\Desktop */
 124     return 2000;
 125 }
 126
 127
 128 /***********************************************************************
 129  *              set_windows_hook
 130  *
 131  * Implementation of SetWindowsHookExA and SetWindowsHookExW.
 132  */
 133 static HHOOK set_windows_hook( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid, BOOL unicode )
 134 {
 135     HHOOK handle = 0;
 136     WCHAR module[MAX_PATH];
 137     DWORD len;
 138
 139     if (!proc)
 140     {
 141         SetLastError( ERROR_INVALID_FILTER_PROC );
 142         return 0;
 143     }
 144
 145     if (!proc)
 146     {
 147         SetLastError( ERROR_INVALID_FILTER_PROC );
 148         return 0;
 149     }
 150
 151     /* FIXME: what if the tid belongs to another process? */
 152     if (tid)  /* thread-local hook */
 153     {
 154         if (id == WH_JOURNALRECORD ||
 155             id == WH_JOURNALPLAYBACK ||
 156             id == WH_KEYBOARD_LL ||
 157             id == WH_MOUSE_LL ||
 158             id == WH_SYSMSGFILTER)
 159         {
 160             /* these can only be global */
 161             SetLastError( ERROR_INVALID_PARAMETER );
 162             return 0;
 163         }
 164         inst = 0;
 165     }
 166     else  /* system-global hook */
 167     {
 168         if (id == WH_KEYBOARD_LL || id == WH_MOUSE_LL) inst = 0;
 169         else if (!inst || !(len = GetModuleFileNameW( inst, module, MAX_PATH )) || len >= MAX_PATH)
 170         {
 171             SetLastError( ERROR_HOOK_NEEDS_HMOD );
 172             return 0;
 173         }
 174     }
 175
 176     SERVER_START_REQ( set_hook )
 177     {
 178         req->id        = id;
 179         req->pid       = 0;
 180         req->tid       = tid;
 181         req->event_min = EVENT_MIN;
 182         req->event_max = EVENT_MAX;
 183         req->flags     = WINEVENT_INCONTEXT;
 184         req->unicode   = unicode;
 185         if (inst) /* make proc relative to the module base */
 186         {
 187             req->proc = (void *)((char *)proc - (char *)inst);
 188             wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
 189         }
 190         else req->proc = proc;
 191
 192         if (!wine_server_call_err( req ))
 193         {
 194             handle = reply->handle;
 195             get_user_thread_info()->active_hooks = reply->active_hooks;
 196         }
 197     }
 198     SERVER_END_REQ;
 199
 200     TRACE( "%s %p %lx -> %p\n", hook_names[id-WH_MINHOOK], proc, tid, handle );
 201     return handle;
 202 }
 203
 204
 205 /***********************************************************************
 206  *              call_hook_AtoW
 207  */
 208 static LRESULT call_hook_AtoW( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
 209 {
 210     LRESULT ret;
 211     UNICODE_STRING usBuffer;
 212     if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
 213     else
 214     {
 215         CBT_CREATEWNDA *cbtcwA = (CBT_CREATEWNDA *)lparam;
 216         CBT_CREATEWNDW cbtcwW;
 217         CREATESTRUCTW csW;
 218
 219         cbtcwW.lpcs = &csW;
 220         cbtcwW.hwndInsertAfter = cbtcwA->hwndInsertAfter;
 221         csW = *(CREATESTRUCTW *)cbtcwA->lpcs;
 222
 223         if (HIWORD(cbtcwA->lpcs->lpszName))
 224         {
 225             RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszName);
 226             csW.lpszName = usBuffer.Buffer;
 227         }
 228         if (HIWORD(cbtcwA->lpcs->lpszClass))
 229         {
 230             RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszClass);
 231             csW.lpszClass = usBuffer.Buffer;
 232         }
 233         ret = proc( code, wparam, (LPARAM)&cbtcwW );
 234         cbtcwA->hwndInsertAfter = cbtcwW.hwndInsertAfter;
 235         if (HIWORD(csW.lpszName)) HeapFree( GetProcessHeap(), 0, (LPWSTR)csW.lpszName );
 236         if (HIWORD(csW.lpszClass)) HeapFree( GetProcessHeap(), 0, (LPWSTR)csW.lpszClass );
 237     }
 238     return ret;
 239 }
 240
 241
 242 /***********************************************************************
 243  *              call_hook_WtoA
 244  */
 245 static LRESULT call_hook_WtoA( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
 246 {
 247     LRESULT ret;
 248
 249     if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
 250     else
 251     {
 252         CBT_CREATEWNDW *cbtcwW = (CBT_CREATEWNDW *)lparam;
 253         CBT_CREATEWNDA cbtcwA;
 254         CREATESTRUCTA csA;
 255         int len;
 256
 257         cbtcwA.lpcs = &csA;
 258         cbtcwA.hwndInsertAfter = cbtcwW->hwndInsertAfter;
 259         csA = *(CREATESTRUCTA *)cbtcwW->lpcs;
 260
 261         if (HIWORD(cbtcwW->lpcs->lpszName)) {
 262             len = WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszName, -1, NULL, 0, NULL, NULL );
 263             csA.lpszName = HeapAlloc( GetProcessHeap(), 0, len*sizeof(CHAR) );
 264             WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszName, -1, (LPSTR)csA.lpszName, len, NULL, NULL );
 265         }
 266
 267         if (HIWORD(cbtcwW->lpcs->lpszClass)) {
 268             len = WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszClass, -1, NULL, 0, NULL, NULL );
 269             csA.lpszClass = HeapAlloc( GetProcessHeap(), 0, len*sizeof(CHAR) );
 270             WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszClass, -1, (LPSTR)csA.lpszClass, len, NULL, NULL );
 271         }
 272
 273         ret = proc( code, wparam, (LPARAM)&cbtcwA );
 274         cbtcwW->hwndInsertAfter = cbtcwA.hwndInsertAfter;
 275         if (HIWORD(csA.lpszName)) HeapFree( GetProcessHeap(), 0, (LPSTR)csA.lpszName );
 276         if (HIWORD(csA.lpszClass)) HeapFree( GetProcessHeap(), 0, (LPSTR)csA.lpszClass );
 277     }
 278     return ret;
 279 }
 280
 281
 282 /***********************************************************************
 283  *              call_hook
 284  */
 285 static LRESULT call_hook( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
 286                           BOOL prev_unicode, BOOL next_unicode )
 287 {
 288     LRESULT ret;
 289
 290     if (TRACE_ON(relay))
 291         DPRINTF( "%04lx:Call hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx)\n",
 292                  GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam );
 293
 294     if (!prev_unicode == !next_unicode) ret = proc( code, wparam, lparam );
 295     else if (prev_unicode) ret = call_hook_WtoA( proc, id, code, wparam, lparam );
 296     else ret = call_hook_AtoW( proc, id, code, wparam, lparam );
 297
 298     if (TRACE_ON(relay))
 299         DPRINTF( "%04lx:Ret  hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx) retval=%08lx\n",
 300                  GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, ret );
 301
 302     return ret;
 303 }
 304
 305
 306 /***********************************************************************
 307  *              get_hook_proc
 308  *
 309  * Retrieve the hook procedure real value for a module-relative proc
 310  */
 311 static void *get_hook_proc( void *proc, const WCHAR *module )
 312 {
 313     HMODULE mod;
 314
 315     if (!(mod = GetModuleHandleW(module)))
 316     {
 317         TRACE( "loading %s\n", debugstr_w(module) );
 318         /* FIXME: the library will never be freed */
 319         if (!(mod = LoadLibraryW(module))) return NULL;
 320     }
 321     return (char *)mod + (ULONG_PTR)proc;
 322 }
 323
 324
 325 /***********************************************************************
 326  *              HOOK_CallHooks
 327  */
 328 LRESULT HOOK_CallHooks( INT id, INT code, WPARAM wparam, LPARAM lparam, BOOL unicode )
 329 {
 330     struct user_thread_info *thread_info = get_user_thread_info();
 331     HOOKPROC proc = NULL;
 332     HHOOK handle = 0;
 333     DWORD pid = 0, tid = 0;
 334     WCHAR module[MAX_PATH];
 335     BOOL unicode_hook = FALSE;
 336     DWORD_PTR ret = 0;
 337
 338     USER_CheckNotLock();
 339
 340     if (!HOOK_IsHooked( id ))
 341     {
 342         TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
 343         return 0;
 344     }
 345
 346     SERVER_START_REQ( start_hook_chain )
 347     {
 348         req->id = id;
 349         req->event = EVENT_MIN;
 350         wine_server_set_reply( req, module, sizeof(module)-sizeof(WCHAR) );
 351         if (!wine_server_call( req ))
 352         {
 353             module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
 354             handle       = reply->handle;
 355             proc         = reply->proc;
 356             pid          = reply->pid;
 357             tid          = reply->tid;
 358             unicode_hook = reply->unicode;
 359             thread_info->active_hooks = reply->active_hooks;
 360         }
 361     }
 362     SERVER_END_REQ;
 363
 364     if (tid)
 365     {
 366         TRACE( "calling hook in thread %04lx %s code %x wp %x lp %lx\n",
 367                tid, hook_names[id-WH_MINHOOK], code, wparam, lparam );
 368
 369         switch(id)
 370         {
 371         case WH_KEYBOARD_LL:
 372             MSG_SendInternalMessageTimeout( pid, tid, WM_WINE_KEYBOARD_LL_HOOK, wparam, lparam,
 373                                             SMTO_ABORTIFHUNG, get_ll_hook_timeout(), &ret );
 374             break;
 375         case WH_MOUSE_LL:
 376             MSG_SendInternalMessageTimeout( pid, tid, WM_WINE_MOUSE_LL_HOOK, wparam, lparam,
 377                                             SMTO_ABORTIFHUNG, get_ll_hook_timeout(), &ret );
 378             break;
 379         default:
 380             ERR("Unknown hook id %d\n", id);
 381             assert(0);
 382             break;
 383         }
 384     }
 385     else if (proc)
 386     {
 387         TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
 388                proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, debugstr_w(module) );
 389
 390         if (!module[0] || (proc = get_hook_proc( proc, module )) != NULL)
 391         {
 392             HHOOK prev = thread_info->hook;
 393             thread_info->hook = handle;
 394             ret = call_hook( proc, id, code, wparam, lparam, unicode, unicode_hook );
 395             thread_info->hook = prev;
 396         }
 397
 398     }
 399     else return 0;
 400
 401     SERVER_START_REQ( finish_hook_chain )
 402     {
 403         req->id = id;
 404         wine_server_call( req );
 405     }
 406     SERVER_END_REQ;
 407     return ret;
 408 }
 409
 410
 411 /***********************************************************************
 412  *           HOOK_IsHooked
 413  */
 414 BOOL HOOK_IsHooked( INT id )
 415 {
 416     struct user_thread_info *thread_info = get_user_thread_info();
 417
 418     if (!thread_info->active_hooks) return TRUE;
 419     return (thread_info->active_hooks & (1 << (id - WH_MINHOOK))) != 0;
 420 }
 421
 422
 423 /***********************************************************************
 424  *              SetWindowsHookA (USER32.@)
 425  */
 426 HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
 427 {
 428     return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
 429 }
 430
 431
 432 /***********************************************************************
 433  *              SetWindowsHookW (USER32.@)
 434  */
 435 HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
 436 {
 437     return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
 438 }
 439
 440
 441 /***********************************************************************
 442  *              SetWindowsHookExA (USER32.@)
 443  */
 444 HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
 445 {
 446     return set_windows_hook( id, proc, inst, tid, FALSE );
 447 }
 448
 449 /***********************************************************************
 450  *              SetWindowsHookExW (USER32.@)
 451  */
 452 HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
 453 {
 454     return set_windows_hook( id, proc, inst, tid, TRUE );
 455 }
 456
 457
 458 /***********************************************************************
 459  *              UnhookWindowsHook (USER32.@)
 460  */
 461 BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
 462 {
 463     BOOL ret;
 464
 465     TRACE( "%s %p\n", hook_names[id-WH_MINHOOK], proc );
 466
 467     SERVER_START_REQ( remove_hook )
 468     {
 469         req->handle = 0;
 470         req->id   = id;
 471         req->proc = proc;
 472         ret = !wine_server_call_err( req );
 473         if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
 474     }
 475     SERVER_END_REQ;
 476     if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
 477     return ret;
 478 }
 479
 480
 481
 482 /***********************************************************************
 483  *              UnhookWindowsHookEx (USER32.@)
 484  */
 485 BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
 486 {
 487     BOOL ret;
 488
 489     TRACE( "%p\n", hhook );
 490
 491     SERVER_START_REQ( remove_hook )
 492     {
 493         req->handle = hhook;
 494         req->id     = 0;
 495         ret = !wine_server_call_err( req );
 496         if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
 497     }
 498     SERVER_END_REQ;
 499     if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
 500     return ret;
 501 }
 502
 503
 504 /***********************************************************************
 505  *              CallNextHookEx (USER32.@)
 506  */
 507 LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
 508 {
 509     struct user_thread_info *thread_info = get_user_thread_info();
 510     HOOKPROC proc = NULL;
 511     WCHAR module[MAX_PATH];
 512     HHOOK handle = 0;
 513     DWORD pid = 0, tid = 0;
 514     INT id = 0;
 515     BOOL prev_unicode = FALSE, next_unicode = FALSE;
 516     DWORD_PTR ret = 0;
 517
 518     SERVER_START_REQ( get_next_hook )
 519     {
 520         req->handle = thread_info->hook;
 521         req->event = EVENT_MIN;
 522         wine_server_set_reply( req, module, sizeof(module)-sizeof(WCHAR) );
 523         if (!wine_server_call_err( req ))
 524         {
 525             module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
 526             handle       = reply->next;
 527             id           = reply->id;
 528             pid          = reply->pid;
 529             tid          = reply->tid;
 530             proc         = reply->proc;
 531             prev_unicode = reply->prev_unicode;
 532             next_unicode = reply->next_unicode;
 533         }
 534     }
 535     SERVER_END_REQ;
 536
 537     if (tid)
 538     {
 539         TRACE( "calling hook in thread %04lx %s code %x wp %x lp %lx\n",
 540                tid, hook_names[id-WH_MINHOOK], code, wparam, lparam );
 541
 542         switch(id)
 543         {
 544         case WH_KEYBOARD_LL:
 545             MSG_SendInternalMessageTimeout( pid, tid, WM_WINE_KEYBOARD_LL_HOOK, wparam, lparam,
 546                                             SMTO_ABORTIFHUNG, get_ll_hook_timeout(), &ret );
 547             break;
 548         case WH_MOUSE_LL:
 549             MSG_SendInternalMessageTimeout( pid, tid, WM_WINE_MOUSE_LL_HOOK, wparam, lparam,
 550                                             SMTO_ABORTIFHUNG, get_ll_hook_timeout(), &ret );
 551             break;
 552         default:
 553             ERR("Unknown hook id %d\n", id);
 554             assert(0);
 555             break;
 556         }
 557     }
 558     else if (proc)
 559     {
 560         TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
 561                proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, debugstr_w(module) );
 562
 563         if (!module[0] || (proc = get_hook_proc( proc, module )) != NULL)
 564         {
 565             HHOOK prev = thread_info->hook;
 566             thread_info->hook = handle;
 567             ret = call_hook( proc, id, code, wparam, lparam, prev_unicode, next_unicode );
 568             thread_info->hook = prev;
 569         }
 570     }
 571     return ret;
 572 }
 573
 574
 575 /***********************************************************************
 576  *              CallMsgFilterA (USER32.@)
 577  */
 578 BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
 579 {
 580     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, FALSE )) return TRUE;
 581     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, FALSE );
 582 }
 583
 584
 585 /***********************************************************************
 586  *              CallMsgFilterW (USER32.@)
 587  */
 588 BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
 589 {
 590     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, TRUE )) return TRUE;
 591     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, TRUE );
 592 }
 593
 594
 595 /***********************************************************************
 596  *           SetWinEventHook                            [USER32.@]
 597  *
 598  * Set up an event hook for a set of events.
 599  *
 600  * PARAMS
 601  *  event_min [I] Lowest event handled by pfnProc
 602  *  event_max [I] Highest event handled by pfnProc
 603  *  inst      [I] DLL containing pfnProc
 604  *  proc      [I] Callback event hook function
 605  *  pid       [I] Process to get events from, or 0 for all processes
 606  *  tid       [I] Thread to get events from, or 0 for all threads
 607  *  flags     [I] Flags indicating the status of pfnProc
 608  *
 609  * RETURNS
 610  *  Success: A handle representing the hook.
 611  *  Failure: A NULL handle.
 612  */
 613 HWINEVENTHOOK WINAPI SetWinEventHook(DWORD event_min, DWORD event_max,
 614                                      HMODULE inst, WINEVENTPROC proc,
 615                                      DWORD pid, DWORD tid, DWORD flags)
 616 {
 617     HWINEVENTHOOK handle = 0;
 618     WCHAR module[MAX_PATH];
 619     DWORD len;
 620
 621     TRACE("%ld,%ld,%p,%p,%08lx,%04lx,%08lx\n", event_min, event_max, inst,
 622           proc, pid, tid, flags);
 623
 624     if (inst)
 625     {
 626         if (!(len = GetModuleFileNameW(inst, module, MAX_PATH)) || len >= MAX_PATH)
 627             inst = 0;
 628     }
 629
 630     if ((flags & WINEVENT_INCONTEXT) && !inst)
 631     {
 632         SetLastError(ERROR_HOOK_NEEDS_HMOD);
 633         return 0;
 634     }
 635
 636     if (event_min > event_max)
 637     {
 638         SetLastError(ERROR_INVALID_HOOK_FILTER);
 639         return 0;
 640     }
 641
 642     /* FIXME: what if the tid or pid belongs to another process? */
 643     if (tid)  /* thread-local hook */
 644         inst = 0;
 645
 646     SERVER_START_REQ( set_hook )
 647     {
 648         req->id        = WH_WINEVENT;
 649         req->pid       = pid;
 650         req->tid       = tid;
 651         req->event_min = event_min;
 652         req->event_max = event_max;
 653         req->flags     = flags;
 654         req->unicode   = 1;
 655         if (inst) /* make proc relative to the module base */
 656         {
 657             req->proc = (void *)((char *)proc - (char *)inst);
 658             wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
 659         }
 660         else req->proc = proc;
 661
 662         if (!wine_server_call_err( req ))
 663         {
 664             handle = reply->handle;
 665             get_user_thread_info()->active_hooks = reply->active_hooks;
 666         }
 667     }
 668     SERVER_END_REQ;
 669
 670     TRACE("-> %p\n", handle);
 671     return handle;
 672 }
 673
 674
 675 /***********************************************************************
 676  *           UnhookWinEvent                             [USER32.@]
 677  *
 678  * Remove an event hook for a set of events.
 679  *
 680  * PARAMS
 681  *  hEventHook [I] Event hook to remove
 682  *
 683  * RETURNS
 684  *  Success: TRUE. The event hook has been removed.
 685  *  Failure: FALSE, if hEventHook is invalid.
 686  */
 687 BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK hEventHook)
 688 {
 689     BOOL ret;
 690
 691     TRACE( "%p\n", hEventHook );
 692
 693     SERVER_START_REQ( remove_hook )
 694     {
 695         req->handle = hEventHook;
 696         req->id     = WH_WINEVENT;
 697         ret = !wine_server_call_err( req );
 698         if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
 699     }
 700     SERVER_END_REQ;
 701     return ret;
 702 }
 703
 704 inline static BOOL find_first_hook(DWORD id, DWORD event, HWND hwnd, LONG object_id,
 705                                    LONG child_id, struct hook_info *info)
 706 {
 707     struct user_thread_info *thread_info = get_user_thread_info();
 708     BOOL ret;
 709
 710     if (!HOOK_IsHooked( id ))
 711     {
 712         TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
 713         return FALSE;
 714     }
 715
 716     SERVER_START_REQ( start_hook_chain )
 717     {
 718         req->id = id;
 719         req->event = event;
 720         req->window = hwnd;
 721         req->object_id = object_id;
 722         req->child_id = child_id;
 723         wine_server_set_reply( req, info->module, sizeof(info->module)-sizeof(WCHAR) );
 724         ret = !wine_server_call( req );
 725         if (ret)
 726         {
 727             info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
 728             info->handle    = reply->handle;
 729             info->proc      = reply->proc;
 730             info->tid       = reply->tid;
 731             thread_info->active_hooks = reply->active_hooks;
 732         }
 733     }
 734     SERVER_END_REQ;
 735     return ret && (info->tid || info->proc);
 736 }
 737
 738 inline static BOOL find_next_hook(DWORD event, HWND hwnd, LONG object_id,
 739                                   LONG child_id, struct hook_info *info)
 740 {
 741     BOOL ret;
 742
 743     SERVER_START_REQ( get_next_hook )
 744     {
 745         req->handle = info->handle;
 746         req->event = event;
 747         req->window = hwnd;
 748         req->object_id = object_id;
 749         req->child_id = child_id;
 750         wine_server_set_reply( req, info->module, sizeof(info->module)-sizeof(WCHAR) );
 751         ret = !wine_server_call( req );
 752         if (ret)
 753         {
 754             info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
 755             info->handle    = reply->next;
 756             info->proc      = reply->proc;
 757             info->tid       = reply->tid;
 758         }
 759     }
 760     SERVER_END_REQ;
 761     return ret;
 762 }
 763
 764 inline static void find_hook_close(DWORD id)
 765 {
 766     SERVER_START_REQ( finish_hook_chain )
 767     {
 768         req->id = id;
 769         wine_server_call( req );
 770     }
 771     SERVER_END_REQ;
 772 }
 773
 774 /***********************************************************************
 775  *           NotifyWinEvent                             [USER32.@]
 776  *
 777  * Inform the OS that an event has occurred.
 778  *
 779  * PARAMS
 780  *  event     [I] Id of the event
 781  *  hwnd      [I] Window holding the object that created the event
 782  *  object_id [I] Type of object that created the event
 783  *  child_id  [I] Child object of nId, or CHILDID_SELF.
 784  *
 785  * RETURNS
 786  *  Nothing.
 787  */
 788 void WINAPI NotifyWinEvent(DWORD event, HWND hwnd, LONG object_id, LONG child_id)
 789 {
 790     struct hook_info info;
 791
 792     TRACE("%04lx,%p,%ld,%ld\n", event, hwnd, object_id, child_id);
 793
 794     if (!hwnd)
 795     {
 796         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
 797         return;
 798     }
 799
 800     USER_CheckNotLock();
 801
 802 #if 0
 803     if (event & 0x80000000)
 804     {
 805         /* FIXME: on 64-bit platforms we need to invent some other way for
 806          * passing parameters, nId and nChildId can't hold full [W|L]PARAM.
 807          * struct call_hook *hook = (LRESULT *)hWnd;
 808          * wparam = hook->wparam;
 809          * lparam = hook->lparam;
 810          */
 811         LRESULT *ret = (LRESULT *)hwnd;
 812         INT id, code, unicode;
 813
 814         id = (dwEvent & 0x7fff0000) >> 16;
 815         code = event & 0x7fff;
 816         unicode = event & 0x8000;
 817         *ret = HOOK_CallHooks(id, code, object_id, child_id, unicode);
 818         return;
 819     }
 820 #endif
 821
 822     if (!find_first_hook(WH_WINEVENT, event, hwnd, object_id, child_id, &info)) return;
 823
 824     do
 825     {
 826         if (info.proc)
 827         {
 828             TRACE( "calling WH_WINEVENT hook %p event %lx hwnd %p %lx %lx module %s\n",
 829                    info.proc, event, hwnd, object_id, child_id, debugstr_w(info.module) );
 830
 831             if (!info.module[0] || (info.proc = get_hook_proc( info.proc, info.module )) != NULL)
 832             {
 833                 if (TRACE_ON(relay))
 834                     DPRINTF( "%04lx:Call winevent hook proc %p (hhook=%p,event=%lx,hwnd=%p,object_id=%lx,child_id=%lx,tid=%04lx,time=%lx)\n",
 835                              GetCurrentThreadId(), info.proc, info.handle, event, hwnd, object_id,
 836                              child_id, GetCurrentThreadId(), GetCurrentTime());
 837
 838                 info.proc(info.handle, event, hwnd, object_id, child_id,
 839                           GetCurrentThreadId(), GetCurrentTime());
 840
 841                 if (TRACE_ON(relay))
 842                     DPRINTF( "%04lx:Ret  winevent hook proc %p (hhook=%p,event=%lx,hwnd=%p,object_id=%lx,child_id=%lx,tid=%04lx,time=%lx)\n",
 843                              GetCurrentThreadId(), info.proc, info.handle, event, hwnd, object_id,
 844                              child_id, GetCurrentThreadId(), GetCurrentTime());
 845             }
 846         }
 847         else
 848             break;
 849     }
 850     while (find_next_hook(event, hwnd, object_id, child_id, &info));
 851
 852     find_hook_close(WH_WINEVENT);
 853 }
 854
 855
 856 /***********************************************************************
 857  *           IsWinEventHookInstalled                       [USER32.@]
 858  *
 859  * Determine if an event hook is installed for an event.
 860  *
 861  * PARAMS
 862  *  dwEvent  [I] Id of the event
 863  *
 864  * RETURNS
 865  *  TRUE,  If there are any hooks installed for the event.
 866  *  FALSE, Otherwise.
 867  *
 868  * BUGS
 869  *  Not implemented.
 870  */
 871 BOOL WINAPI IsWinEventHookInstalled(DWORD dwEvent)
 872 {
 873     FIXME("(%ld)-stub!\n", dwEvent);
 874     return TRUE;
 875 }