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 void *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 if (tid) /* thread-local hook */
148 {
149 if (id == WH_JOURNALRECORD ||
150 id == WH_JOURNALPLAYBACK ||
151 id == WH_KEYBOARD_LL ||
152 id == WH_MOUSE_LL ||
153 id == WH_SYSMSGFILTER)
154 {
155 /* these can only be global */
156 SetLastError( ERROR_INVALID_PARAMETER );
157 return 0;
158 }
159 }
160 else /* system-global hook */
161 {
162 if (id == WH_KEYBOARD_LL || id == WH_MOUSE_LL) inst = 0;
163 else if (!inst)
164 {
165 SetLastError( ERROR_HOOK_NEEDS_HMOD );
166 return 0;
167 }
168 }
169
170 if (inst && (!(len = GetModuleFileNameW( inst, module, MAX_PATH )) || len >= MAX_PATH))
171 {
172 SetLastError( ERROR_INVALID_PARAMETER );
173 return 0;
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 = wine_server_client_ptr( (void *)((char *)proc - (char *)inst) );
188 wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
189 }
190 else req->proc = wine_server_client_ptr( proc );
191
192 if (!wine_server_call_err( req ))
193 {
194 handle = wine_server_ptr_handle( reply->handle );
195 get_user_thread_info()->active_hooks = reply->active_hooks;
196 }
197 }
198 SERVER_END_REQ;
199
200 TRACE( "%s %p %x -> %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 LPWSTR nameW = NULL;
219 LPWSTR classW = NULL;
220
221 cbtcwW.lpcs = &csW;
222 cbtcwW.hwndInsertAfter = cbtcwA->hwndInsertAfter;
223 csW = *(CREATESTRUCTW *)cbtcwA->lpcs;
224
225 if (!IS_INTRESOURCE(cbtcwA->lpcs->lpszName))
226 {
227 RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszName);
228 csW.lpszName = nameW = usBuffer.Buffer;
229 }
230 if (!IS_INTRESOURCE(cbtcwA->lpcs->lpszClass))
231 {
232 RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszClass);
233 csW.lpszClass = classW = usBuffer.Buffer;
234 }
235 ret = proc( code, wparam, (LPARAM)&cbtcwW );
236 cbtcwA->hwndInsertAfter = cbtcwW.hwndInsertAfter;
237 HeapFree( GetProcessHeap(), 0, nameW );
238 HeapFree( GetProcessHeap(), 0, classW );
239 }
240 return ret;
241 }
242
243
244 /***********************************************************************
245 * call_hook_WtoA
246 */
247 static LRESULT call_hook_WtoA( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
248 {
249 LRESULT ret;
250
251 if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
252 else
253 {
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;
260
261 cbtcwA.lpcs = &csA;
262 cbtcwA.hwndInsertAfter = cbtcwW->hwndInsertAfter;
263 csA = *(CREATESTRUCTA *)cbtcwW->lpcs;
264
265 if (!IS_INTRESOURCE(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;
270 }
271
272 if (!IS_INTRESOURCE(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;
277 }
278
279 ret = proc( code, wparam, (LPARAM)&cbtcwA );
280 cbtcwW->hwndInsertAfter = cbtcwA.hwndInsertAfter;
281 HeapFree( GetProcessHeap(), 0, nameA );
282 HeapFree( GetProcessHeap(), 0, classA );
283 }
284 return ret;
285 }
286
287
288 /***********************************************************************
289 * call_hook_proc
290 */
291 static LRESULT call_hook_proc( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
292 BOOL prev_unicode, BOOL next_unicode )
293 {
294 LRESULT ret;
295
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 );
299
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 );
303
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 );
307
308 return ret;
309 }
310
311
312 /***********************************************************************
313 * get_hook_proc
314 *
315 * Retrieve the hook procedure real value for a module-relative proc
316 */
317 void *get_hook_proc( void *proc, const WCHAR *module )
318 {
319 HMODULE mod;
320
321 if (!(mod = GetModuleHandleW(module)))
322 {
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;
326 }
327 return (char *)mod + (ULONG_PTR)proc;
328 }
329
330 /***********************************************************************
331 * call_hook
332 *
333 * Call hook either in current thread or send message to the destination
334 * thread.
335 */
336 static LRESULT call_hook( struct hook_info *info, INT code, WPARAM wparam, LPARAM lparam )
337 {
338 DWORD_PTR ret = 0;
339
340 if (info->tid)
341 {
342 struct hook_extra_info h_extra;
343 h_extra.handle = info->handle;
344 h_extra.lparam = lparam;
345
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 );
348
349 switch(info->id)
350 {
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;
365 }
366 }
367 else if (info->proc)
368 {
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) );
372
373 if (!info->module[0] ||
374 (info->proc = get_hook_proc( info->proc, info->module )) != NULL)
375 {
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;
379
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;
386 }
387 }
388 return ret;
389 }
390
391
392 /***********************************************************************
393 * HOOK_IsHooked
394 */
395 static BOOL HOOK_IsHooked( INT id )
396 {
397 struct user_thread_info *thread_info = get_user_thread_info();
398
399 if (!thread_info->active_hooks) return TRUE;
400 return (thread_info->active_hooks & (1 << (id - WH_MINHOOK))) != 0;
401 }
402
403
404 /***********************************************************************
405 * HOOK_CallHooks
406 */
407 LRESULT HOOK_CallHooks( INT id, INT code, WPARAM wparam, LPARAM lparam, BOOL unicode )
408 {
409 struct user_thread_info *thread_info = get_user_thread_info();
410 struct hook_info info;
411 DWORD_PTR ret = 0;
412
413 USER_CheckNotLock();
414
415 if (!HOOK_IsHooked( id ))
416 {
417 TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
418 return 0;
419 }
420
421 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
422 info.prev_unicode = unicode;
423 info.id = id;
424
425 SERVER_START_REQ( start_hook_chain )
426 {
427 req->id = info.id;
428 req->event = EVENT_MIN;
429 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
430 if (!wine_server_call( req ))
431 {
432 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
433 info.handle = wine_server_ptr_handle( reply->handle );
434 info.pid = reply->pid;
435 info.tid = reply->tid;
436 info.proc = wine_server_get_ptr( reply->proc );
437 info.next_unicode = reply->unicode;
438 thread_info->active_hooks = reply->active_hooks;
439 }
440 }
441 SERVER_END_REQ;
442
443 if (!info.tid && !info.proc) return 0;
444 ret = call_hook( &info, code, wparam, lparam );
445
446 SERVER_START_REQ( finish_hook_chain )
447 {
448 req->id = id;
449 wine_server_call( req );
450 }
451 SERVER_END_REQ;
452 return ret;
453 }
454
455
456 /***********************************************************************
457 * SetWindowsHookA (USER32.@)
458 */
459 HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
460 {
461 return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
462 }
463
464
465 /***********************************************************************
466 * SetWindowsHookW (USER32.@)
467 */
468 HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
469 {
470 return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
471 }
472
473
474 /***********************************************************************
475 * SetWindowsHookExA (USER32.@)
476 */
477 HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
478 {
479 return set_windows_hook( id, proc, inst, tid, FALSE );
480 }
481
482 /***********************************************************************
483 * SetWindowsHookExW (USER32.@)
484 */
485 HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
486 {
487 return set_windows_hook( id, proc, inst, tid, TRUE );
488 }
489
490
491 /***********************************************************************
492 * UnhookWindowsHook (USER32.@)
493 */
494 BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
495 {
496 BOOL ret;
497
498 TRACE( "%s %p\n", hook_names[id-WH_MINHOOK], proc );
499
500 SERVER_START_REQ( remove_hook )
501 {
502 req->handle = 0;
503 req->id = id;
504 req->proc = wine_server_client_ptr( proc );
505 ret = !wine_server_call_err( req );
506 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
507 }
508 SERVER_END_REQ;
509 if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
510 return ret;
511 }
512
513
514
515 /***********************************************************************
516 * UnhookWindowsHookEx (USER32.@)
517 */
518 BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
519 {
520 BOOL ret;
521
522 SERVER_START_REQ( remove_hook )
523 {
524 req->handle = wine_server_user_handle( hhook );
525 req->id = 0;
526 ret = !wine_server_call_err( req );
527 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
528 }
529 SERVER_END_REQ;
530 if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
531 return ret;
532 }
533
534
535 /***********************************************************************
536 * CallNextHookEx (USER32.@)
537 */
538 LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
539 {
540 struct user_thread_info *thread_info = get_user_thread_info();
541 struct hook_info info;
542
543 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
544
545 SERVER_START_REQ( get_hook_info )
546 {
547 req->handle = wine_server_user_handle( thread_info->hook );
548 req->get_next = 1;
549 req->event = EVENT_MIN;
550 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
551 if (!wine_server_call_err( req ))
552 {
553 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
554 info.handle = wine_server_ptr_handle( reply->handle );
555 info.id = reply->id;
556 info.pid = reply->pid;
557 info.tid = reply->tid;
558 info.proc = wine_server_get_ptr( reply->proc );
559 info.next_unicode = reply->unicode;
560 }
561 }
562 SERVER_END_REQ;
563
564 info.prev_unicode = thread_info->hook_unicode;
565 return call_hook( &info, code, wparam, lparam );
566 }
567
568
569 LRESULT call_current_hook( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
570 {
571 struct hook_info info;
572
573 ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
574
575 SERVER_START_REQ( get_hook_info )
576 {
577 req->handle = wine_server_user_handle( hhook );
578 req->get_next = 0;
579 req->event = EVENT_MIN;
580 wine_server_set_reply( req, info.module, sizeof(info.module)-sizeof(WCHAR) );
581 if (!wine_server_call_err( req ))
582 {
583 info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
584 info.handle = wine_server_ptr_handle( reply->handle );
585 info.id = reply->id;
586 info.pid = reply->pid;
587 info.tid = reply->tid;
588 info.proc = wine_server_get_ptr( reply->proc );
589 info.next_unicode = reply->unicode;
590 }
591 }
592 SERVER_END_REQ;
593
594 info.prev_unicode = TRUE; /* assume Unicode for this function */
595 return call_hook( &info, code, wparam, lparam );
596 }
597
598 /***********************************************************************
599 * CallMsgFilterA (USER32.@)
600 */
601 BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
602 {
603 if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, FALSE )) return TRUE;
604 return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, FALSE );
605 }
606
607
608 /***********************************************************************
609 * CallMsgFilterW (USER32.@)
610 */
611 BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
612 {
613 if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, TRUE )) return TRUE;
614 return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, TRUE );
615 }
616
617
618 /***********************************************************************
619 * SetWinEventHook [USER32.@]
620 *
621 * Set up an event hook for a set of events.
622 *
623 * PARAMS
624 * event_min [I] Lowest event handled by pfnProc
625 * event_max [I] Highest event handled by pfnProc
626 * inst [I] DLL containing pfnProc
627 * proc [I] Callback event hook function
628 * pid [I] Process to get events from, or 0 for all processes
629 * tid [I] Thread to get events from, or 0 for all threads
630 * flags [I] Flags indicating the status of pfnProc
631 *
632 * RETURNS
633 * Success: A handle representing the hook.
634 * Failure: A NULL handle.
635 */
636 HWINEVENTHOOK WINAPI SetWinEventHook(DWORD event_min, DWORD event_max,
637 HMODULE inst, WINEVENTPROC proc,
638 DWORD pid, DWORD tid, DWORD flags)
639 {
640 HWINEVENTHOOK handle = 0;
641 WCHAR module[MAX_PATH];
642 DWORD len;
643
644 TRACE("%d,%d,%p,%p,%08x,%04x,%08x\n", event_min, event_max, inst,
645 proc, pid, tid, flags);
646
647 if (inst)
648 {
649 if (!(len = GetModuleFileNameW(inst, module, MAX_PATH)) || len >= MAX_PATH)
650 inst = 0;
651 }
652
653 if ((flags & WINEVENT_INCONTEXT) && !inst)
654 {
655 SetLastError(ERROR_HOOK_NEEDS_HMOD);
656 return 0;
657 }
658
659 if (event_min > event_max)
660 {
661 SetLastError(ERROR_INVALID_HOOK_FILTER);
662 return 0;
663 }
664
665 /* FIXME: what if the tid or pid belongs to another process? */
666 if (tid) /* thread-local hook */
667 inst = 0;
668
669 SERVER_START_REQ( set_hook )
670 {
671 req->id = WH_WINEVENT;
672 req->pid = pid;
673 req->tid = tid;
674 req->event_min = event_min;
675 req->event_max = event_max;
676 req->flags = flags;
677 req->unicode = 1;
678 if (inst) /* make proc relative to the module base */
679 {
680 req->proc = wine_server_client_ptr( (void *)((char *)proc - (char *)inst) );
681 wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
682 }
683 else req->proc = wine_server_client_ptr( proc );
684
685 if (!wine_server_call_err( req ))
686 {
687 handle = wine_server_ptr_handle( reply->handle );
688 get_user_thread_info()->active_hooks = reply->active_hooks;
689 }
690 }
691 SERVER_END_REQ;
692
693 TRACE("-> %p\n", handle);
694 return handle;
695 }
696
697
698 /***********************************************************************
699 * UnhookWinEvent [USER32.@]
700 *
701 * Remove an event hook for a set of events.
702 *
703 * PARAMS
704 * hEventHook [I] Event hook to remove
705 *
706 * RETURNS
707 * Success: TRUE. The event hook has been removed.
708 * Failure: FALSE, if hEventHook is invalid.
709 */
710 BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK hEventHook)
711 {
712 BOOL ret;
713
714 SERVER_START_REQ( remove_hook )
715 {
716 req->handle = wine_server_user_handle( hEventHook );
717 req->id = WH_WINEVENT;
718 ret = !wine_server_call_err( req );
719 if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
720 }
721 SERVER_END_REQ;
722 return ret;
723 }
724
725 static inline BOOL find_first_hook(DWORD id, DWORD event, HWND hwnd, LONG object_id,
726 LONG child_id, struct hook_info *info)
727 {
728 struct user_thread_info *thread_info = get_user_thread_info();
729 BOOL ret;
730
731 if (!HOOK_IsHooked( id ))
732 {
733 TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
734 return FALSE;
735 }
736
737 SERVER_START_REQ( start_hook_chain )
738 {
739 req->id = id;
740 req->event = event;
741 req->window = wine_server_user_handle( hwnd );
742 req->object_id = object_id;
743 req->child_id = child_id;
744 wine_server_set_reply( req, info->module, sizeof(info->module)-sizeof(WCHAR) );
745 ret = !wine_server_call( req );
746 if (ret)
747 {
748 info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
749 info->handle = wine_server_ptr_handle( reply->handle );
750 info->proc = wine_server_get_ptr( reply->proc );
751 info->tid = reply->tid;
752 thread_info->active_hooks = reply->active_hooks;
753 }
754 }
755 SERVER_END_REQ;
756 return ret && (info->tid || info->proc);
757 }
758
759 static inline BOOL find_next_hook(DWORD event, HWND hwnd, LONG object_id,
760 LONG child_id, struct hook_info *info)
761 {
762 BOOL ret;
763
764 SERVER_START_REQ( get_hook_info )
765 {
766 req->handle = wine_server_user_handle( info->handle );
767 req->get_next = 1;
768 req->event = event;
769 req->window = wine_server_user_handle( hwnd );
770 req->object_id = object_id;
771 req->child_id = child_id;
772 wine_server_set_reply( req, info->module, sizeof(info->module)-sizeof(WCHAR) );
773 ret = !wine_server_call( req );
774 if (ret)
775 {
776 info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
777 info->handle = wine_server_ptr_handle( reply->handle );
778 info->proc = wine_server_get_ptr( reply->proc );
779 info->tid = reply->tid;
780 }
781 }
782 SERVER_END_REQ;
783 return ret;
784 }
785
786 static inline void find_hook_close(DWORD id)
787 {
788 SERVER_START_REQ( finish_hook_chain )
789 {
790 req->id = id;
791 wine_server_call( req );
792 }
793 SERVER_END_REQ;
794 }
795
796 /***********************************************************************
797 * NotifyWinEvent [USER32.@]
798 *
799 * Inform the OS that an event has occurred.
800 *
801 * PARAMS
802 * event [I] Id of the event
803 * hwnd [I] Window holding the object that created the event
804 * object_id [I] Type of object that created the event
805 * child_id [I] Child object of nId, or CHILDID_SELF.
806 *
807 * RETURNS
808 * Nothing.
809 */
810 void WINAPI NotifyWinEvent(DWORD event, HWND hwnd, LONG object_id, LONG child_id)
811 {
812 struct hook_info info;
813
814 TRACE("%04x,%p,%d,%d\n", event, hwnd, object_id, child_id);
815
816 if (!hwnd)
817 {
818 SetLastError(ERROR_INVALID_WINDOW_HANDLE);
819 return;
820 }
821
822 USER_CheckNotLock();
823
824 #if 0
825 if (event & 0x80000000)
826 {
827 /* FIXME: on 64-bit platforms we need to invent some other way for
828 * passing parameters, nId and nChildId can't hold full [W|L]PARAM.
829 * struct call_hook *hook = (LRESULT *)hWnd;
830 * wparam = hook->wparam;
831 * lparam = hook->lparam;
832 */
833 LRESULT *ret = (LRESULT *)hwnd;
834 INT id, code, unicode;
835
836 id = (dwEvent & 0x7fff0000) >> 16;
837 code = event & 0x7fff;
838 unicode = event & 0x8000;
839 *ret = HOOK_CallHooks(id, code, object_id, child_id, unicode);
840 return;
841 }
842 #endif
843
844 if (!find_first_hook(WH_WINEVENT, event, hwnd, object_id, child_id, &info)) return;
845
846 do
847 {
848 WINEVENTPROC proc = info.proc;
849 if (proc)
850 {
851 TRACE( "calling WH_WINEVENT hook %p event %x hwnd %p %x %x module %s\n",
852 proc, event, hwnd, object_id, child_id, debugstr_w(info.module) );
853
854 if (!info.module[0] || (proc = get_hook_proc( proc, info.module )) != NULL)
855 {
856 if (TRACE_ON(relay))
857 DPRINTF( "%04x:Call winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
858 GetCurrentThreadId(), proc, info.handle, event, hwnd, object_id,
859 child_id, GetCurrentThreadId(), GetCurrentTime());
860
861 proc( info.handle, event, hwnd, object_id, child_id,
862 GetCurrentThreadId(), GetCurrentTime());
863
864 if (TRACE_ON(relay))
865 DPRINTF( "%04x:Ret winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
866 GetCurrentThreadId(), proc, info.handle, event, hwnd, object_id,
867 child_id, GetCurrentThreadId(), GetCurrentTime());
868 }
869 }
870 else
871 break;
872 }
873 while (find_next_hook(event, hwnd, object_id, child_id, &info));
874
875 find_hook_close(WH_WINEVENT);
876 }
877
878
879 /***********************************************************************
880 * IsWinEventHookInstalled [USER32.@]
881 *
882 * Determine if an event hook is installed for an event.
883 *
884 * PARAMS
885 * dwEvent [I] Id of the event
886 *
887 * RETURNS
888 * TRUE, If there are any hooks installed for the event.
889 * FALSE, Otherwise.
890 *
891 * BUGS
892 * Not implemented.
893 */
894 BOOL WINAPI IsWinEventHookInstalled(DWORD dwEvent)
895 {
896 /* FIXME: Needed by Office 2007 installer */
897 WARN("(%d)-stub!\n", dwEvent);
898 return TRUE;
899 }
900
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.