opengl32: Fix some style issues.
[wine.git] / dlls / user32 / hook.c
blob633704be4d5a41b963f232d9fabee87e6bf01d70
1 /*
2 * Windows hook functions
4 * Copyright 2002 Alexandre Julliard
5 * Copyright 2005 Dmitry Timoshkov
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.
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.
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
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
65 #include "config.h"
66 #include "wine/port.h"
68 #include <stdarg.h>
69 #include <assert.h>
71 #include "windef.h"
72 #include "winbase.h"
73 #include "wingdi.h"
74 #include "winuser.h"
75 #include "winerror.h"
76 #include "win.h"
77 #include "user_private.h"
78 #include "wine/server.h"
79 #include "wine/unicode.h"
80 #include "wine/debug.h"
81 #include "winternl.h"
83 WINE_DEFAULT_DEBUG_CHANNEL(hook);
84 WINE_DECLARE_DEBUG_CHANNEL(relay);
86 struct hook_info
88 INT id;
89 void *proc;
90 void *handle;
91 DWORD pid, tid;
92 BOOL prev_unicode, next_unicode;
93 WCHAR module[MAX_PATH];
96 #define WH_WINEVENT (WH_MAXHOOK+1)
98 static const char * const hook_names[WH_WINEVENT - WH_MINHOOK + 1] =
100 "WH_MSGFILTER",
101 "WH_JOURNALRECORD",
102 "WH_JOURNALPLAYBACK",
103 "WH_KEYBOARD",
104 "WH_GETMESSAGE",
105 "WH_CALLWNDPROC",
106 "WH_CBT",
107 "WH_SYSMSGFILTER",
108 "WH_MOUSE",
109 "WH_HARDWARE",
110 "WH_DEBUG",
111 "WH_SHELL",
112 "WH_FOREGROUNDIDLE",
113 "WH_CALLWNDPROCRET",
114 "WH_KEYBOARD_LL",
115 "WH_MOUSE_LL",
116 "WH_WINEVENT"
120 /***********************************************************************
121 * get_ll_hook_timeout
124 static UINT get_ll_hook_timeout(void)
126 /* FIXME: should retrieve LowLevelHooksTimeout in HKEY_CURRENT_USER\Control Panel\Desktop */
127 return 2000;
131 /***********************************************************************
132 * set_windows_hook
134 * Implementation of SetWindowsHookExA and SetWindowsHookExW.
136 static HHOOK set_windows_hook( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid, BOOL unicode )
138 HHOOK handle = 0;
139 WCHAR module[MAX_PATH];
140 DWORD len;
142 if (!proc)
144 SetLastError( ERROR_INVALID_FILTER_PROC );
145 return 0;
148 if (tid) /* thread-local hook */
150 if (id == WH_JOURNALRECORD ||
151 id == WH_JOURNALPLAYBACK ||
152 id == WH_KEYBOARD_LL ||
153 id == WH_MOUSE_LL ||
154 id == WH_SYSMSGFILTER)
156 /* these can only be global */
157 SetLastError( ERROR_INVALID_PARAMETER );
158 return 0;
161 else /* system-global hook */
163 if (id == WH_KEYBOARD_LL || id == WH_MOUSE_LL) inst = 0;
164 else if (!inst)
166 SetLastError( ERROR_HOOK_NEEDS_HMOD );
167 return 0;
171 if (inst && (!(len = GetModuleFileNameW( inst, module, MAX_PATH )) || len >= MAX_PATH))
173 SetLastError( ERROR_INVALID_PARAMETER );
174 return 0;
177 SERVER_START_REQ( set_hook )
179 req->id = id;
180 req->pid = 0;
181 req->tid = tid;
182 req->event_min = EVENT_MIN;
183 req->event_max = EVENT_MAX;
184 req->flags = WINEVENT_INCONTEXT;
185 req->unicode = unicode;
186 if (inst) /* make proc relative to the module base */
188 req->proc = wine_server_client_ptr( (void *)((char *)proc - (char *)inst) );
189 wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
191 else req->proc = wine_server_client_ptr( proc );
193 if (!wine_server_call_err( req ))
195 handle = wine_server_ptr_handle( reply->handle );
196 get_user_thread_info()->active_hooks = reply->active_hooks;
199 SERVER_END_REQ;
201 TRACE( "%s %p %x -> %p\n", hook_names[id-WH_MINHOOK], proc, tid, handle );
202 return handle;
205 #ifdef __i386__
206 /* Some apps pass a non-stdcall proc to SetWindowsHookExA,
207 * so we need a small assembly wrapper to call the proc.
209 extern LRESULT HOOKPROC_wrapper( HOOKPROC proc,
210 INT code, WPARAM wParam, LPARAM lParam );
211 __ASM_GLOBAL_FUNC( HOOKPROC_wrapper,
212 "pushl %ebp\n\t"
213 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
214 __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
215 "movl %esp,%ebp\n\t"
216 __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
217 "pushl %edi\n\t"
218 __ASM_CFI(".cfi_rel_offset %edi,-4\n\t")
219 "pushl %esi\n\t"
220 __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
221 "pushl %ebx\n\t"
222 __ASM_CFI(".cfi_rel_offset %ebx,-12\n\t")
223 "pushl 20(%ebp)\n\t"
224 "pushl 16(%ebp)\n\t"
225 "pushl 12(%ebp)\n\t"
226 "movl 8(%ebp),%eax\n\t"
227 "call *%eax\n\t"
228 "leal -12(%ebp),%esp\n\t"
229 "popl %ebx\n\t"
230 __ASM_CFI(".cfi_same_value %ebx\n\t")
231 "popl %esi\n\t"
232 __ASM_CFI(".cfi_same_value %esi\n\t")
233 "popl %edi\n\t"
234 __ASM_CFI(".cfi_same_value %edi\n\t")
235 "leave\n\t"
236 __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
237 __ASM_CFI(".cfi_same_value %ebp\n\t")
238 "ret" )
239 #else
240 static inline LRESULT HOOKPROC_wrapper( HOOKPROC proc,
241 INT code, WPARAM wParam, LPARAM lParam )
243 return proc( code, wParam, lParam );
245 #endif /* __i386__ */
248 /***********************************************************************
249 * call_hook_AtoW
251 static LRESULT call_hook_AtoW( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
253 LRESULT ret;
254 UNICODE_STRING usBuffer;
255 if (id != WH_CBT || code != HCBT_CREATEWND)
256 ret = HOOKPROC_wrapper( proc, code, wparam, lparam );
257 else
259 CBT_CREATEWNDA *cbtcwA = (CBT_CREATEWNDA *)lparam;
260 CBT_CREATEWNDW cbtcwW;
261 CREATESTRUCTW csW;
262 LPWSTR nameW = NULL;
263 LPWSTR classW = NULL;
265 cbtcwW.lpcs = &csW;
266 cbtcwW.hwndInsertAfter = cbtcwA->hwndInsertAfter;
267 csW = *(CREATESTRUCTW *)cbtcwA->lpcs;
269 if (!IS_INTRESOURCE(cbtcwA->lpcs->lpszName))
271 RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszName);
272 csW.lpszName = nameW = usBuffer.Buffer;
274 if (!IS_INTRESOURCE(cbtcwA->lpcs->lpszClass))
276 RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszClass);
277 csW.lpszClass = classW = usBuffer.Buffer;
279 ret = HOOKPROC_wrapper( proc, code, wparam, (LPARAM)&cbtcwW );
280 cbtcwA->hwndInsertAfter = cbtcwW.hwndInsertAfter;
281 HeapFree( GetProcessHeap(), 0, nameW );
282 HeapFree( GetProcessHeap(), 0, classW );
284 return ret;
288 /***********************************************************************
289 * call_hook_WtoA
291 static LRESULT call_hook_WtoA( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
293 LRESULT ret;
295 if (id != WH_CBT || code != HCBT_CREATEWND)
296 ret = HOOKPROC_wrapper( proc, code, wparam, lparam );
297 else
299 CBT_CREATEWNDW *cbtcwW = (CBT_CREATEWNDW *)lparam;
300 CBT_CREATEWNDA cbtcwA;
301 CREATESTRUCTA csA;
302 int len;
303 LPSTR nameA = NULL;
304 LPSTR classA = NULL;
306 cbtcwA.lpcs = &csA;
307 cbtcwA.hwndInsertAfter = cbtcwW->hwndInsertAfter;
308 csA = *(CREATESTRUCTA *)cbtcwW->lpcs;
310 if (!IS_INTRESOURCE(cbtcwW->lpcs->lpszName)) {
311 len = WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszName, -1, NULL, 0, NULL, NULL );
312 nameA = HeapAlloc( GetProcessHeap(), 0, len*sizeof(CHAR) );
313 WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszName, -1, nameA, len, NULL, NULL );
314 csA.lpszName = nameA;
317 if (!IS_INTRESOURCE(cbtcwW->lpcs->lpszClass)) {
318 len = WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszClass, -1, NULL, 0, NULL, NULL );
319 classA = HeapAlloc( GetProcessHeap(), 0, len*sizeof(CHAR) );
320 WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszClass, -1, classA, len, NULL, NULL );
321 csA.lpszClass = classA;
324 ret = HOOKPROC_wrapper( proc, code, wparam, (LPARAM)&cbtcwA );
325 cbtcwW->hwndInsertAfter = cbtcwA.hwndInsertAfter;
326 HeapFree( GetProcessHeap(), 0, nameA );
327 HeapFree( GetProcessHeap(), 0, classA );
329 return ret;
333 /***********************************************************************
334 * call_hook_proc
336 static LRESULT call_hook_proc( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
337 BOOL prev_unicode, BOOL next_unicode )
339 LRESULT ret;
341 if (TRACE_ON(relay))
342 DPRINTF( "%04x:Call hook proc %p (id=%s,code=%x,wp=%08lx,lp=%08lx)\n",
343 GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam );
345 if (!prev_unicode == !next_unicode) ret = proc( code, wparam, lparam );
346 else if (prev_unicode) ret = call_hook_WtoA( proc, id, code, wparam, lparam );
347 else ret = call_hook_AtoW( proc, id, code, wparam, lparam );
349 if (TRACE_ON(relay))
350 DPRINTF( "%04x:Ret hook proc %p (id=%s,code=%x,wp=%08lx,lp=%08lx) retval=%08lx\n",
351 GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, ret );
353 return ret;
357 /***********************************************************************
358 * get_hook_proc
360 * Retrieve the hook procedure real value for a module-relative proc
362 void *get_hook_proc( void *proc, const WCHAR *module )
364 HMODULE mod;
366 if (!(mod = GetModuleHandleW(module)))
368 TRACE( "loading %s\n", debugstr_w(module) );
369 /* FIXME: the library will never be freed */
370 if (!(mod = LoadLibraryExW(module, NULL, LOAD_WITH_ALTERED_SEARCH_PATH))) return NULL;
372 return (char *)mod + (ULONG_PTR)proc;
375 /***********************************************************************
376 * call_hook
378 * Call hook either in current thread or send message to the destination
379 * thread.
381 static LRESULT call_hook( struct hook_info *info, INT code, WPARAM wparam, LPARAM lparam )
383 DWORD_PTR ret = 0;
385 if (info->tid)
387 struct hook_extra_info h_extra;
388 h_extra.handle = info->handle;
389 h_extra.lparam = lparam;
391 TRACE( "calling hook in thread %04x %s code %x wp %lx lp %lx\n",
392 info->tid, hook_names[info->id-WH_MINHOOK], code, wparam, lparam );
394 switch(info->id)
396 case WH_KEYBOARD_LL:
397 MSG_SendInternalMessageTimeout( info->pid, info->tid, WM_WINE_KEYBOARD_LL_HOOK,
398 wparam, (LPARAM)&h_extra, SMTO_ABORTIFHUNG,
399 get_ll_hook_timeout(), &ret );
400 break;
401 case WH_MOUSE_LL:
402 MSG_SendInternalMessageTimeout( info->pid, info->tid, WM_WINE_MOUSE_LL_HOOK,
403 wparam, (LPARAM)&h_extra, SMTO_ABORTIFHUNG,
404 get_ll_hook_timeout(), &ret );
405 break;
406 default:
407 ERR("Unknown hook id %d\n", info->id);
408 assert(0);
409 break;
412 else if (info->proc)
414 TRACE( "calling hook %p %s code %x wp %lx lp %lx module %s\n",
415 info->proc, hook_names[info->id-WH_MINHOOK], code, wparam,
416 lparam, debugstr_w(info->module) );
418 if (!info->module[0] ||
419 (info->proc = get_hook_proc( info->proc, info->module )) != NULL)
421 struct user_thread_info *thread_info = get_user_thread_info();
422 HHOOK prev = thread_info->hook;
423 BOOL prev_unicode = thread_info->hook_unicode;
425 thread_info->hook = info->handle;
426 thread_info->hook_unicode = info->next_unicode;
427 ret = call_hook_proc( info->proc, info->id, code, wparam, lparam,
428 info->prev_unicode, info->next_unicode );
429 thread_info->hook = prev;
430 thread_info->hook_unicode = prev_unicode;
434 if (info->id == WH_KEYBOARD_LL || info->id == WH_MOUSE_LL)
435 get_user_thread_info()->key_state_time = 0; /* force refreshing the key state cache */
437 return ret;
441 /***********************************************************************
442 * HOOK_IsHooked
444 static BOOL HOOK_IsHooked( INT id )
446 struct user_thread_info *thread_info = get_user_thread_info();
448 if (!thread_info->active_hooks) return TRUE;
449 return (thread_info->active_hooks & (1 << (id - WH_MINHOOK))) != 0;
453 /***********************************************************************
454 * HOOK_CallHooks
456 LRESULT HOOK_CallHooks( INT id, INT code, WPARAM wparam, LPARAM lparam, BOOL unicode )
458 struct user_thread_info *thread_info = get_user_thread_info();
459 struct hook_info info;
460 DWORD_PTR ret = 0;
462 USER_CheckNotLock();
464 if (!HOOK_IsHooked( id ))
466 TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
467 return 0;
470 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
471 info.prev_unicode = unicode;
472 info.id = id;
474 SERVER_START_REQ( start_hook_chain )
476 req->id = info.id;
477 req->event = EVENT_MIN;
478 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
479 if (!wine_server_call( req ))
481 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
482 info.handle = wine_server_ptr_handle( reply->handle );
483 info.pid = reply->pid;
484 info.tid = reply->tid;
485 info.proc = wine_server_get_ptr( reply->proc );
486 info.next_unicode = reply->unicode;
487 thread_info->active_hooks = reply->active_hooks;
490 SERVER_END_REQ;
492 if (!info.tid && !info.proc) return 0;
493 ret = call_hook( &info, code, wparam, lparam );
495 SERVER_START_REQ( finish_hook_chain )
497 req->id = id;
498 wine_server_call( req );
500 SERVER_END_REQ;
501 return ret;
505 /***********************************************************************
506 * SetWindowsHookA (USER32.@)
508 HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
510 return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
514 /***********************************************************************
515 * SetWindowsHookW (USER32.@)
517 HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
519 return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
523 /***********************************************************************
524 * SetWindowsHookExA (USER32.@)
526 HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
528 return set_windows_hook( id, proc, inst, tid, FALSE );
531 /***********************************************************************
532 * SetWindowsHookExW (USER32.@)
534 HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
536 return set_windows_hook( id, proc, inst, tid, TRUE );
540 /***********************************************************************
541 * UnhookWindowsHook (USER32.@)
543 BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
545 BOOL ret;
547 TRACE( "%s %p\n", hook_names[id-WH_MINHOOK], proc );
549 SERVER_START_REQ( remove_hook )
551 req->handle = 0;
552 req->id = id;
553 req->proc = wine_server_client_ptr( proc );
554 ret = !wine_server_call_err( req );
555 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
557 SERVER_END_REQ;
558 if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
559 return ret;
564 /***********************************************************************
565 * UnhookWindowsHookEx (USER32.@)
567 BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
569 BOOL ret;
571 SERVER_START_REQ( remove_hook )
573 req->handle = wine_server_user_handle( hhook );
574 req->id = 0;
575 ret = !wine_server_call_err( req );
576 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
578 SERVER_END_REQ;
579 if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
580 return ret;
584 /***********************************************************************
585 * CallNextHookEx (USER32.@)
587 LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
589 struct user_thread_info *thread_info = get_user_thread_info();
590 struct hook_info info;
592 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
594 SERVER_START_REQ( get_hook_info )
596 req->handle = wine_server_user_handle( thread_info->hook );
597 req->get_next = 1;
598 req->event = EVENT_MIN;
599 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
600 if (!wine_server_call_err( req ))
602 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
603 info.handle = wine_server_ptr_handle( reply->handle );
604 info.id = reply->id;
605 info.pid = reply->pid;
606 info.tid = reply->tid;
607 info.proc = wine_server_get_ptr( reply->proc );
608 info.next_unicode = reply->unicode;
611 SERVER_END_REQ;
613 info.prev_unicode = thread_info->hook_unicode;
614 return call_hook( &info, code, wparam, lparam );
618 LRESULT call_current_hook( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
620 struct hook_info info;
622 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
624 SERVER_START_REQ( get_hook_info )
626 req->handle = wine_server_user_handle( hhook );
627 req->get_next = 0;
628 req->event = EVENT_MIN;
629 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
630 if (!wine_server_call_err( req ))
632 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
633 info.handle = wine_server_ptr_handle( reply->handle );
634 info.id = reply->id;
635 info.pid = reply->pid;
636 info.tid = reply->tid;
637 info.proc = wine_server_get_ptr( reply->proc );
638 info.next_unicode = reply->unicode;
641 SERVER_END_REQ;
643 info.prev_unicode = TRUE; /* assume Unicode for this function */
644 return call_hook( &info, code, wparam, lparam );
647 /***********************************************************************
648 * CallMsgFilterA (USER32.@)
650 BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
652 if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, FALSE )) return TRUE;
653 return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, FALSE );
657 /***********************************************************************
658 * CallMsgFilterW (USER32.@)
660 BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
662 if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, TRUE )) return TRUE;
663 return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, TRUE );
667 /***********************************************************************
668 * SetWinEventHook [USER32.@]
670 * Set up an event hook for a set of events.
672 * PARAMS
673 * event_min [I] Lowest event handled by pfnProc
674 * event_max [I] Highest event handled by pfnProc
675 * inst [I] DLL containing pfnProc
676 * proc [I] Callback event hook function
677 * pid [I] Process to get events from, or 0 for all processes
678 * tid [I] Thread to get events from, or 0 for all threads
679 * flags [I] Flags indicating the status of pfnProc
681 * RETURNS
682 * Success: A handle representing the hook.
683 * Failure: A NULL handle.
685 HWINEVENTHOOK WINAPI SetWinEventHook(DWORD event_min, DWORD event_max,
686 HMODULE inst, WINEVENTPROC proc,
687 DWORD pid, DWORD tid, DWORD flags)
689 HWINEVENTHOOK handle = 0;
690 WCHAR module[MAX_PATH];
691 DWORD len;
693 TRACE("%d,%d,%p,%p,%08x,%04x,%08x\n", event_min, event_max, inst,
694 proc, pid, tid, flags);
696 if (inst)
698 if (!(len = GetModuleFileNameW(inst, module, MAX_PATH)) || len >= MAX_PATH)
699 inst = 0;
702 if ((flags & WINEVENT_INCONTEXT) && !inst)
704 SetLastError(ERROR_HOOK_NEEDS_HMOD);
705 return 0;
708 if (event_min > event_max)
710 SetLastError(ERROR_INVALID_HOOK_FILTER);
711 return 0;
714 /* FIXME: what if the tid or pid belongs to another process? */
715 if (tid) /* thread-local hook */
716 inst = 0;
718 SERVER_START_REQ( set_hook )
720 req->id = WH_WINEVENT;
721 req->pid = pid;
722 req->tid = tid;
723 req->event_min = event_min;
724 req->event_max = event_max;
725 req->flags = flags;
726 req->unicode = 1;
727 if (inst) /* make proc relative to the module base */
729 req->proc = wine_server_client_ptr( (void *)((char *)proc - (char *)inst) );
730 wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
732 else req->proc = wine_server_client_ptr( proc );
734 if (!wine_server_call_err( req ))
736 handle = wine_server_ptr_handle( reply->handle );
737 get_user_thread_info()->active_hooks = reply->active_hooks;
740 SERVER_END_REQ;
742 TRACE("-> %p\n", handle);
743 return handle;
747 /***********************************************************************
748 * UnhookWinEvent [USER32.@]
750 * Remove an event hook for a set of events.
752 * PARAMS
753 * hEventHook [I] Event hook to remove
755 * RETURNS
756 * Success: TRUE. The event hook has been removed.
757 * Failure: FALSE, if hEventHook is invalid.
759 BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK hEventHook)
761 BOOL ret;
763 SERVER_START_REQ( remove_hook )
765 req->handle = wine_server_user_handle( hEventHook );
766 req->id = WH_WINEVENT;
767 ret = !wine_server_call_err( req );
768 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
770 SERVER_END_REQ;
771 return ret;
774 static inline BOOL find_first_hook(DWORD id, DWORD event, HWND hwnd, LONG object_id,
775 LONG child_id, struct hook_info *info)
777 struct user_thread_info *thread_info = get_user_thread_info();
778 BOOL ret;
780 if (!HOOK_IsHooked( id ))
782 TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
783 return FALSE;
786 SERVER_START_REQ( start_hook_chain )
788 req->id = id;
789 req->event = event;
790 req->window = wine_server_user_handle( hwnd );
791 req->object_id = object_id;
792 req->child_id = child_id;
793 wine_server_set_reply( req, info->module, sizeof(info->module)-sizeof(WCHAR) );
794 ret = !wine_server_call( req );
795 if (ret)
797 info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
798 info->handle = wine_server_ptr_handle( reply->handle );
799 info->proc = wine_server_get_ptr( reply->proc );
800 info->tid = reply->tid;
801 thread_info->active_hooks = reply->active_hooks;
804 SERVER_END_REQ;
805 return ret && (info->tid || info->proc);
808 static inline BOOL find_next_hook(DWORD event, HWND hwnd, LONG object_id,
809 LONG child_id, struct hook_info *info)
811 BOOL ret;
813 SERVER_START_REQ( get_hook_info )
815 req->handle = wine_server_user_handle( info->handle );
816 req->get_next = 1;
817 req->event = event;
818 req->window = wine_server_user_handle( hwnd );
819 req->object_id = object_id;
820 req->child_id = child_id;
821 wine_server_set_reply( req, info->module, sizeof(info->module)-sizeof(WCHAR) );
822 ret = !wine_server_call( req );
823 if (ret)
825 info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
826 info->handle = wine_server_ptr_handle( reply->handle );
827 info->proc = wine_server_get_ptr( reply->proc );
828 info->tid = reply->tid;
831 SERVER_END_REQ;
832 return ret;
835 static inline void find_hook_close(DWORD id)
837 SERVER_START_REQ( finish_hook_chain )
839 req->id = id;
840 wine_server_call( req );
842 SERVER_END_REQ;
845 /***********************************************************************
846 * NotifyWinEvent [USER32.@]
848 * Inform the OS that an event has occurred.
850 * PARAMS
851 * event [I] Id of the event
852 * hwnd [I] Window holding the object that created the event
853 * object_id [I] Type of object that created the event
854 * child_id [I] Child object of nId, or CHILDID_SELF.
856 * RETURNS
857 * Nothing.
859 void WINAPI NotifyWinEvent(DWORD event, HWND hwnd, LONG object_id, LONG child_id)
861 struct hook_info info;
863 TRACE("%04x,%p,%d,%d\n", event, hwnd, object_id, child_id);
865 if (!hwnd)
867 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
868 return;
871 USER_CheckNotLock();
873 #if 0
874 if (event & 0x80000000)
876 /* FIXME: on 64-bit platforms we need to invent some other way for
877 * passing parameters, nId and nChildId can't hold full [W|L]PARAM.
878 * struct call_hook *hook = (LRESULT *)hWnd;
879 * wparam = hook->wparam;
880 * lparam = hook->lparam;
882 LRESULT *ret = (LRESULT *)hwnd;
883 INT id, code, unicode;
885 id = (dwEvent & 0x7fff0000) >> 16;
886 code = event & 0x7fff;
887 unicode = event & 0x8000;
888 *ret = HOOK_CallHooks(id, code, object_id, child_id, unicode);
889 return;
891 #endif
893 if (!find_first_hook(WH_WINEVENT, event, hwnd, object_id, child_id, &info)) return;
897 WINEVENTPROC proc = info.proc;
898 if (proc)
900 TRACE( "calling WH_WINEVENT hook %p event %x hwnd %p %x %x module %s\n",
901 proc, event, hwnd, object_id, child_id, debugstr_w(info.module) );
903 if (!info.module[0] || (proc = get_hook_proc( proc, info.module )) != NULL)
905 if (TRACE_ON(relay))
906 DPRINTF( "%04x:Call winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
907 GetCurrentThreadId(), proc, info.handle, event, hwnd, object_id,
908 child_id, GetCurrentThreadId(), GetCurrentTime());
910 proc( info.handle, event, hwnd, object_id, child_id,
911 GetCurrentThreadId(), GetCurrentTime());
913 if (TRACE_ON(relay))
914 DPRINTF( "%04x:Ret winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
915 GetCurrentThreadId(), proc, info.handle, event, hwnd, object_id,
916 child_id, GetCurrentThreadId(), GetCurrentTime());
919 else
920 break;
922 while (find_next_hook(event, hwnd, object_id, child_id, &info));
924 find_hook_close(WH_WINEVENT);
928 /***********************************************************************
929 * IsWinEventHookInstalled [USER32.@]
931 * Determine if an event hook is installed for an event.
933 * PARAMS
934 * dwEvent [I] Id of the event
936 * RETURNS
937 * TRUE, If there are any hooks installed for the event.
938 * FALSE, Otherwise.
940 * BUGS
941 * Not implemented.
943 BOOL WINAPI IsWinEventHookInstalled(DWORD dwEvent)
945 /* FIXME: Needed by Office 2007 installer */
946 WARN("(%d)-stub!\n", dwEvent);
947 return TRUE;