wrc: Remove some tokens declared twice.
[wine/multimedia.git] / server / hook.c
blobb0d1b8f62d3ae7016cd916df2b4764a62fe1432b
1 /*
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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "config.h"
23 #include "wine/port.h"
25 #include <assert.h>
26 #include <stdarg.h>
27 #include <stdio.h>
29 #include "ntstatus.h"
30 #define WIN32_NO_STATUS
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winuser.h"
34 #include "winternl.h"
36 #include "object.h"
37 #include "process.h"
38 #include "request.h"
39 #include "user.h"
41 struct hook_table;
43 struct hook
45 struct list chain; /* hook chain entry */
46 user_handle_t handle; /* user handle for this hook */
47 struct process *process; /* process the hook is set to */
48 struct thread *thread; /* thread the hook is set to */
49 struct thread *owner; /* owner of the out of context hook */
50 struct hook_table *table; /* hook table that contains this hook */
51 int index; /* hook table index */
52 int event_min;
53 int event_max;
54 int flags;
55 void *proc; /* hook function */
56 int unicode; /* is it a unicode hook? */
57 WCHAR *module; /* module name for global hooks */
58 size_t module_size;
61 #define WH_WINEVENT (WH_MAXHOOK+1)
63 #define NB_HOOKS (WH_WINEVENT-WH_MINHOOK+1)
64 #define HOOK_ENTRY(p) LIST_ENTRY( (p), struct hook, chain )
66 struct hook_table
68 struct object obj; /* object header */
69 struct list hooks[NB_HOOKS]; /* array of hook chains */
70 int counts[NB_HOOKS]; /* use counts for each hook chain */
73 static void hook_table_dump( struct object *obj, int verbose );
74 static void hook_table_destroy( struct object *obj );
76 static const struct object_ops hook_table_ops =
78 sizeof(struct hook_table), /* size */
79 hook_table_dump, /* dump */
80 no_add_queue, /* add_queue */
81 NULL, /* remove_queue */
82 NULL, /* signaled */
83 NULL, /* satisfied */
84 no_signal, /* signal */
85 no_get_fd, /* get_fd */
86 no_map_access, /* map_access */
87 no_lookup_name, /* lookup_name */
88 no_close_handle, /* close_handle */
89 hook_table_destroy /* destroy */
93 /* create a new hook table */
94 static struct hook_table *alloc_hook_table(void)
96 struct hook_table *table;
97 int i;
99 if ((table = alloc_object( &hook_table_ops )))
101 for (i = 0; i < NB_HOOKS; i++)
103 list_init( &table->hooks[i] );
104 table->counts[i] = 0;
107 return table;
110 static struct hook_table *get_global_hooks( struct thread *thread )
112 struct hook_table *table;
113 struct desktop *desktop = get_thread_desktop( thread, 0 );
115 if (!desktop) return NULL;
116 table = desktop->global_hooks;
117 release_object( desktop );
118 return table;
121 /* create a new hook and add it to the specified table */
122 static struct hook *add_hook( struct desktop *desktop, struct thread *thread, int index, int global )
124 struct hook *hook;
125 struct hook_table *table = global ? desktop->global_hooks : get_queue_hooks(thread);
127 if (!table)
129 if (!(table = alloc_hook_table())) return NULL;
130 if (global) desktop->global_hooks = table;
131 else set_queue_hooks( thread, table );
133 if (!(hook = mem_alloc( sizeof(*hook) ))) return NULL;
135 if (!(hook->handle = alloc_user_handle( hook, USER_HOOK )))
137 free( hook );
138 return NULL;
140 hook->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
141 hook->table = table;
142 hook->index = index;
143 list_add_head( &table->hooks[index], &hook->chain );
144 if (thread) thread->desktop_users++;
145 return hook;
148 /* free a hook, removing it from its chain */
149 static void free_hook( struct hook *hook )
151 free_user_handle( hook->handle );
152 if (hook->module) free( hook->module );
153 if (hook->thread)
155 assert( hook->thread->desktop_users > 0 );
156 hook->thread->desktop_users--;
157 release_object( hook->thread );
159 if (hook->process) release_object( hook->process );
160 release_object( hook->owner );
161 list_remove( &hook->chain );
162 free( hook );
165 /* find a hook from its index and proc */
166 static struct hook *find_hook( struct thread *thread, int index, void *proc )
168 struct list *p;
169 struct hook_table *table = get_queue_hooks( thread );
171 if (table)
173 LIST_FOR_EACH( p, &table->hooks[index] )
175 struct hook *hook = HOOK_ENTRY( p );
176 if (hook->proc == proc) return hook;
179 return NULL;
182 /* get the first hook in the chain */
183 inline static struct hook *get_first_hook( struct hook_table *table, int index )
185 struct list *elem = list_head( &table->hooks[index] );
186 return elem ? HOOK_ENTRY( elem ) : NULL;
189 /* check if a given hook should run in the current thread */
190 inline static int run_hook_in_current_thread( struct hook *hook )
192 if ((!hook->process || hook->process == current->process) &&
193 (!(hook->flags & WINEVENT_SKIPOWNPROCESS) || hook->process != current->process))
195 if ((!hook->thread || hook->thread == current) &&
196 (!(hook->flags & WINEVENT_SKIPOWNTHREAD) || hook->thread != current))
197 return 1;
199 return 0;
202 /* check if a given hook should run in the owner thread instead of the current thread */
203 inline static int run_hook_in_owner_thread( struct hook *hook )
205 if ((hook->index == WH_MOUSE_LL - WH_MINHOOK ||
206 hook->index == WH_KEYBOARD_LL - WH_MINHOOK))
207 return hook->owner != current;
208 return 0;
211 /* find the first non-deleted hook in the chain */
212 inline static struct hook *get_first_valid_hook( struct hook_table *table, int index,
213 int event, user_handle_t win,
214 int object_id, int child_id )
216 struct hook *hook = get_first_hook( table, index );
218 while (hook)
220 if (hook->proc && run_hook_in_current_thread( hook ))
222 if (event >= hook->event_min && event <= hook->event_max)
224 if (hook->flags & WINEVENT_INCONTEXT) return hook;
226 /* only winevent hooks may be out of context */
227 assert(hook->index + WH_MINHOOK == WH_WINEVENT);
228 post_win_event( hook->owner, event, win, object_id, child_id,
229 hook->proc, hook->module, hook->module_size,
230 hook->handle );
233 hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
235 return hook;
238 /* find the next hook in the chain, skipping the deleted ones */
239 static struct hook *get_next_hook( struct thread *thread, struct hook *hook, int event,
240 user_handle_t win, int object_id, int child_id )
242 struct hook_table *global_hooks, *table = hook->table;
243 int index = hook->index;
245 while ((hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) )))
247 if (hook->proc && run_hook_in_current_thread( hook ))
249 if (event >= hook->event_min && event <= hook->event_max)
251 if (hook->flags & WINEVENT_INCONTEXT) return hook;
253 /* only winevent hooks may be out of context */
254 assert(hook->index + WH_MINHOOK == WH_WINEVENT);
255 post_win_event( hook->owner, event, win, object_id, child_id,
256 hook->proc, hook->module, hook->module_size,
257 hook->handle );
261 global_hooks = get_global_hooks( thread );
262 if (global_hooks && table != global_hooks) /* now search through the global table */
264 hook = get_first_valid_hook( global_hooks, index, event, win, object_id, child_id );
266 return hook;
269 static void hook_table_dump( struct object *obj, int verbose )
271 /* struct hook_table *table = (struct hook_table *)obj; */
272 fprintf( stderr, "Hook table\n" );
275 static void hook_table_destroy( struct object *obj )
277 int i;
278 struct hook *hook;
279 struct hook_table *table = (struct hook_table *)obj;
281 for (i = 0; i < NB_HOOKS; i++)
283 while ((hook = get_first_hook( table, i )) != NULL) free_hook( hook );
287 /* remove a hook, freeing it if the chain is not in use */
288 static void remove_hook( struct hook *hook )
290 if (hook->table->counts[hook->index])
291 hook->proc = NULL; /* chain is in use, just mark it and return */
292 else
293 free_hook( hook );
296 /* release a hook chain, removing deleted hooks if the use count drops to 0 */
297 static void release_hook_chain( struct hook_table *table, int index )
299 if (!table->counts[index]) /* use count shouldn't already be 0 */
301 set_error( STATUS_INVALID_PARAMETER );
302 return;
304 if (!--table->counts[index])
306 struct hook *hook = get_first_hook( table, index );
307 while (hook)
309 struct hook *next = HOOK_ENTRY( list_next( &table->hooks[hook->index], &hook->chain ) );
310 if (!hook->proc) free_hook( hook );
311 hook = next;
316 /* remove all global hooks owned by a given thread */
317 void remove_thread_hooks( struct thread *thread )
319 struct hook_table *global_hooks = get_global_hooks( thread );
320 int index;
322 if (!global_hooks) return;
324 /* only low-level keyboard/mouse global hooks can be owned by a thread */
325 for (index = WH_KEYBOARD_LL - WH_MINHOOK; index <= WH_MOUSE_LL - WH_MINHOOK; index++)
327 struct hook *hook = get_first_hook( global_hooks, index );
328 while (hook)
330 struct hook *next = HOOK_ENTRY( list_next( &global_hooks->hooks[index], &hook->chain ) );
331 if (hook->thread == thread) remove_hook( hook );
332 hook = next;
337 /* get a bitmap of active hooks in a hook table */
338 static int is_hook_active( struct hook_table *table, int index )
340 struct hook *hook = get_first_hook( table, index );
342 while (hook)
344 if (hook->proc && run_hook_in_current_thread( hook )) return 1;
345 hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
347 return 0;
350 /* get a bitmap of all active hooks for the current thread */
351 unsigned int get_active_hooks(void)
353 struct hook_table *table = get_queue_hooks( current );
354 struct hook_table *global_hooks = get_global_hooks( current );
355 unsigned int ret = 1 << 31; /* set high bit to indicate that the bitmap is valid */
356 int id;
358 for (id = WH_MINHOOK; id <= WH_WINEVENT; id++)
360 if ((table && is_hook_active( table, id - WH_MINHOOK )) ||
361 (global_hooks && is_hook_active( global_hooks, id - WH_MINHOOK )))
362 ret |= 1 << (id - WH_MINHOOK);
364 return ret;
367 /* set a window hook */
368 DECL_HANDLER(set_hook)
370 struct process *process = NULL;
371 struct thread *thread = NULL;
372 struct desktop *desktop;
373 struct hook *hook;
374 WCHAR *module;
375 int global;
376 size_t module_size = get_req_data_size();
378 if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
380 set_error( STATUS_INVALID_PARAMETER );
381 return;
384 if (!(desktop = get_thread_desktop( current, DESKTOP_HOOKCONTROL ))) return;
386 if (req->pid && !(process = get_process_from_id( req->pid ))) goto done;
388 if (req->tid)
390 if (!(thread = get_thread_from_id( req->tid ))) goto done;
391 if (process && process != thread->process)
393 set_error( STATUS_INVALID_PARAMETER );
394 goto done;
398 if (req->id == WH_KEYBOARD_LL || req->id == WH_MOUSE_LL)
400 /* low-level hardware hooks are special: always global, but without a module */
401 if (thread)
403 set_error( STATUS_INVALID_PARAMETER );
404 goto done;
406 module = NULL;
407 global = 1;
409 else if (!req->tid)
411 /* out of context hooks do not need a module handle */
412 if (!module_size && (req->flags & WINEVENT_INCONTEXT))
414 set_error( STATUS_INVALID_PARAMETER );
415 goto done;
417 if (!(module = memdup( get_req_data(), module_size ))) goto done;
418 global = 1;
420 else
422 module = NULL;
423 global = 0;
426 if ((hook = add_hook( desktop, thread, req->id - WH_MINHOOK, global )))
428 hook->owner = (struct thread *)grab_object( current );
429 hook->process = process ? (struct process *)grab_object( process ) : NULL;
430 hook->event_min = req->event_min;
431 hook->event_max = req->event_max;
432 hook->flags = req->flags;
433 hook->proc = req->proc;
434 hook->unicode = req->unicode;
435 hook->module = module;
436 hook->module_size = module_size;
437 reply->handle = hook->handle;
438 reply->active_hooks = get_active_hooks();
440 else if (module) free( module );
442 done:
443 if (process) release_object( process );
444 if (thread) release_object( thread );
445 release_object( desktop );
449 /* remove a window hook */
450 DECL_HANDLER(remove_hook)
452 struct hook *hook;
454 if (req->handle)
456 if (!(hook = get_user_object( req->handle, USER_HOOK )))
458 set_error( STATUS_INVALID_HANDLE );
459 return;
462 else
464 if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
466 set_error( STATUS_INVALID_PARAMETER );
467 return;
469 if (!(hook = find_hook( current, req->id - WH_MINHOOK, req->proc )))
471 set_error( STATUS_INVALID_PARAMETER );
472 return;
475 remove_hook( hook );
476 reply->active_hooks = get_active_hooks();
480 /* start calling a hook chain */
481 DECL_HANDLER(start_hook_chain)
483 struct hook *hook;
484 struct hook_table *table = get_queue_hooks( current );
486 if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
488 set_error( STATUS_INVALID_PARAMETER );
489 return;
492 reply->active_hooks = get_active_hooks();
494 if (!table || !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK, req->event,
495 req->window, req->object_id, req->child_id )))
497 /* try global table */
498 if (!(table = get_global_hooks( current )) ||
499 !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK, req->event,
500 req->window, req->object_id, req->child_id )))
501 return; /* no hook set */
504 if (run_hook_in_owner_thread( hook ))
506 reply->pid = get_process_id( hook->owner->process );
507 reply->tid = get_thread_id( hook->owner );
509 else
511 reply->pid = 0;
512 reply->tid = 0;
514 reply->proc = hook->proc;
515 reply->handle = hook->handle;
516 reply->unicode = hook->unicode;
517 table->counts[hook->index]++;
518 if (hook->module) set_reply_data( hook->module, hook->module_size );
522 /* finished calling a hook chain */
523 DECL_HANDLER(finish_hook_chain)
525 struct hook_table *table = get_queue_hooks( current );
526 struct hook_table *global_hooks = get_global_hooks( current );
527 int index = req->id - WH_MINHOOK;
529 if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
531 set_error( STATUS_INVALID_PARAMETER );
532 return;
534 if (table) release_hook_chain( table, index );
535 if (global_hooks) release_hook_chain( global_hooks, index );
539 /* get the next hook to call */
540 DECL_HANDLER(get_next_hook)
542 struct hook *hook, *next;
544 if (!(hook = get_user_object( req->handle, USER_HOOK ))) return;
545 if (hook->thread && (hook->thread != current))
547 set_error( STATUS_INVALID_HANDLE );
548 return;
550 if ((next = get_next_hook( current, hook, req->event, req->window, req->object_id, req->child_id )))
552 reply->next = next->handle;
553 reply->id = next->index + WH_MINHOOK;
554 reply->prev_unicode = hook->unicode;
555 reply->next_unicode = next->unicode;
556 if (next->module) set_reply_data( next->module, next->module_size );
557 if (run_hook_in_owner_thread( next ))
559 reply->pid = get_process_id( next->owner->process );
560 reply->tid = get_thread_id( next->owner );
562 else
564 reply->pid = 0;
565 reply->tid = 0;
567 reply->proc = next->proc;