2 * Windows hook functions
4 * Copyright 2002 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 * Status of the various hooks:
23 * WH_JOURNALRECORD Partially implemented
24 * WH_JOURNALPLAYBACK Partially implemented
26 * WH_GETMESSAGE OK (FIXME: A/W mapping?)
27 * WH_CALLWNDPROC OK (FIXME: A/W mapping?)
35 * HCBT_CLICKSKIPPED OK
37 * HCBT_SYSCOMMAND Not implemented
41 * WH_HARDWARE Not supported in Win32
42 * WH_DEBUG Not implemented
44 * HSHELL_WINDOWCREATED OK
45 * HSHELL_WINDOWDESTROYED OK
46 * HSHELL_ACTIVATESHELLWINDOW Not implemented
47 * HSHELL_WINDOWACTIVATED Not implemented
48 * HSHELL_GETMINRECT Not implemented
49 * HSHELL_REDRAW Not implemented
50 * HSHELL_TASKMAN Not implemented
51 * HSHELL_LANGUAGE Not implemented
52 * HSHELL_SYSMENU Not implemented
53 * HSHELL_ENDTASK Not implemented
54 * HSHELL_ACCESSIBILITYSTATE Not implemented
55 * HSHELL_APPCOMMAND Not implemented
56 * HSHELL_WINDOWREPLACED Not implemented
57 * HSHELL_WINDOWREPLACING Not implemented
58 * WH_FOREGROUNDIDLE Not implemented
59 * WH_CALLWNDPROCRET OK (FIXME: A/W mapping?)
60 * WH_KEYBOARD_LL Implemented but should use SendMessage instead
61 * WH_MOUSE_LL Implemented but should use SendMessage instead
71 #include "wine/server.h"
72 #include "wine/unicode.h"
73 #include "wine/debug.h"
76 WINE_DEFAULT_DEBUG_CHANNEL(hook
);
77 WINE_DECLARE_DEBUG_CHANNEL(relay
);
79 static const char * const hook_names
[WH_MAXHOOK
- WH_MINHOOK
+ 1] =
100 /***********************************************************************
103 * Implementation of SetWindowsHookExA and SetWindowsHookExW.
105 static HHOOK
set_windows_hook( INT id
, HOOKPROC proc
, HINSTANCE inst
, DWORD tid
, BOOL unicode
)
108 WCHAR module
[MAX_PATH
];
110 if (tid
) /* thread-local hook */
112 if (id
== WH_JOURNALRECORD
||
113 id
== WH_JOURNALPLAYBACK
||
114 id
== WH_KEYBOARD_LL
||
116 id
== WH_SYSMSGFILTER
)
118 /* these can only be global */
119 SetLastError( ERROR_INVALID_PARAMETER
);
124 else /* system-global hook */
126 if (!inst
|| !GetModuleFileNameW( inst
, module
, MAX_PATH
))
128 SetLastError( ERROR_INVALID_PARAMETER
);
133 SERVER_START_REQ( set_hook
)
137 req
->unicode
= unicode
;
138 if (inst
) /* make proc relative to the module base */
140 req
->proc
= (void *)((char *)proc
- (char *)inst
);
141 wine_server_add_data( req
, module
, strlenW(module
) * sizeof(WCHAR
) );
143 else req
->proc
= proc
;
145 if (!wine_server_call_err( req
)) handle
= reply
->handle
;
149 TRACE( "%s %p %lx -> %p\n", hook_names
[id
-WH_MINHOOK
], proc
, tid
, handle
);
154 /***********************************************************************
157 static LRESULT
call_hook_AtoW( HOOKPROC proc
, INT id
, INT code
, WPARAM wparam
, LPARAM lparam
)
160 UNICODE_STRING usBuffer
;
161 if (id
!= WH_CBT
|| code
!= HCBT_CREATEWND
) ret
= proc( code
, wparam
, lparam
);
164 CBT_CREATEWNDA
*cbtcwA
= (CBT_CREATEWNDA
*)lparam
;
165 CBT_CREATEWNDW cbtcwW
;
169 cbtcwW
.hwndInsertAfter
= cbtcwA
->hwndInsertAfter
;
170 csW
= *(CREATESTRUCTW
*)cbtcwA
->lpcs
;
172 if (HIWORD(cbtcwA
->lpcs
->lpszName
))
174 RtlCreateUnicodeStringFromAsciiz(&usBuffer
,cbtcwA
->lpcs
->lpszName
);
175 csW
.lpszName
= usBuffer
.Buffer
;
177 if (HIWORD(cbtcwA
->lpcs
->lpszClass
))
179 RtlCreateUnicodeStringFromAsciiz(&usBuffer
,cbtcwA
->lpcs
->lpszName
);
180 csW
.lpszClass
= usBuffer
.Buffer
;
182 ret
= proc( code
, wparam
, (LPARAM
)&cbtcwW
);
183 cbtcwA
->hwndInsertAfter
= cbtcwW
.hwndInsertAfter
;
184 if (HIWORD(csW
.lpszName
)) HeapFree( GetProcessHeap(), 0, (LPWSTR
)csW
.lpszName
);
185 if (HIWORD(csW
.lpszClass
)) HeapFree( GetProcessHeap(), 0, (LPWSTR
)csW
.lpszClass
);
191 /***********************************************************************
194 static LRESULT
call_hook_WtoA( HOOKPROC proc
, INT id
, INT code
, WPARAM wparam
, LPARAM lparam
)
198 if (id
!= WH_CBT
|| code
!= HCBT_CREATEWND
) ret
= proc( code
, wparam
, lparam
);
201 CBT_CREATEWNDW
*cbtcwW
= (CBT_CREATEWNDW
*)lparam
;
202 CBT_CREATEWNDA cbtcwA
;
206 cbtcwA
.hwndInsertAfter
= cbtcwW
->hwndInsertAfter
;
207 csA
= *(CREATESTRUCTA
*)cbtcwW
->lpcs
;
209 if (HIWORD(cbtcwW
->lpcs
->lpszName
))
210 csA
.lpszName
= HEAP_strdupWtoA( GetProcessHeap(), 0, cbtcwW
->lpcs
->lpszName
);
211 if (HIWORD(cbtcwW
->lpcs
->lpszClass
))
212 csA
.lpszClass
= HEAP_strdupWtoA( GetProcessHeap(), 0, cbtcwW
->lpcs
->lpszClass
);
213 ret
= proc( code
, wparam
, (LPARAM
)&cbtcwA
);
214 cbtcwW
->hwndInsertAfter
= cbtcwA
.hwndInsertAfter
;
215 if (HIWORD(csA
.lpszName
)) HeapFree( GetProcessHeap(), 0, (LPSTR
)csA
.lpszName
);
216 if (HIWORD(csA
.lpszClass
)) HeapFree( GetProcessHeap(), 0, (LPSTR
)csA
.lpszClass
);
222 /***********************************************************************
225 static LRESULT
call_hook( HOOKPROC proc
, INT id
, INT code
, WPARAM wparam
, LPARAM lparam
,
226 BOOL prev_unicode
, BOOL next_unicode
)
231 DPRINTF( "%04lx:Call hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx)\n",
232 GetCurrentThreadId(), proc
, hook_names
[id
-WH_MINHOOK
], code
, wparam
, lparam
);
234 if (!prev_unicode
== !next_unicode
) ret
= proc( code
, wparam
, lparam
);
235 else if (prev_unicode
) ret
= call_hook_WtoA( proc
, id
, code
, wparam
, lparam
);
236 else ret
= call_hook_AtoW( proc
, id
, code
, wparam
, lparam
);
239 DPRINTF( "%04lx:Ret hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx) retval=%08lx\n",
240 GetCurrentThreadId(), proc
, hook_names
[id
-WH_MINHOOK
], code
, wparam
, lparam
, ret
);
246 /***********************************************************************
249 * Retrieve the hook procedure real value for a module-relative proc
251 static HOOKPROC
get_hook_proc( HOOKPROC proc
, const WCHAR
*module
)
255 if (!(mod
= GetModuleHandleW(module
)))
257 TRACE( "loading %s\n", debugstr_w(module
) );
258 /* FIXME: the library will never be freed */
259 if (!(mod
= LoadLibraryW(module
))) return NULL
;
261 return (HOOKPROC
)((char *)mod
+ (ULONG_PTR
)proc
);
265 /***********************************************************************
268 LRESULT
HOOK_CallHooks( INT id
, INT code
, WPARAM wparam
, LPARAM lparam
, BOOL unicode
)
270 MESSAGEQUEUE
*queue
= QUEUE_Current();
271 HOOKPROC proc
= NULL
;
273 WCHAR module
[MAX_PATH
];
274 BOOL unicode_hook
= FALSE
;
277 if (!queue
) return 0;
279 SERVER_START_REQ( start_hook_chain
)
282 wine_server_set_reply( req
, module
, sizeof(module
)-sizeof(WCHAR
) );
283 if (!wine_server_call_err( req
))
285 module
[wine_server_reply_size(req
) / sizeof(WCHAR
)] = 0;
286 queue
->hook
= reply
->handle
;
288 unicode_hook
= reply
->unicode
;
295 TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
296 proc
, hook_names
[id
-WH_MINHOOK
], code
, wparam
, lparam
, debugstr_w(module
) );
298 if (!module
[0] || (proc
= get_hook_proc( proc
, module
)) != NULL
)
300 int locks
= WIN_SuspendWndsLock();
301 ret
= call_hook( proc
, id
, code
, wparam
, lparam
, unicode
, unicode_hook
);
302 WIN_RestoreWndsLock( locks
);
305 SERVER_START_REQ( finish_hook_chain
)
308 wine_server_call( req
);
318 /***********************************************************************
321 BOOL
HOOK_IsHooked( INT id
)
323 return TRUE
; /* FIXME */
327 /***********************************************************************
328 * SetWindowsHookA (USER32.@)
330 HHOOK WINAPI
SetWindowsHookA( INT id
, HOOKPROC proc
)
332 return SetWindowsHookExA( id
, proc
, 0, GetCurrentThreadId() );
336 /***********************************************************************
337 * SetWindowsHookW (USER32.@)
339 HHOOK WINAPI
SetWindowsHookW( INT id
, HOOKPROC proc
)
341 return SetWindowsHookExW( id
, proc
, 0, GetCurrentThreadId() );
345 /***********************************************************************
346 * SetWindowsHookExA (USER32.@)
348 HHOOK WINAPI
SetWindowsHookExA( INT id
, HOOKPROC proc
, HINSTANCE inst
, DWORD tid
)
350 return set_windows_hook( id
, proc
, inst
, tid
, FALSE
);
353 /***********************************************************************
354 * SetWindowsHookExW (USER32.@)
356 HHOOK WINAPI
SetWindowsHookExW( INT id
, HOOKPROC proc
, HINSTANCE inst
, DWORD tid
)
358 return set_windows_hook( id
, proc
, inst
, tid
, TRUE
);
362 /***********************************************************************
363 * UnhookWindowsHook (USER32.@)
365 BOOL WINAPI
UnhookWindowsHook( INT id
, HOOKPROC proc
)
369 TRACE( "%s %p\n", hook_names
[id
-WH_MINHOOK
], proc
);
371 SERVER_START_REQ( remove_hook
)
376 ret
= !wine_server_call_err( req
);
384 /***********************************************************************
385 * UnhookWindowsHookEx (USER32.@)
387 BOOL WINAPI
UnhookWindowsHookEx( HHOOK hhook
)
391 TRACE( "%p\n", hhook
);
393 SERVER_START_REQ( remove_hook
)
396 ret
= !wine_server_call_err( req
);
403 /***********************************************************************
404 * CallNextHookEx (USER32.@)
406 LRESULT WINAPI
CallNextHookEx( HHOOK hhook
, INT code
, WPARAM wparam
, LPARAM lparam
)
408 MESSAGEQUEUE
*queue
= QUEUE_Current();
410 WCHAR module
[MAX_PATH
];
411 HOOKPROC proc
= NULL
;
413 BOOL prev_unicode
= FALSE
, next_unicode
= FALSE
;
416 if (!queue
) return 0;
418 SERVER_START_REQ( get_next_hook
)
421 wine_server_set_reply( req
, module
, sizeof(module
)-sizeof(WCHAR
) );
422 if (!wine_server_call_err( req
))
424 module
[wine_server_reply_size(req
) / sizeof(WCHAR
)] = 0;
425 queue
->hook
= reply
->next
;
428 prev_unicode
= reply
->prev_unicode
;
429 next_unicode
= reply
->next_unicode
;
436 TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
437 proc
, hook_names
[id
-WH_MINHOOK
], code
, wparam
, lparam
, debugstr_w(module
) );
439 if (!module
[0] || (proc
= get_hook_proc( proc
, module
)) != NULL
)
440 return call_hook( proc
, id
, code
, wparam
, lparam
, prev_unicode
, next_unicode
);
447 /***********************************************************************
448 * CallMsgFilterA (USER32.@)
450 BOOL WINAPI
CallMsgFilterA( LPMSG msg
, INT code
)
452 if (HOOK_CallHooks( WH_SYSMSGFILTER
, code
, 0, (LPARAM
)msg
, FALSE
)) return TRUE
;
453 return HOOK_CallHooks( WH_MSGFILTER
, code
, 0, (LPARAM
)msg
, FALSE
);
457 /***********************************************************************
458 * CallMsgFilterW (USER32.@)
460 BOOL WINAPI
CallMsgFilterW( LPMSG msg
, INT code
)
462 if (HOOK_CallHooks( WH_SYSMSGFILTER
, code
, 0, (LPARAM
)msg
, TRUE
)) return TRUE
;
463 return HOOK_CallHooks( WH_MSGFILTER
, code
, 0, (LPARAM
)msg
, TRUE
);
467 /***********************************************************************
468 * SetWinEventHook [USER32.@]
470 * Set up an event hook for a set of events.
473 * dwMin [I] Lowest event handled by pfnProc
474 * dwMax [I] Highest event handled by pfnProc
475 * hModule [I] DLL containing pfnProc
476 * pfnProc [I] Callback event hook function
477 * dwProcess [I] Process to get events from, or 0 for all processes
478 * dwThread [I] Thread to get events from, or 0 for all threads
479 * dwFlags [I] Flags indicating the status of pfnProc
482 * Success: A handle representing the hook.
483 * Failure: A NULL handle.
488 HWINEVENTHOOK WINAPI
SetWinEventHook(DWORD dwMin
, DWORD dwMax
, HMODULE hModule
,
489 WINEVENTPROC pfnProc
, DWORD dwProcess
,
490 DWORD dwThread
, DWORD dwFlags
)
492 FIXME("(%ld,%ld,%p,%p,%ld,%ld,0x%08lx)-stub!\n", dwMin
, dwMax
, hModule
,
493 pfnProc
, dwProcess
, dwThread
, dwFlags
);
498 /***********************************************************************
499 * UnhookWinEvent [USER32.@]
501 * Remove an event hook for a set of events.
504 * hEventHook [I] Event hook to remove
507 * Success: TRUE. The event hook has been removed.
508 * Failure: FALSE, if hEventHook is invalid.
513 BOOL WINAPI
UnhookWinEvent(HWINEVENTHOOK hEventHook
)
515 FIXME("(%p)-stub!\n", hEventHook
);
517 return (hEventHook
!= 0);
521 /***********************************************************************
522 * NotifyWinEvent [USER32.@]
524 * Inform the OS that an event has occurred.
527 * dwEvent [I] Id of the event
528 * hWnd [I] Window holding the object that created the event
529 * nId [I] Type of object that created the event
530 * nChildId [I] Child object of nId, or CHILDID_SELF.
538 void WINAPI
NotifyWinEvent(DWORD dwEvent
, HWND hWnd
, LONG nId
, LONG nChildId
)
540 FIXME("(%ld,%p,%ld,%ld)-stub!\n", dwEvent
, hWnd
, nId
, nChildId
);
544 /***********************************************************************
545 * IsWinEventHookInstalled [USER32.@]
547 * Determine if an event hook is installed for an event.
550 * dwEvent [I] Id of the event
553 * TRUE, If there are any hooks installed for the event.
559 BOOL WINAPI
IsWinEventHookInstalled(DWORD dwEvent
)
561 FIXME("(%ld)-stub!\n", dwEvent
);