Fixed exception handling on MacOS.
[wine] / server / hook.c
1 /*
2  * Server-side window hooks support
3  *
4  * Copyright (C) 2002 Alexandre Julliard
5  * Copyright (C) 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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
20  */
21
22 #include "config.h"
23 #include "wine/port.h"
24
25 #include <assert.h>
26 #include <stdarg.h>
27 #include <stdio.h>
28
29 #include "windef.h"
30 #include "winbase.h"
31 #include "winuser.h"
32
33 #include "object.h"
34 #include "process.h"
35 #include "request.h"
36 #include "user.h"
37
38 struct hook_table;
39
40 struct hook
41 {
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 */
49     int                 event_min;
50     int                 event_max;
51     int                 flags;
52     void               *proc;     /* hook function */
53     int                 unicode;  /* is it a unicode hook? */
54     WCHAR              *module;   /* module name for global hooks */
55     size_t              module_size;
56 };
57
58 #define WH_WINEVENT (WH_MAXHOOK+1)
59
60 #define NB_HOOKS (WH_WINEVENT-WH_MINHOOK+1)
61 #define HOOK_ENTRY(p)  LIST_ENTRY( (p), struct hook, chain )
62
63 struct hook_table
64 {
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 */
68 };
69
70 static void hook_table_dump( struct object *obj, int verbose );
71 static void hook_table_destroy( struct object *obj );
72
73 static const struct object_ops hook_table_ops =
74 {
75     sizeof(struct hook_table),    /* size */
76     hook_table_dump,              /* dump */
77     no_add_queue,                 /* add_queue */
78     NULL,                         /* remove_queue */
79     NULL,                         /* signaled */
80     NULL,                         /* satisfied */
81     no_signal,                    /* signal */
82     no_get_fd,                    /* get_fd */
83     no_close_handle,              /* close_handle */
84     hook_table_destroy            /* destroy */
85 };
86
87
88 /* create a new hook table */
89 static struct hook_table *alloc_hook_table(void)
90 {
91     struct hook_table *table;
92     int i;
93
94     if ((table = alloc_object( &hook_table_ops )))
95     {
96         for (i = 0; i < NB_HOOKS; i++)
97         {
98             list_init( &table->hooks[i] );
99             table->counts[i] = 0;
100         }
101     }
102     return table;
103 }
104
105 static struct hook_table *get_global_hooks( struct thread *thread )
106 {
107     struct hook_table *table;
108     struct desktop *desktop = get_thread_desktop( thread, 0 );
109
110     if (!desktop) return NULL;
111     table = desktop->global_hooks;
112     release_object( desktop );
113     return table;
114 }
115
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 )
118 {
119     struct hook *hook;
120     struct hook_table *table = global ? desktop->global_hooks : get_queue_hooks(thread);
121
122     if (!table)
123     {
124         if (!(table = alloc_hook_table())) return NULL;
125         if (global) desktop->global_hooks = table;
126         else set_queue_hooks( thread, table );
127     }
128     if (!(hook = mem_alloc( sizeof(*hook) ))) return NULL;
129
130     if (!(hook->handle = alloc_user_handle( hook, USER_HOOK )))
131     {
132         free( hook );
133         return NULL;
134     }
135     hook->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
136     hook->table  = table;
137     hook->index  = index;
138     list_add_head( &table->hooks[index], &hook->chain );
139     if (thread) thread->desktop_users++;
140     return hook;
141 }
142
143 /* free a hook, removing it from its chain */
144 static void free_hook( struct hook *hook )
145 {
146     free_user_handle( hook->handle );
147     if (hook->module) free( hook->module );
148     if (hook->thread)
149     {
150         assert( hook->thread->desktop_users > 0 );
151         hook->thread->desktop_users--;
152         release_object( hook->thread );
153     }
154     if (hook->process) release_object( hook->process );
155     release_object( hook->owner );
156     list_remove( &hook->chain );
157     free( hook );
158 }
159
160 /* find a hook from its index and proc */
161 static struct hook *find_hook( struct thread *thread, int index, void *proc )
162 {
163     struct list *p;
164     struct hook_table *table = get_queue_hooks( thread );
165
166     if (table)
167     {
168         LIST_FOR_EACH( p, &table->hooks[index] )
169         {
170             struct hook *hook = HOOK_ENTRY( p );
171             if (hook->proc == proc) return hook;
172         }
173     }
174     return NULL;
175 }
176
177 /* get the first hook in the chain */
178 inline static struct hook *get_first_hook( struct hook_table *table, int index )
179 {
180     struct list *elem = list_head( &table->hooks[index] );
181     return elem ? HOOK_ENTRY( elem ) : NULL;
182 }
183
184 /* check if a given hook should run in the current thread */
185 inline static int run_hook_in_current_thread( struct hook *hook )
186 {
187     if ((!hook->process || hook->process == current->process) &&
188         (!(hook->flags & WINEVENT_SKIPOWNPROCESS) || hook->process != current->process))
189     {
190         if ((!hook->thread || hook->thread == current) &&
191             (!(hook->flags & WINEVENT_SKIPOWNTHREAD) || hook->thread != current))
192             return 1;
193     }
194     return 0;
195 }
196
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 )
201 {
202     struct hook *hook = get_first_hook( table, index );
203
204     while (hook)
205     {
206         if (hook->proc && run_hook_in_current_thread( hook ))
207         {
208             if (event >= hook->event_min && event <= hook->event_max)
209             {
210                 if (hook->flags & WINEVENT_INCONTEXT) return hook;
211
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,
216                                 hook->handle );
217             }
218         }
219         hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
220     }
221     return hook;
222 }
223
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 )
227 {
228     struct hook_table *global_hooks, *table = hook->table;
229     int index = hook->index;
230
231     while ((hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) )))
232     {
233         if (hook->proc && run_hook_in_current_thread( hook ))
234         {
235             if (event >= hook->event_min && event <= hook->event_max)
236             {
237                 if (hook->flags & WINEVENT_INCONTEXT) return hook;
238
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,
243                                 hook->handle );
244             }
245         }
246     }
247     global_hooks = get_global_hooks( thread );
248     if (global_hooks && table != global_hooks)  /* now search through the global table */
249     {
250         hook = get_first_valid_hook( global_hooks, index, event, win, object_id, child_id );
251     }
252     return hook;
253 }
254
255 static void hook_table_dump( struct object *obj, int verbose )
256 {
257     /* struct hook_table *table = (struct hook_table *)obj; */
258     fprintf( stderr, "Hook table\n" );
259 }
260
261 static void hook_table_destroy( struct object *obj )
262 {
263     int i;
264     struct hook *hook;
265     struct hook_table *table = (struct hook_table *)obj;
266
267     for (i = 0; i < NB_HOOKS; i++)
268     {
269         while ((hook = get_first_hook( table, i )) != NULL) free_hook( hook );
270     }
271 }
272
273 /* remove a hook, freeing it if the chain is not in use */
274 static void remove_hook( struct hook *hook )
275 {
276     if (hook->table->counts[hook->index])
277         hook->proc = NULL; /* chain is in use, just mark it and return */
278     else
279         free_hook( hook );
280 }
281
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 )
284 {
285     if (!table->counts[index])  /* use count shouldn't already be 0 */
286     {
287         set_error( STATUS_INVALID_PARAMETER );
288         return;
289     }
290     if (!--table->counts[index])
291     {
292         struct hook *hook = get_first_hook( table, index );
293         while (hook)
294         {
295             struct hook *next = HOOK_ENTRY( list_next( &table->hooks[hook->index], &hook->chain ) );
296             if (!hook->proc) free_hook( hook );
297             hook = next;
298         }
299     }
300 }
301
302 /* remove all global hooks owned by a given thread */
303 void remove_thread_hooks( struct thread *thread )
304 {
305     struct hook_table *global_hooks = get_global_hooks( thread );
306     int index;
307
308     if (!global_hooks) return;
309
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++)
312     {
313         struct hook *hook = get_first_hook( global_hooks, index );
314         while (hook)
315         {
316             struct hook *next = HOOK_ENTRY( list_next( &global_hooks->hooks[index], &hook->chain ) );
317             if (hook->thread == thread) remove_hook( hook );
318             hook = next;
319         }
320     }
321 }
322
323 /* get a bitmap of active hooks in a hook table */
324 static int is_hook_active( struct hook_table *table, int index )
325 {
326     struct hook *hook = get_first_hook( table, index );
327
328     while (hook)
329     {
330         if (hook->proc && run_hook_in_current_thread( hook )) return 1;
331         hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
332     }
333     return 0;
334 }
335
336 /* get a bitmap of all active hooks for the current thread */
337 unsigned int get_active_hooks(void)
338 {
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 */
342     int id;
343
344     for (id = WH_MINHOOK; id <= WH_WINEVENT; id++)
345     {
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);
349     }
350     return ret;
351 }
352
353 /* set a window hook */
354 DECL_HANDLER(set_hook)
355 {
356     struct process *process = NULL;
357     struct thread *thread = NULL;
358     struct desktop *desktop;
359     struct hook *hook;
360     WCHAR *module;
361     int global;
362     size_t module_size = get_req_data_size();
363
364     if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
365     {
366         set_error( STATUS_INVALID_PARAMETER );
367         return;
368     }
369
370     if (!(desktop = get_thread_desktop( current, DESKTOP_HOOKCONTROL ))) return;
371
372     if (req->pid && !(process = get_process_from_id( req->pid ))) goto done;
373
374     if (req->tid)
375     {
376         if (!(thread = get_thread_from_id( req->tid ))) goto done;
377         if (process && process != thread->process)
378         {
379             set_error( STATUS_INVALID_PARAMETER );
380             goto done;
381         }
382     }
383
384     if (req->id == WH_KEYBOARD_LL || req->id == WH_MOUSE_LL)
385     {
386         /* low-level hardware hooks are special: always global, but without a module */
387         thread = (struct thread *)grab_object( current );
388         module = NULL;
389         global = 1;
390     }
391     else if (!req->tid)
392     {
393         /* out of context hooks do not need a module handle */
394         if (!module_size && (req->flags & WINEVENT_INCONTEXT))
395         {
396             set_error( STATUS_INVALID_PARAMETER );
397             goto done;
398         }
399         if (!(module = memdup( get_req_data(), module_size ))) goto done;
400         global = 1;
401     }
402     else
403     {
404         module = NULL;
405         global = 0;
406     }
407
408     if ((hook = add_hook( desktop, thread, req->id - WH_MINHOOK, global )))
409     {
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();
421     }
422     else if (module) free( module );
423
424 done:
425     if (process) release_object( process );
426     if (thread) release_object( thread );
427     release_object( desktop );
428 }
429
430
431 /* remove a window hook */
432 DECL_HANDLER(remove_hook)
433 {
434     struct hook *hook;
435
436     if (req->handle)
437     {
438         if (!(hook = get_user_object( req->handle, USER_HOOK )))
439         {
440             set_error( STATUS_INVALID_HANDLE );
441             return;
442         }
443     }
444     else
445     {
446         if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
447         {
448             set_error( STATUS_INVALID_PARAMETER );
449             return;
450         }
451         if (!(hook = find_hook( current, req->id - WH_MINHOOK, req->proc )))
452         {
453             set_error( STATUS_INVALID_PARAMETER );
454             return;
455         }
456     }
457     remove_hook( hook );
458     reply->active_hooks = get_active_hooks();
459 }
460
461
462 /* start calling a hook chain */
463 DECL_HANDLER(start_hook_chain)
464 {
465     struct hook *hook;
466     struct hook_table *table = get_queue_hooks( current );
467
468     if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
469     {
470         set_error( STATUS_INVALID_PARAMETER );
471         return;
472     }
473
474     reply->active_hooks = get_active_hooks();
475
476     if (!table || !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK, req->event,
477                                                  req->window, req->object_id, req->child_id )))
478     {
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 */
484     }
485
486     if (hook->thread && hook->thread != current) /* must run in other thread */
487     {
488         reply->pid  = get_process_id( hook->thread->process );
489         reply->tid  = get_thread_id( hook->thread );
490     }
491     else
492     {
493         reply->pid  = 0;
494         reply->tid  = 0;
495     }
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 );
501 }
502
503
504 /* finished calling a hook chain */
505 DECL_HANDLER(finish_hook_chain)
506 {
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;
510
511     if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
512     {
513         set_error( STATUS_INVALID_PARAMETER );
514         return;
515     }
516     if (table) release_hook_chain( table, index );
517     if (global_hooks) release_hook_chain( global_hooks, index );
518 }
519
520
521 /* get the next hook to call */
522 DECL_HANDLER(get_next_hook)
523 {
524     struct hook *hook, *next;
525
526     if (!(hook = get_user_object( req->handle, USER_HOOK ))) return;
527     if (hook->thread && (hook->thread != current))
528     {
529         set_error( STATUS_INVALID_HANDLE );
530         return;
531     }
532     if ((next = get_next_hook( current, hook, req->event, req->window, req->object_id, req->child_id )))
533     {
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)
540         {
541             reply->pid  = get_process_id( next->thread->process );
542             reply->tid  = get_thread_id( next->thread );
543         }
544         else
545         {
546             reply->pid  = 0;
547             reply->tid  = 0;
548         }
549         reply->proc = next->proc;
550     }
551 }