quartz: Make FileAsyncReader_WaitForNext return an empty sample in flushing state.
[wine] / dlls / user32 / 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     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 = (void *)((char *)proc - (char *)inst);
188             wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
189         }
190         else req->proc = proc;
191
192         if (!wine_server_call_err( req ))
193         {
194             handle = reply->handle;
195             get_user_thread_info()->active_hooks = reply->active_hooks;
196         }
197     }
198     SERVER_END_REQ;
199
200     TRACE( "%s %p %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 (HIWORD(cbtcwA->lpcs->lpszName))
226         {
227             RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszName);
228             csW.lpszName = nameW = usBuffer.Buffer;
229         }
230         if (HIWORD(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 (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;
270         }
271
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;
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 = LoadLibraryW(module))) 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( (HOOKPROC)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  *              HOOK_CallHooks
393  */
394 LRESULT HOOK_CallHooks( INT id, INT code, WPARAM wparam, LPARAM lparam, BOOL unicode )
395 {
396     struct user_thread_info *thread_info = get_user_thread_info();
397     struct hook_info info;
398     DWORD_PTR ret = 0;
399
400     USER_CheckNotLock();
401
402     if (!HOOK_IsHooked( id ))
403     {
404         TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
405         return 0;
406     }
407
408     ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
409     info.prev_unicode = unicode;
410     info.id = id;
411
412     SERVER_START_REQ( start_hook_chain )
413     {
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 ))
418         {
419             info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
420             info.handle       = reply->handle;
421             info.pid          = reply->pid;
422             info.tid          = reply->tid;
423             info.proc         = reply->proc;
424             info.next_unicode = reply->unicode;
425             thread_info->active_hooks = reply->active_hooks;
426         }
427     }
428     SERVER_END_REQ;
429
430     if (!info.tid && !info.proc) return 0;
431     ret = call_hook( &info, code, wparam, lparam );
432
433     SERVER_START_REQ( finish_hook_chain )
434     {
435         req->id = id;
436         wine_server_call( req );
437     }
438     SERVER_END_REQ;
439     return ret;
440 }
441
442
443 /***********************************************************************
444  *           HOOK_IsHooked
445  */
446 BOOL HOOK_IsHooked( INT id )
447 {
448     struct user_thread_info *thread_info = get_user_thread_info();
449
450     if (!thread_info->active_hooks) return TRUE;
451     return (thread_info->active_hooks & (1 << (id - WH_MINHOOK))) != 0;
452 }
453
454
455 /***********************************************************************
456  *              SetWindowsHookA (USER32.@)
457  */
458 HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
459 {
460     return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
461 }
462
463
464 /***********************************************************************
465  *              SetWindowsHookW (USER32.@)
466  */
467 HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
468 {
469     return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
470 }
471
472
473 /***********************************************************************
474  *              SetWindowsHookExA (USER32.@)
475  */
476 HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
477 {
478     return set_windows_hook( id, proc, inst, tid, FALSE );
479 }
480
481 /***********************************************************************
482  *              SetWindowsHookExW (USER32.@)
483  */
484 HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
485 {
486     return set_windows_hook( id, proc, inst, tid, TRUE );
487 }
488
489
490 /***********************************************************************
491  *              UnhookWindowsHook (USER32.@)
492  */
493 BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
494 {
495     BOOL ret;
496
497     TRACE( "%s %p\n", hook_names[id-WH_MINHOOK], proc );
498
499     SERVER_START_REQ( remove_hook )
500     {
501         req->handle = 0;
502         req->id   = id;
503         req->proc = proc;
504         ret = !wine_server_call_err( req );
505         if (ret) get_user_thread_info()->active_hooks = reply->active_hooks;
506     }
507     SERVER_END_REQ;
508     if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
509     return ret;
510 }
511
512
513
514 /***********************************************************************
515  *              UnhookWindowsHookEx (USER32.@)
516  */
517 BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
518 {
519     BOOL ret;
520
521     SERVER_START_REQ( remove_hook )
522     {
523         req->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;
527     }
528     SERVER_END_REQ;
529     if (!ret && GetLastError() == ERROR_INVALID_HANDLE) SetLastError( ERROR_INVALID_HOOK_HANDLE );
530     return ret;
531 }
532
533
534 /***********************************************************************
535  *              CallNextHookEx (USER32.@)
536  */
537 LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
538 {
539     struct user_thread_info *thread_info = get_user_thread_info();
540     struct hook_info info;
541
542     ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
543
544     SERVER_START_REQ( get_hook_info )
545     {
546         req->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 ))
551         {
552             info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
553             info.handle       = reply->handle;
554             info.id           = reply->id;
555             info.pid          = reply->pid;
556             info.tid          = reply->tid;
557             info.proc         = reply->proc;
558             info.next_unicode = reply->unicode;
559         }
560     }
561     SERVER_END_REQ;
562
563     info.prev_unicode = thread_info->hook_unicode;
564     return call_hook( &info, code, wparam, lparam );
565 }
566
567
568 LRESULT call_current_hook( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
569 {
570     struct hook_info info;
571
572     ZeroMemory( &info, sizeof(info) - sizeof(info.module) );
573
574     SERVER_START_REQ( get_hook_info )
575     {
576         req->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 ))
581         {
582             info.module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
583             info.handle       = reply->handle;
584             info.id           = reply->id;
585             info.pid          = reply->pid;
586             info.tid          = reply->tid;
587             info.proc         = reply->proc;
588             info.next_unicode = reply->unicode;
589         }
590     }
591     SERVER_END_REQ;
592
593     info.prev_unicode = TRUE;  /* assume Unicode for this function */
594     return call_hook( &info, code, wparam, lparam );
595 }
596
597 /***********************************************************************
598  *              CallMsgFilterA (USER32.@)
599  */
600 BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
601 {
602     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, FALSE )) return TRUE;
603     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, FALSE );
604 }
605
606
607 /***********************************************************************
608  *              CallMsgFilterW (USER32.@)
609  */
610 BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
611 {
612     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, TRUE )) return TRUE;
613     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, TRUE );
614 }
615
616
617 /***********************************************************************
618  *           SetWinEventHook                            [USER32.@]
619  *
620  * Set up an event hook for a set of events.
621  *
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
630  *
631  * RETURNS
632  *  Success: A handle representing the hook.
633  *  Failure: A NULL handle.
634  */
635 HWINEVENTHOOK WINAPI SetWinEventHook(DWORD event_min, DWORD event_max,
636                                      HMODULE inst, WINEVENTPROC proc,
637                                      DWORD pid, DWORD tid, DWORD flags)
638 {
639     HWINEVENTHOOK handle = 0;
640     WCHAR module[MAX_PATH];
641     DWORD len;
642
643     TRACE("%d,%d,%p,%p,%08x,%04x,%08x\n", event_min, event_max, inst,
644           proc, pid, tid, flags);
645
646     if (inst)
647     {
648         if (!(len = GetModuleFileNameW(inst, module, MAX_PATH)) || len >= MAX_PATH)
649             inst = 0;
650     }
651
652     if ((flags & WINEVENT_INCONTEXT) && !inst)
653     {
654         SetLastError(ERROR_HOOK_NEEDS_HMOD);
655         return 0;
656     }
657
658     if (event_min > event_max)
659     {
660         SetLastError(ERROR_INVALID_HOOK_FILTER);
661         return 0;
662     }
663
664     /* FIXME: what if the tid or pid belongs to another process? */
665     if (tid)  /* thread-local hook */
666         inst = 0;
667
668     SERVER_START_REQ( set_hook )
669     {
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 */
678         {
679             req->proc = (void *)((char *)proc - (char *)inst);
680             wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
681         }
682         else req->proc = proc;
683
684         if (!wine_server_call_err( req ))
685         {
686             handle = reply->handle;
687             get_user_thread_info()->active_hooks = reply->active_hooks;
688         }
689     }
690     SERVER_END_REQ;
691
692     TRACE("-> %p\n", handle);
693     return handle;
694 }
695
696
697 /***********************************************************************
698  *           UnhookWinEvent                             [USER32.@]
699  *
700  * Remove an event hook for a set of events.
701  *
702  * PARAMS
703  *  hEventHook [I] Event hook to remove
704  *
705  * RETURNS
706  *  Success: TRUE. The event hook has been removed.
707  *  Failure: FALSE, if hEventHook is invalid.
708  */
709 BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK hEventHook)
710 {
711     BOOL ret;
712
713     SERVER_START_REQ( remove_hook )
714     {
715         req->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;
719     }
720     SERVER_END_REQ;
721     return ret;
722 }
723
724 static inline BOOL find_first_hook(DWORD id, DWORD event, HWND hwnd, LONG object_id,
725                                    LONG child_id, struct hook_info *info)
726 {
727     struct user_thread_info *thread_info = get_user_thread_info();
728     BOOL ret;
729
730     if (!HOOK_IsHooked( id ))
731     {
732         TRACE( "skipping hook %s mask %x\n", hook_names[id-WH_MINHOOK], thread_info->active_hooks );
733         return FALSE;
734     }
735
736     SERVER_START_REQ( start_hook_chain )
737     {
738         req->id = id;
739         req->event = event;
740         req->window = 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)
746         {
747             info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
748             info->handle    = reply->handle;
749             info->proc      = reply->proc;
750             info->tid       = reply->tid;
751             thread_info->active_hooks = reply->active_hooks;
752         }
753     }
754     SERVER_END_REQ;
755     return ret && (info->tid || info->proc);
756 }
757
758 static inline BOOL find_next_hook(DWORD event, HWND hwnd, LONG object_id,
759                                   LONG child_id, struct hook_info *info)
760 {
761     BOOL ret;
762
763     SERVER_START_REQ( get_hook_info )
764     {
765         req->handle = info->handle;
766         req->get_next = 1;
767         req->event = event;
768         req->window = 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)
774         {
775             info->module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
776             info->handle    = reply->handle;
777             info->proc      = reply->proc;
778             info->tid       = reply->tid;
779         }
780     }
781     SERVER_END_REQ;
782     return ret;
783 }
784
785 static inline void find_hook_close(DWORD id)
786 {
787     SERVER_START_REQ( finish_hook_chain )
788     {
789         req->id = id;
790         wine_server_call( req );
791     }
792     SERVER_END_REQ;
793 }
794
795 /***********************************************************************
796  *           NotifyWinEvent                             [USER32.@]
797  *
798  * Inform the OS that an event has occurred.
799  *
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.
805  *
806  * RETURNS
807  *  Nothing.
808  */
809 void WINAPI NotifyWinEvent(DWORD event, HWND hwnd, LONG object_id, LONG child_id)
810 {
811     struct hook_info info;
812
813     TRACE("%04x,%p,%d,%d\n", event, hwnd, object_id, child_id);
814
815     if (!hwnd)
816     {
817         SetLastError(ERROR_INVALID_WINDOW_HANDLE);
818         return;
819     }
820
821     USER_CheckNotLock();
822
823 #if 0
824     if (event & 0x80000000)
825     {
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;
831          */
832         LRESULT *ret = (LRESULT *)hwnd;
833         INT id, code, unicode;
834
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;
840     }
841 #endif
842
843     if (!find_first_hook(WH_WINEVENT, event, hwnd, object_id, child_id, &info)) return;
844
845     do
846     {
847         if (info.proc)
848         {
849             TRACE( "calling WH_WINEVENT hook %p event %x hwnd %p %x %x module %s\n",
850                    info.proc, event, hwnd, object_id, child_id, debugstr_w(info.module) );
851
852             if (!info.module[0] || (info.proc = get_hook_proc( info.proc, info.module )) != NULL)
853             {
854                 if (TRACE_ON(relay))
855                     DPRINTF( "%04x:Call winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
856                              GetCurrentThreadId(), info.proc, info.handle, event, hwnd, object_id,
857                              child_id, GetCurrentThreadId(), GetCurrentTime());
858
859                 info.proc(info.handle, event, hwnd, object_id, child_id,
860                           GetCurrentThreadId(), GetCurrentTime());
861
862                 if (TRACE_ON(relay))
863                     DPRINTF( "%04x:Ret  winevent hook proc %p (hhook=%p,event=%x,hwnd=%p,object_id=%x,child_id=%x,tid=%04x,time=%x)\n",
864                              GetCurrentThreadId(), info.proc, info.handle, event, hwnd, object_id,
865                              child_id, GetCurrentThreadId(), GetCurrentTime());
866             }
867         }
868         else
869             break;
870     }
871     while (find_next_hook(event, hwnd, object_id, child_id, &info));
872
873     find_hook_close(WH_WINEVENT);
874 }
875
876
877 /***********************************************************************
878  *           IsWinEventHookInstalled                       [USER32.@]
879  *
880  * Determine if an event hook is installed for an event.
881  *
882  * PARAMS
883  *  dwEvent  [I] Id of the event
884  *
885  * RETURNS
886  *  TRUE,  If there are any hooks installed for the event.
887  *  FALSE, Otherwise.
888  *
889  * BUGS
890  *  Not implemented.
891  */
892 BOOL WINAPI IsWinEventHookInstalled(DWORD dwEvent)
893 {
894     FIXME("(%d)-stub!\n", dwEvent);
895     return TRUE;
896 }