shell32: handle corrupt entry in iconcache registry entry (Coverity).
[wine.git] / dlls / user32 / hook.c
blob916c37e4c1e04ce37529c19afa4c3186e56e6a4f
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 "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"
82 WINE_DEFAULT_DEBUG_CHANNEL(hook);
83 WINE_DECLARE_DEBUG_CHANNEL(relay);
85 struct hook_info
87 INT id;
88 void *proc;
89 void *handle;
90 DWORD pid, tid;
91 BOOL prev_unicode, next_unicode;
92 WCHAR module[MAX_PATH];
95 #define WH_WINEVENT (WH_MAXHOOK+1)
97 static const char * const hook_names[WH_WINEVENT - WH_MINHOOK + 1] =
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"
119 /***********************************************************************
120 * get_ll_hook_timeout
123 static UINT get_ll_hook_timeout(void)
125 /* FIXME: should retrieve LowLevelHooksTimeout in HKEY_CURRENT_USER\Control Panel\Desktop */
126 return 2000;
130 /***********************************************************************
131 * set_windows_hook
133 * Implementation of SetWindowsHookExA and SetWindowsHookExW.
135 static HHOOK set_windows_hook( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid, BOOL unicode )
137 HHOOK handle = 0;
138 WCHAR module[MAX_PATH];
139 DWORD len;
141 if (!proc)
143 SetLastError( ERROR_INVALID_FILTER_PROC );
144 return 0;
147 if (tid) /* thread-local hook */
149 if (id == WH_JOURNALRECORD ||
150 id == WH_JOURNALPLAYBACK ||
151 id == WH_KEYBOARD_LL ||
152 id == WH_MOUSE_LL ||
153 id == WH_SYSMSGFILTER)
155 /* these can only be global */
156 SetLastError( ERROR_INVALID_PARAMETER );
157 return 0;
160 else /* system-global hook */
162 if (id == WH_KEYBOARD_LL || id == WH_MOUSE_LL) inst = 0;
163 else if (!inst)
165 SetLastError( ERROR_HOOK_NEEDS_HMOD );
166 return 0;
170 if (inst && (!(len = GetModuleFileNameW( inst, module, MAX_PATH )) || len >= MAX_PATH))
172 SetLastError( ERROR_INVALID_PARAMETER );
173 return 0;
176 SERVER_START_REQ( set_hook )
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 */
187 req->proc = wine_server_client_ptr( (void *)((char *)proc - (char *)inst) );
188 wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
190 else req->proc = wine_server_client_ptr( proc );
192 if (!wine_server_call_err( req ))
194 handle = wine_server_ptr_handle( reply->handle );
195 get_user_thread_info()->active_hooks = reply->active_hooks;
198 SERVER_END_REQ;
200 TRACE( "%s %p %x -> %p\n", hook_names[id-WH_MINHOOK], proc, tid, handle );
201 return handle;
205 /***********************************************************************
206 * call_hook_AtoW
208 static LRESULT call_hook_AtoW( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
210 LRESULT ret;
211 UNICODE_STRING usBuffer;
212 if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
213 else
215 CBT_CREATEWNDA *cbtcwA = (CBT_CREATEWNDA *)lparam;
216 CBT_CREATEWNDW cbtcwW;
217 CREATESTRUCTW csW;
218 LPWSTR nameW = NULL;
219 LPWSTR classW = NULL;
221 cbtcwW.lpcs = &csW;
222 cbtcwW.hwndInsertAfter = cbtcwA->hwndInsertAfter;
223 csW = *(CREATESTRUCTW *)cbtcwA->lpcs;
225 if (HIWORD(cbtcwA->lpcs->lpszName))
227 RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszName);
228 csW.lpszName = nameW = usBuffer.Buffer;
230 if (HIWORD(cbtcwA->lpcs->lpszClass))
232 RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszClass);
233 csW.lpszClass = classW = usBuffer.Buffer;
235 ret = proc( code, wparam, (LPARAM)&cbtcwW );
236 cbtcwA->hwndInsertAfter = cbtcwW.hwndInsertAfter;
237 HeapFree( GetProcessHeap(), 0, nameW );
238 HeapFree( GetProcessHeap(), 0, classW );
240 return ret;
244 /***********************************************************************
245 * call_hook_WtoA
247 static LRESULT call_hook_WtoA( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
249 LRESULT ret;
251 if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
252 else
254 CBT_CREATEWNDW *cbtcwW = (CBT_CREATEWNDW *)lparam;
255 CBT_CREATEWNDA cbtcwA;
256 CREATESTRUCTA csA;
257 int len;
258 LPSTR nameA = NULL;
259 LPSTR classA = NULL;
261 cbtcwA.lpcs = &csA;
262 cbtcwA.hwndInsertAfter = cbtcwW->hwndInsertAfter;
263 csA = *(CREATESTRUCTA *)cbtcwW->lpcs;
265 if (HIWORD(cbtcwW->lpcs->lpszName)) {
266 len = WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszName, -1, NULL, 0, NULL, NULL );
267 nameA = HeapAlloc( GetProcessHeap(), 0, len*sizeof(CHAR) );
268 WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszName, -1, nameA, len, NULL, NULL );
269 csA.lpszName = nameA;
272 if (HIWORD(cbtcwW->lpcs->lpszClass)) {
273 len = WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszClass, -1, NULL, 0, NULL, NULL );
274 classA = HeapAlloc( GetProcessHeap(), 0, len*sizeof(CHAR) );
275 WideCharToMultiByte( CP_ACP, 0, cbtcwW->lpcs->lpszClass, -1, classA, len, NULL, NULL );
276 csA.lpszClass = classA;
279 ret = proc( code, wparam, (LPARAM)&cbtcwA );
280 cbtcwW->hwndInsertAfter = cbtcwA.hwndInsertAfter;
281 HeapFree( GetProcessHeap(), 0, nameA );
282 HeapFree( GetProcessHeap(), 0, classA );
284 return ret;
288 /***********************************************************************
289 * call_hook_proc
291 static LRESULT call_hook_proc( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
292 BOOL prev_unicode, BOOL next_unicode )
294 LRESULT ret;
296 if (TRACE_ON(relay))
297 DPRINTF( "%04x:Call hook proc %p (id=%s,code=%x,wp=%08lx,lp=%08lx)\n",
298 GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam );
300 if (!prev_unicode == !next_unicode) ret = proc( code, wparam, lparam );
301 else if (prev_unicode) ret = call_hook_WtoA( proc, id, code, wparam, lparam );
302 else ret = call_hook_AtoW( proc, id, code, wparam, lparam );
304 if (TRACE_ON(relay))
305 DPRINTF( "%04x:Ret hook proc %p (id=%s,code=%x,wp=%08lx,lp=%08lx) retval=%08lx\n",
306 GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, ret );
308 return ret;
312 /***********************************************************************
313 * get_hook_proc
315 * Retrieve the hook procedure real value for a module-relative proc
317 void *get_hook_proc( void *proc, const WCHAR *module )
319 HMODULE mod;
321 if (!(mod = GetModuleHandleW(module)))
323 TRACE( "loading %s\n", debugstr_w(module) );
324 /* FIXME: the library will never be freed */
325 if (!(mod = LoadLibraryExW(module, NULL, LOAD_WITH_ALTERED_SEARCH_PATH))) return NULL;
327 return (char *)mod + (ULONG_PTR)proc;
330 /***********************************************************************
331 * call_hook
333 * Call hook either in current thread or send message to the destination
334 * thread.
336 static LRESULT call_hook( struct hook_info *info, INT code, WPARAM wparam, LPARAM lparam )
338 DWORD_PTR ret = 0;
340 if (info->tid)
342 struct hook_extra_info h_extra;
343 h_extra.handle = info->handle;
344 h_extra.lparam = lparam;
346 TRACE( "calling hook in thread %04x %s code %x wp %lx lp %lx\n",
347 info->tid, hook_names[info->id-WH_MINHOOK], code, wparam, lparam );
349 switch(info->id)
351 case WH_KEYBOARD_LL:
352 MSG_SendInternalMessageTimeout( info->pid, info->tid, WM_WINE_KEYBOARD_LL_HOOK,
353 wparam, (LPARAM)&h_extra, SMTO_ABORTIFHUNG,
354 get_ll_hook_timeout(), &ret );
355 break;
356 case WH_MOUSE_LL:
357 MSG_SendInternalMessageTimeout( info->pid, info->tid, WM_WINE_MOUSE_LL_HOOK,
358 wparam, (LPARAM)&h_extra, SMTO_ABORTIFHUNG,
359 get_ll_hook_timeout(), &ret );
360 break;
361 default:
362 ERR("Unknown hook id %d\n", info->id);
363 assert(0);
364 break;
367 else if (info->proc)
369 TRACE( "calling hook %p %s code %x wp %lx lp %lx module %s\n",
370 info->proc, hook_names[info->id-WH_MINHOOK], code, wparam,
371 lparam, debugstr_w(info->module) );
373 if (!info->module[0] ||
374 (info->proc = get_hook_proc( info->proc, info->module )) != NULL)
376 struct user_thread_info *thread_info = get_user_thread_info();
377 HHOOK prev = thread_info->hook;
378 BOOL prev_unicode = thread_info->hook_unicode;
380 thread_info->hook = info->handle;
381 thread_info->hook_unicode = info->next_unicode;
382 ret = call_hook_proc( info->proc, info->id, code, wparam, lparam,
383 info->prev_unicode, info->next_unicode );
384 thread_info->hook = prev;
385 thread_info->hook_unicode = prev_unicode;
388 return ret;
391 /***********************************************************************
392 * HOOK_CallHooks
394 LRESULT HOOK_CallHooks( INT id, INT code, WPARAM wparam, LPARAM lparam, BOOL unicode )
396 struct user_thread_info *thread_info = get_user_thread_info();
397 struct hook_info info;
398 DWORD_PTR ret = 0;
400 USER_CheckNotLock();
402 if (!HOOK_IsHooked( id ))
404 TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
405 return 0;
408 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
409 info.prev_unicode = unicode;
410 info.id = id;
412 SERVER_START_REQ( start_hook_chain )
414 req->id = info.id;
415 req->event = EVENT_MIN;
416 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
417 if (!wine_server_call( req ))
419 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
420 info.handle = wine_server_ptr_handle( reply->handle );
421 info.pid = reply->pid;
422 info.tid = reply->tid;
423 info.proc = wine_server_get_ptr( reply->proc );
424 info.next_unicode = reply->unicode;
425 thread_info->active_hooks = reply->active_hooks;
428 SERVER_END_REQ;
430 if (!info.tid && !info.proc) return 0;
431 ret = call_hook( &info, code, wparam, lparam );
433 SERVER_START_REQ( finish_hook_chain )
435 req->id = id;
436 wine_server_call( req );
438 SERVER_END_REQ;
439 return ret;
443 /***********************************************************************
444 * HOOK_IsHooked
446 BOOL HOOK_IsHooked( INT id )
448 struct user_thread_info *thread_info = get_user_thread_info();
450 if (!thread_info->active_hooks) return TRUE;
451 return (thread_info->active_hooks & (1 << (id - WH_MINHOOK))) != 0;
455 /***********************************************************************
456 * SetWindowsHookA (USER32.@)
458 HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
460 return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
464 /***********************************************************************
465 * SetWindowsHookW (USER32.@)
467 HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
469 return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
473 /***********************************************************************
474 * SetWindowsHookExA (USER32.@)
476 HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
478 return set_windows_hook( id, proc, inst, tid, FALSE );
481 /***********************************************************************
482 * SetWindowsHookExW (USER32.@)
484 HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
486 return set_windows_hook( id, proc, inst, tid, TRUE );
490 /***********************************************************************
491 * UnhookWindowsHook (USER32.@)
493 BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
495 BOOL ret;
497 TRACE( "%s %p\n", hook_names[id-WH_MINHOOK], proc );
499 SERVER_START_REQ( remove_hook )
501 req->handle = 0;
502 req->id = id;
503 req->proc = wine_server_client_ptr( proc );
504 ret = !wine_server_call_err( req );
505 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
507 SERVER_END_REQ;
508 if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
509 return ret;
514 /***********************************************************************
515 * UnhookWindowsHookEx (USER32.@)
517 BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
519 BOOL ret;
521 SERVER_START_REQ( remove_hook )
523 req->handle = wine_server_user_handle( hhook );
524 req->id = 0;
525 ret = !wine_server_call_err( req );
526 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
528 SERVER_END_REQ;
529 if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
530 return ret;
534 /***********************************************************************
535 * CallNextHookEx (USER32.@)
537 LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
539 struct user_thread_info *thread_info = get_user_thread_info();
540 struct hook_info info;
542 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
544 SERVER_START_REQ( get_hook_info )
546 req->handle = wine_server_user_handle( thread_info->hook );
547 req->get_next = 1;
548 req->event = EVENT_MIN;
549 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
550 if (!wine_server_call_err( req ))
552 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
553 info.handle = wine_server_ptr_handle( reply->handle );
554 info.id = reply->id;
555 info.pid = reply->pid;
556 info.tid = reply->tid;
557 info.proc = wine_server_get_ptr( reply->proc );
558 info.next_unicode = reply->unicode;
561 SERVER_END_REQ;
563 info.prev_unicode = thread_info->hook_unicode;
564 return call_hook( &info, code, wparam, lparam );
568 LRESULT call_current_hook( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
570 struct hook_info info;
572 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
574 SERVER_START_REQ( get_hook_info )
576 req->handle = wine_server_user_handle( hhook );
577 req->get_next = 0;
578 req->event = EVENT_MIN;
579 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
580 if (!wine_server_call_err( req ))
582 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
583 info.handle = wine_server_ptr_handle( reply->handle );
584 info.id = reply->id;
585 info.pid = reply->pid;
586 info.tid = reply->tid;
587 info.proc = wine_server_get_ptr( reply->proc );
588 info.next_unicode = reply->unicode;
591 SERVER_END_REQ;
593 info.prev_unicode = TRUE; /* assume Unicode for this function */
594 return call_hook( &info, code, wparam, lparam );
597 /***********************************************************************
598 * CallMsgFilterA (USER32.@)
600 BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
602 if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, FALSE )) return TRUE;
603 return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, FALSE );
607 /***********************************************************************
608 * CallMsgFilterW (USER32.@)
610 BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
612 if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, TRUE )) return TRUE;
613 return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, TRUE );
617 /***********************************************************************
618 * SetWinEventHook [USER32.@]
620 * Set up an event hook for a set of events.
622 * PARAMS
623 * event_min [I] Lowest event handled by pfnProc
624 * event_max [I] Highest event handled by pfnProc
625 * inst [I] DLL containing pfnProc
626 * proc [I] Callback event hook function
627 * pid [I] Process to get events from, or 0 for all processes
628 * tid [I] Thread to get events from, or 0 for all threads
629 * flags [I] Flags indicating the status of pfnProc
631 * RETURNS
632 * Success: A handle representing the hook.
633 * Failure: A NULL handle.
635 HWINEVENTHOOK WINAPI SetWinEventHook(DWORD event_min, DWORD event_max,
636 HMODULE inst, WINEVENTPROC proc,
637 DWORD pid, DWORD tid, DWORD flags)
639 HWINEVENTHOOK handle = 0;
640 WCHAR module[MAX_PATH];
641 DWORD len;
643 TRACE("%d,%d,%p,%p,%08x,%04x,%08x\n", event_min, event_max, inst,
644 proc, pid, tid, flags);
646 if (inst)
648 if (!(len = GetModuleFileNameW(inst, module, MAX_PATH)) || len >= MAX_PATH)
649 inst = 0;
652 if ((flags & WINEVENT_INCONTEXT) && !inst)
654 SetLastError(ERROR_HOOK_NEEDS_HMOD);
655 return 0;
658 if (event_min > event_max)
660 SetLastError(ERROR_INVALID_HOOK_FILTER);
661 return 0;
664 /* FIXME: what if the tid or pid belongs to another process? */
665 if (tid) /* thread-local hook */
666 inst = 0;
668 SERVER_START_REQ( set_hook )
670 req->id = WH_WINEVENT;
671 req->pid = pid;
672 req->tid = tid;
673 req->event_min = event_min;
674 req->event_max = event_max;
675 req->flags = flags;
676 req->unicode = 1;
677 if (inst) /* make proc relative to the module base */
679 req->proc = wine_server_client_ptr( (void *)((char *)proc - (char *)inst) );
680 wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
682 else req->proc = wine_server_client_ptr( proc );
684 if (!wine_server_call_err( req ))
686 handle = wine_server_ptr_handle( reply->handle );
687 get_user_thread_info()->active_hooks = reply->active_hooks;
690 SERVER_END_REQ;
692 TRACE("-> %p\n", handle);
693 return handle;
697 /***********************************************************************
698 * UnhookWinEvent [USER32.@]
700 * Remove an event hook for a set of events.
702 * PARAMS
703 * hEventHook [I] Event hook to remove
705 * RETURNS
706 * Success: TRUE. The event hook has been removed.
707 * Failure: FALSE, if hEventHook is invalid.
709 BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK hEventHook)
711 BOOL ret;
713 SERVER_START_REQ( remove_hook )
715 req->handle = wine_server_user_handle( hEventHook );
716 req->id = WH_WINEVENT;
717 ret = !wine_server_call_err( req );
718 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
720 SERVER_END_REQ;
721 return ret;
724 static inline BOOL find_first_hook(DWORD id, DWORD event, HWND hwnd, LONG object_id,
725 LONG child_id, struct hook_info *info)
727 struct user_thread_info *thread_info = get_user_thread_info();
728 BOOL ret;
730 if (!HOOK_IsHooked( id ))
732 TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
733 return FALSE;
736 SERVER_START_REQ( start_hook_chain )
738 req->id = id;
739 req->event = event;
740 req->window = wine_server_user_handle( hwnd );
741 req->object_id = object_id;
742 req->child_id = child_id;
743 wine_server_set_reply( req, info->module, sizeof(info->module)-sizeof(WCHAR) );
744 ret = !wine_server_call( req );
745 if (ret)
747 info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
748 info->handle = wine_server_ptr_handle( reply->handle );
749 info->proc = wine_server_get_ptr( reply->proc );
750 info->tid = reply->tid;
751 thread_info->active_hooks = reply->active_hooks;
754 SERVER_END_REQ;
755 return ret && (info->tid || info->proc);
758 static inline BOOL find_next_hook(DWORD event, HWND hwnd, LONG object_id,
759 LONG child_id, struct hook_info *info)
761 BOOL ret;
763 SERVER_START_REQ( get_hook_info )
765 req->handle = wine_server_user_handle( info->handle );
766 req->get_next = 1;
767 req->event = event;
768 req->window = wine_server_user_handle( hwnd );
769 req->object_id = object_id;
770 req->child_id = child_id;
771 wine_server_set_reply( req, info->module, sizeof(info->module)-sizeof(WCHAR) );
772 ret = !wine_server_call( req );
773 if (ret)
775 info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
776 info->handle = wine_server_ptr_handle( reply->handle );
777 info->proc = wine_server_get_ptr( reply->proc );
778 info->tid = reply->tid;
781 SERVER_END_REQ;
782 return ret;
785 static inline void find_hook_close(DWORD id)
787 SERVER_START_REQ( finish_hook_chain )
789 req->id = id;
790 wine_server_call( req );
792 SERVER_END_REQ;
795 /***********************************************************************
796 * NotifyWinEvent [USER32.@]
798 * Inform the OS that an event has occurred.
800 * PARAMS
801 * event [I] Id of the event
802 * hwnd [I] Window holding the object that created the event
803 * object_id [I] Type of object that created the event
804 * child_id [I] Child object of nId, or CHILDID_SELF.
806 * RETURNS
807 * Nothing.
809 void WINAPI NotifyWinEvent(DWORD event, HWND hwnd, LONG object_id, LONG child_id)
811 struct hook_info info;
813 TRACE("%04x,%p,%d,%d\n", event, hwnd, object_id, child_id);
815 if (!hwnd)
817 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
818 return;
821 USER_CheckNotLock();
823 #if 0
824 if (event & 0x80000000)
826 /* FIXME: on 64-bit platforms we need to invent some other way for
827 * passing parameters, nId and nChildId can't hold full [W|L]PARAM.
828 * struct call_hook *hook = (LRESULT *)hWnd;
829 * wparam = hook->wparam;
830 * lparam = hook->lparam;
832 LRESULT *ret = (LRESULT *)hwnd;
833 INT id, code, unicode;
835 id = (dwEvent & 0x7fff0000) >> 16;
836 code = event & 0x7fff;
837 unicode = event & 0x8000;
838 *ret = HOOK_CallHooks(id, code, object_id, child_id, unicode);
839 return;
841 #endif
843 if (!find_first_hook(WH_WINEVENT, event, hwnd, object_id, child_id, &info)) return;
847 WINEVENTPROC proc = info.proc;
848 if (proc)
850 TRACE( "calling WH_WINEVENT hook %p event %x hwnd %p %x %x module %s\n",
851 proc, event, hwnd, object_id, child_id, debugstr_w(info.module) );
853 if (!info.module[0] || (proc = get_hook_proc( proc, info.module )) != NULL)
855 if (TRACE_ON(relay))
856 DPRINTF( "%04x:Call winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
857 GetCurrentThreadId(), proc, info.handle, event, hwnd, object_id,
858 child_id, GetCurrentThreadId(), GetCurrentTime());
860 proc( info.handle, event, hwnd, object_id, child_id,
861 GetCurrentThreadId(), GetCurrentTime());
863 if (TRACE_ON(relay))
864 DPRINTF( "%04x:Ret winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
865 GetCurrentThreadId(), proc, info.handle, event, hwnd, object_id,
866 child_id, GetCurrentThreadId(), GetCurrentTime());
869 else
870 break;
872 while (find_next_hook(event, hwnd, object_id, child_id, &info));
874 find_hook_close(WH_WINEVENT);
878 /***********************************************************************
879 * IsWinEventHookInstalled [USER32.@]
881 * Determine if an event hook is installed for an event.
883 * PARAMS
884 * dwEvent [I] Id of the event
886 * RETURNS
887 * TRUE, If there are any hooks installed for the event.
888 * FALSE, Otherwise.
890 * BUGS
891 * Not implemented.
893 BOOL WINAPI IsWinEventHookInstalled(DWORD dwEvent)
895 /* FIXME: Needed by Office 2007 installer */
896 WARN("(%d)-stub!\n", dwEvent);
897 return TRUE;