2 * Server-side window hooks support
4 * Copyright (C) 2002 Alexandre Julliard
5 * Copyright (C) 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 #include "wine/port.h"
42 struct list chain; /* hook chain entry */
43 user_handle_t handle; /* user handle for this hook */
44 struct process *process; /* process the hook is set to */
45 struct thread *thread; /* thread the hook is set to */
46 struct thread *owner; /* owner of the out of context hook */
47 struct hook_table *table; /* hook table that contains this hook */
48 int index; /* hook table index */
52 void *proc; /* hook function */
53 int unicode; /* is it a unicode hook? */
54 WCHAR *module; /* module name for global hooks */
58 #define WH_WINEVENT (WH_MAXHOOK+1)
60 #define NB_HOOKS (WH_WINEVENT-WH_MINHOOK+1)
61 #define HOOK_ENTRY(p) LIST_ENTRY( (p), struct hook, chain )
65 struct object obj; /* object header */
66 struct list hooks[NB_HOOKS]; /* array of hook chains */
67 int counts[NB_HOOKS]; /* use counts for each hook chain */
70 static void hook_table_dump( struct object *obj, int verbose );
71 static void hook_table_destroy( struct object *obj );
73 static const struct object_ops hook_table_ops =
75 sizeof(struct hook_table), /* size */
76 hook_table_dump, /* dump */
77 no_add_queue, /* add_queue */
78 NULL, /* remove_queue */
81 no_signal, /* signal */
82 no_get_fd, /* get_fd */
83 no_close_handle, /* close_handle */
84 hook_table_destroy /* destroy */
88 /* create a new hook table */
89 static struct hook_table *alloc_hook_table(void)
91 struct hook_table *table;
94 if ((table = alloc_object( &hook_table_ops )))
96 for (i = 0; i < NB_HOOKS; i++)
98 list_init( &table->hooks[i] );
105 static struct hook_table *get_global_hooks( struct thread *thread )
107 struct hook_table *table;
108 struct desktop *desktop = get_thread_desktop( thread, 0 );
110 if (!desktop) return NULL;
111 table = desktop->global_hooks;
112 release_object( desktop );
116 /* create a new hook and add it to the specified table */
117 static struct hook *add_hook( struct desktop *desktop, struct thread *thread, int index, int global )
120 struct hook_table *table = global ? desktop->global_hooks : get_queue_hooks(thread);
124 if (!(table = alloc_hook_table())) return NULL;
125 if (global) desktop->global_hooks = table;
126 else set_queue_hooks( thread, table );
128 if (!(hook = mem_alloc( sizeof(*hook) ))) return NULL;
130 if (!(hook->handle = alloc_user_handle( hook, USER_HOOK )))
135 hook->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
138 list_add_head( &table->hooks[index], &hook->chain );
139 if (thread) thread->desktop_users++;
143 /* free a hook, removing it from its chain */
144 static void free_hook( struct hook *hook )
146 free_user_handle( hook->handle );
147 if (hook->module) free( hook->module );
150 assert( hook->thread->desktop_users > 0 );
151 hook->thread->desktop_users--;
152 release_object( hook->thread );
154 if (hook->process) release_object( hook->process );
155 release_object( hook->owner );
156 list_remove( &hook->chain );
160 /* find a hook from its index and proc */
161 static struct hook *find_hook( struct thread *thread, int index, void *proc )
164 struct hook_table *table = get_queue_hooks( thread );
168 LIST_FOR_EACH( p, &table->hooks[index] )
170 struct hook *hook = HOOK_ENTRY( p );
171 if (hook->proc == proc) return hook;
177 /* get the first hook in the chain */
178 inline static struct hook *get_first_hook( struct hook_table *table, int index )
180 struct list *elem = list_head( &table->hooks[index] );
181 return elem ? HOOK_ENTRY( elem ) : NULL;
184 /* check if a given hook should run in the current thread */
185 inline static int run_hook_in_current_thread( struct hook *hook )
187 if ((!hook->process || hook->process == current->process) &&
188 (!(hook->flags & WINEVENT_SKIPOWNPROCESS) || hook->process != current->process))
190 if ((!hook->thread || hook->thread == current) &&
191 (!(hook->flags & WINEVENT_SKIPOWNTHREAD) || hook->thread != current))
197 /* find the first non-deleted hook in the chain */
198 inline static struct hook *get_first_valid_hook( struct hook_table *table, int index,
199 int event, user_handle_t win,
200 int object_id, int child_id )
202 struct hook *hook = get_first_hook( table, index );
206 if (hook->proc && run_hook_in_current_thread( hook ))
208 if (event >= hook->event_min && event <= hook->event_max)
210 if (hook->flags & WINEVENT_INCONTEXT) return hook;
212 /* only winevent hooks may be out of context */
213 assert(hook->index + WH_MINHOOK == WH_WINEVENT);
214 post_win_event( hook->owner, event, win, object_id, child_id,
215 hook->proc, hook->module, hook->module_size,
219 hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
224 /* find the next hook in the chain, skipping the deleted ones */
225 static struct hook *get_next_hook( struct thread *thread, struct hook *hook, int event,
226 user_handle_t win, int object_id, int child_id )
228 struct hook_table *global_hooks, *table = hook->table;
229 int index = hook->index;
231 while ((hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) )))
233 if (hook->proc && run_hook_in_current_thread( hook ))
235 if (event >= hook->event_min && event <= hook->event_max)
237 if (hook->flags & WINEVENT_INCONTEXT) return hook;
239 /* only winevent hooks may be out of context */
240 assert(hook->index + WH_MINHOOK == WH_WINEVENT);
241 post_win_event( hook->owner, event, win, object_id, child_id,
242 hook->proc, hook->module, hook->module_size,
247 global_hooks = get_global_hooks( thread );
248 if (global_hooks && table != global_hooks) /* now search through the global table */
250 hook = get_first_valid_hook( global_hooks, index, event, win, object_id, child_id );
255 static void hook_table_dump( struct object *obj, int verbose )
257 /* struct hook_table *table = (struct hook_table *)obj; */
258 fprintf( stderr, "Hook table\n" );
261 static void hook_table_destroy( struct object *obj )
265 struct hook_table *table = (struct hook_table *)obj;
267 for (i = 0; i < NB_HOOKS; i++)
269 while ((hook = get_first_hook( table, i )) != NULL) free_hook( hook );
273 /* remove a hook, freeing it if the chain is not in use */
274 static void remove_hook( struct hook *hook )
276 if (hook->table->counts[hook->index])
277 hook->proc = NULL; /* chain is in use, just mark it and return */
282 /* release a hook chain, removing deleted hooks if the use count drops to 0 */
283 static void release_hook_chain( struct hook_table *table, int index )
285 if (!table->counts[index]) /* use count shouldn't already be 0 */
287 set_error( STATUS_INVALID_PARAMETER );
290 if (!--table->counts[index])
292 struct hook *hook = get_first_hook( table, index );
295 struct hook *next = HOOK_ENTRY( list_next( &table->hooks[hook->index], &hook->chain ) );
296 if (!hook->proc) free_hook( hook );
302 /* remove all global hooks owned by a given thread */
303 void remove_thread_hooks( struct thread *thread )
305 struct hook_table *global_hooks = get_global_hooks( thread );
308 if (!global_hooks) return;
310 /* only low-level keyboard/mouse global hooks can be owned by a thread */
311 for (index = WH_KEYBOARD_LL - WH_MINHOOK; index <= WH_MOUSE_LL - WH_MINHOOK; index++)
313 struct hook *hook = get_first_hook( global_hooks, index );
316 struct hook *next = HOOK_ENTRY( list_next( &global_hooks->hooks[index], &hook->chain ) );
317 if (hook->thread == thread) remove_hook( hook );
323 /* get a bitmap of active hooks in a hook table */
324 static int is_hook_active( struct hook_table *table, int index )
326 struct hook *hook = get_first_hook( table, index );
330 if (hook->proc && run_hook_in_current_thread( hook )) return 1;
331 hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
336 /* get a bitmap of all active hooks for the current thread */
337 unsigned int get_active_hooks(void)
339 struct hook_table *table = get_queue_hooks( current );
340 struct hook_table *global_hooks = get_global_hooks( current );
341 unsigned int ret = 1 << 31; /* set high bit to indicate that the bitmap is valid */
344 for (id = WH_MINHOOK; id <= WH_WINEVENT; id++)
346 if ((table && is_hook_active( table, id - WH_MINHOOK )) ||
347 (global_hooks && is_hook_active( global_hooks, id - WH_MINHOOK )))
348 ret |= 1 << (id - WH_MINHOOK);
353 /* set a window hook */
354 DECL_HANDLER(set_hook)
356 struct process *process = NULL;
357 struct thread *thread = NULL;
358 struct desktop *desktop;
362 size_t module_size = get_req_data_size();
364 if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
366 set_error( STATUS_INVALID_PARAMETER );
370 if (!(desktop = get_thread_desktop( current, DESKTOP_HOOKCONTROL ))) return;
372 if (req->pid && !(process = get_process_from_id( req->pid ))) goto done;
376 if (!(thread = get_thread_from_id( req->tid ))) goto done;
377 if (process && process != thread->process)
379 set_error( STATUS_INVALID_PARAMETER );
384 if (req->id == WH_KEYBOARD_LL || req->id == WH_MOUSE_LL)
386 /* low-level hardware hooks are special: always global, but without a module */
387 thread = (struct thread *)grab_object( current );
393 /* out of context hooks do not need a module handle */
394 if (!module_size && (req->flags & WINEVENT_INCONTEXT))
396 set_error( STATUS_INVALID_PARAMETER );
399 if (!(module = memdup( get_req_data(), module_size ))) goto done;
408 if ((hook = add_hook( desktop, thread, req->id - WH_MINHOOK, global )))
410 hook->owner = (struct thread *)grab_object( current );
411 hook->process = process ? (struct process *)grab_object( process ) : NULL;
412 hook->event_min = req->event_min;
413 hook->event_max = req->event_max;
414 hook->flags = req->flags;
415 hook->proc = req->proc;
416 hook->unicode = req->unicode;
417 hook->module = module;
418 hook->module_size = module_size;
419 reply->handle = hook->handle;
420 reply->active_hooks = get_active_hooks();
422 else if (module) free( module );
425 if (process) release_object( process );
426 if (thread) release_object( thread );
427 release_object( desktop );
431 /* remove a window hook */
432 DECL_HANDLER(remove_hook)
438 if (!(hook = get_user_object( req->handle, USER_HOOK )))
440 set_error( STATUS_INVALID_HANDLE );
446 if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
448 set_error( STATUS_INVALID_PARAMETER );
451 if (!(hook = find_hook( current, req->id - WH_MINHOOK, req->proc )))
453 set_error( STATUS_INVALID_PARAMETER );
458 reply->active_hooks = get_active_hooks();
462 /* start calling a hook chain */
463 DECL_HANDLER(start_hook_chain)
466 struct hook_table *table = get_queue_hooks( current );
468 if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
470 set_error( STATUS_INVALID_PARAMETER );
474 reply->active_hooks = get_active_hooks();
476 if (!table || !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK, req->event,
477 req->window, req->object_id, req->child_id )))
479 /* try global table */
480 if (!(table = get_global_hooks( current )) ||
481 !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK, req->event,
482 req->window, req->object_id, req->child_id )))
483 return; /* no hook set */
486 if (hook->thread && hook->thread != current) /* must run in other thread */
488 reply->pid = get_process_id( hook->thread->process );
489 reply->tid = get_thread_id( hook->thread );
496 reply->proc = hook->proc;
497 reply->handle = hook->handle;
498 reply->unicode = hook->unicode;
499 table->counts[hook->index]++;
500 if (hook->module) set_reply_data( hook->module, hook->module_size );
504 /* finished calling a hook chain */
505 DECL_HANDLER(finish_hook_chain)
507 struct hook_table *table = get_queue_hooks( current );
508 struct hook_table *global_hooks = get_global_hooks( current );
509 int index = req->id - WH_MINHOOK;
511 if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
513 set_error( STATUS_INVALID_PARAMETER );
516 if (table) release_hook_chain( table, index );
517 if (global_hooks) release_hook_chain( global_hooks, index );
521 /* get the next hook to call */
522 DECL_HANDLER(get_next_hook)
524 struct hook *hook, *next;
526 if (!(hook = get_user_object( req->handle, USER_HOOK ))) return;
527 if (hook->thread && (hook->thread != current))
529 set_error( STATUS_INVALID_HANDLE );
532 if ((next = get_next_hook( current, hook, req->event, req->window, req->object_id, req->child_id )))
534 reply->next = next->handle;
535 reply->id = next->index + WH_MINHOOK;
536 reply->prev_unicode = hook->unicode;
537 reply->next_unicode = next->unicode;
538 if (next->module) set_reply_data( next->module, next->module_size );
539 if (next->thread && next->thread != current)
541 reply->pid = get_process_id( next->thread->process );
542 reply->tid = get_thread_id( next->thread );
549 reply->proc = next->proc;