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