advapi32: QueryObjectSecurity should return a self-relative security descriptor and...
[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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, 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 "ntstatus.h"
30 #define WIN32_NO_STATUS
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winuser.h"
34 #include "winternl.h"
35
36 #include "object.h"
37 #include "process.h"
38 #include "request.h"
39 #include "user.h"
40
41 struct hook_table;
42
43 struct hook
44 {
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     data_size_t         module_size;
59 };
60
61 #define WH_WINEVENT (WH_MAXHOOK+1)
62
63 #define NB_HOOKS (WH_WINEVENT-WH_MINHOOK+1)
64 #define HOOK_ENTRY(p)  LIST_ENTRY( (p), struct hook, chain )
65
66 struct hook_table
67 {
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 */
71 };
72
73 static void hook_table_dump( struct object *obj, int verbose );
74 static void hook_table_destroy( struct object *obj );
75
76 static const struct object_ops hook_table_ops =
77 {
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_open_file,                 /* open_file */
89     no_close_handle,              /* close_handle */
90     hook_table_destroy            /* destroy */
91 };
92
93
94 /* create a new hook table */
95 static struct hook_table *alloc_hook_table(void)
96 {
97     struct hook_table *table;
98     int i;
99
100     if ((table = alloc_object( &hook_table_ops )))
101     {
102         for (i = 0; i < NB_HOOKS; i++)
103         {
104             list_init( &table->hooks[i] );
105             table->counts[i] = 0;
106         }
107     }
108     return table;
109 }
110
111 static struct hook_table *get_global_hooks( struct thread *thread )
112 {
113     struct hook_table *table;
114     struct desktop *desktop = get_thread_desktop( thread, 0 );
115
116     if (!desktop) return NULL;
117     table = desktop->global_hooks;
118     release_object( desktop );
119     return table;
120 }
121
122 /* create a new hook and add it to the specified table */
123 static struct hook *add_hook( struct desktop *desktop, struct thread *thread, int index, int global )
124 {
125     struct hook *hook;
126     struct hook_table *table = global ? desktop->global_hooks : get_queue_hooks(thread);
127
128     if (!table)
129     {
130         if (!(table = alloc_hook_table())) return NULL;
131         if (global) desktop->global_hooks = table;
132         else set_queue_hooks( thread, table );
133     }
134     if (!(hook = mem_alloc( sizeof(*hook) ))) return NULL;
135
136     if (!(hook->handle = alloc_user_handle( hook, USER_HOOK )))
137     {
138         free( hook );
139         return NULL;
140     }
141     hook->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
142     hook->table  = table;
143     hook->index  = index;
144     list_add_head( &table->hooks[index], &hook->chain );
145     if (thread) thread->desktop_users++;
146     return hook;
147 }
148
149 /* free a hook, removing it from its chain */
150 static void free_hook( struct hook *hook )
151 {
152     free_user_handle( hook->handle );
153     free( hook->module );
154     if (hook->thread)
155     {
156         assert( hook->thread->desktop_users > 0 );
157         hook->thread->desktop_users--;
158         release_object( hook->thread );
159     }
160     if (hook->process) release_object( hook->process );
161     release_object( hook->owner );
162     list_remove( &hook->chain );
163     free( hook );
164 }
165
166 /* find a hook from its index and proc */
167 static struct hook *find_hook( struct thread *thread, int index, void *proc )
168 {
169     struct list *p;
170     struct hook_table *table = get_queue_hooks( thread );
171
172     if (table)
173     {
174         LIST_FOR_EACH( p, &table->hooks[index] )
175         {
176             struct hook *hook = HOOK_ENTRY( p );
177             if (hook->proc == proc) return hook;
178         }
179     }
180     return NULL;
181 }
182
183 /* get the first hook in the chain */
184 static inline struct hook *get_first_hook( struct hook_table *table, int index )
185 {
186     struct list *elem = list_head( &table->hooks[index] );
187     return elem ? HOOK_ENTRY( elem ) : NULL;
188 }
189
190 /* check if a given hook should run in the current thread */
191 static inline int run_hook_in_current_thread( struct hook *hook )
192 {
193     if ((!hook->process || hook->process == current->process) &&
194         (!(hook->flags & WINEVENT_SKIPOWNPROCESS) || hook->process != current->process))
195     {
196         if ((!hook->thread || hook->thread == current) &&
197             (!(hook->flags & WINEVENT_SKIPOWNTHREAD) || hook->thread != current))
198             return 1;
199     }
200     return 0;
201 }
202
203 /* check if a given hook should run in the owner thread instead of the current thread */
204 static inline int run_hook_in_owner_thread( struct hook *hook )
205 {
206     if ((hook->index == WH_MOUSE_LL - WH_MINHOOK ||
207          hook->index == WH_KEYBOARD_LL - WH_MINHOOK))
208         return hook->owner != current;
209     return 0;
210 }
211
212 /* find the first non-deleted hook in the chain */
213 static inline struct hook *get_first_valid_hook( struct hook_table *table, int index,
214                                                  int event, user_handle_t win,
215                                                  int object_id, int child_id )
216 {
217     struct hook *hook = get_first_hook( table, index );
218
219     while (hook)
220     {
221         if (hook->proc && run_hook_in_current_thread( hook ))
222         {
223             if (event >= hook->event_min && event <= hook->event_max)
224             {
225                 if (hook->flags & WINEVENT_INCONTEXT) return hook;
226
227                 /* only winevent hooks may be out of context */
228                 assert(hook->index + WH_MINHOOK == WH_WINEVENT);
229                 post_win_event( hook->owner, event, win, object_id, child_id,
230                                 hook->proc, hook->module, hook->module_size,
231                                 hook->handle );
232             }
233         }
234         hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
235     }
236     return hook;
237 }
238
239 /* find the next hook in the chain, skipping the deleted ones */
240 static struct hook *get_next_hook( struct thread *thread, struct hook *hook, int event,
241                                    user_handle_t win, int object_id, int child_id )
242 {
243     struct hook_table *global_hooks, *table = hook->table;
244     int index = hook->index;
245
246     while ((hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) )))
247     {
248         if (hook->proc && run_hook_in_current_thread( hook ))
249         {
250             if (event >= hook->event_min && event <= hook->event_max)
251             {
252                 if (hook->flags & WINEVENT_INCONTEXT) return hook;
253
254                 /* only winevent hooks may be out of context */
255                 assert(hook->index + WH_MINHOOK == WH_WINEVENT);
256                 post_win_event( hook->owner, event, win, object_id, child_id,
257                                 hook->proc, hook->module, hook->module_size,
258                                 hook->handle );
259             }
260         }
261     }
262     global_hooks = get_global_hooks( thread );
263     if (global_hooks && table != global_hooks)  /* now search through the global table */
264     {
265         hook = get_first_valid_hook( global_hooks, index, event, win, object_id, child_id );
266     }
267     return hook;
268 }
269
270 static void hook_table_dump( struct object *obj, int verbose )
271 {
272     /* struct hook_table *table = (struct hook_table *)obj; */
273     fprintf( stderr, "Hook table\n" );
274 }
275
276 static void hook_table_destroy( struct object *obj )
277 {
278     int i;
279     struct hook *hook;
280     struct hook_table *table = (struct hook_table *)obj;
281
282     for (i = 0; i < NB_HOOKS; i++)
283     {
284         while ((hook = get_first_hook( table, i )) != NULL) free_hook( hook );
285     }
286 }
287
288 /* remove a hook, freeing it if the chain is not in use */
289 static void remove_hook( struct hook *hook )
290 {
291     if (hook->table->counts[hook->index])
292         hook->proc = NULL; /* chain is in use, just mark it and return */
293     else
294         free_hook( hook );
295 }
296
297 /* release a hook chain, removing deleted hooks if the use count drops to 0 */
298 static void release_hook_chain( struct hook_table *table, int index )
299 {
300     if (!table->counts[index])  /* use count shouldn't already be 0 */
301     {
302         set_error( STATUS_INVALID_PARAMETER );
303         return;
304     }
305     if (!--table->counts[index])
306     {
307         struct hook *hook = get_first_hook( table, index );
308         while (hook)
309         {
310             struct hook *next = HOOK_ENTRY( list_next( &table->hooks[hook->index], &hook->chain ) );
311             if (!hook->proc) free_hook( hook );
312             hook = next;
313         }
314     }
315 }
316
317 /* remove all global hooks owned by a given thread */
318 void remove_thread_hooks( struct thread *thread )
319 {
320     struct hook_table *global_hooks = get_global_hooks( thread );
321     int index;
322
323     if (!global_hooks) return;
324
325     /* only low-level keyboard/mouse global hooks can be owned by a thread */
326     for (index = WH_KEYBOARD_LL - WH_MINHOOK; index <= WH_MOUSE_LL - WH_MINHOOK; index++)
327     {
328         struct hook *hook = get_first_hook( global_hooks, index );
329         while (hook)
330         {
331             struct hook *next = HOOK_ENTRY( list_next( &global_hooks->hooks[index], &hook->chain ) );
332             if (hook->thread == thread) remove_hook( hook );
333             hook = next;
334         }
335     }
336 }
337
338 /* get a bitmap of active hooks in a hook table */
339 static int is_hook_active( struct hook_table *table, int index )
340 {
341     struct hook *hook = get_first_hook( table, index );
342
343     while (hook)
344     {
345         if (hook->proc && run_hook_in_current_thread( hook )) return 1;
346         hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
347     }
348     return 0;
349 }
350
351 /* get a bitmap of all active hooks for the current thread */
352 unsigned int get_active_hooks(void)
353 {
354     struct hook_table *table = get_queue_hooks( current );
355     struct hook_table *global_hooks = get_global_hooks( current );
356     unsigned int ret = 1 << 31;  /* set high bit to indicate that the bitmap is valid */
357     int id;
358
359     for (id = WH_MINHOOK; id <= WH_WINEVENT; id++)
360     {
361         if ((table && is_hook_active( table, id - WH_MINHOOK )) ||
362             (global_hooks && is_hook_active( global_hooks, id - WH_MINHOOK )))
363             ret |= 1 << (id - WH_MINHOOK);
364     }
365     return ret;
366 }
367
368 /* set a window hook */
369 DECL_HANDLER(set_hook)
370 {
371     struct process *process = NULL;
372     struct thread *thread = NULL;
373     struct desktop *desktop;
374     struct hook *hook;
375     WCHAR *module;
376     int global;
377     data_size_t module_size = get_req_data_size();
378
379     if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
380     {
381         set_error( STATUS_INVALID_PARAMETER );
382         return;
383     }
384
385     if (!(desktop = get_thread_desktop( current, DESKTOP_HOOKCONTROL ))) return;
386
387     if (req->pid && !(process = get_process_from_id( req->pid ))) goto done;
388
389     if (req->tid)
390     {
391         if (!(thread = get_thread_from_id( req->tid ))) goto done;
392         if (process && process != thread->process)
393         {
394             set_error( STATUS_INVALID_PARAMETER );
395             goto done;
396         }
397     }
398
399     if (req->id == WH_KEYBOARD_LL || req->id == WH_MOUSE_LL)
400     {
401         /* low-level hardware hooks are special: always global, but without a module */
402         if (thread)
403         {
404             set_error( STATUS_INVALID_PARAMETER );
405             goto done;
406         }
407         module = NULL;
408         global = 1;
409     }
410     else if (!req->tid)
411     {
412         /* out of context hooks do not need a module handle */
413         if (!module_size && (req->flags & WINEVENT_INCONTEXT))
414         {
415             set_error( STATUS_INVALID_PARAMETER );
416             goto done;
417         }
418         if (!(module = memdup( get_req_data(), module_size ))) goto done;
419         global = 1;
420     }
421     else
422     {
423         /* module is optional only if hook is in current process */
424         if (!module_size)
425         {
426             module = NULL;
427             if (thread->process != current->process)
428             {
429                 set_error( STATUS_INVALID_PARAMETER );
430                 goto done;
431             }
432         }
433         else if (!(module = memdup( get_req_data(), module_size ))) goto done;
434         global = 0;
435     }
436
437     if ((hook = add_hook( desktop, thread, req->id - WH_MINHOOK, global )))
438     {
439         hook->owner = (struct thread *)grab_object( current );
440         hook->process = process ? (struct process *)grab_object( process ) : NULL;
441         hook->event_min   = req->event_min;
442         hook->event_max   = req->event_max;
443         hook->flags       = req->flags;
444         hook->proc        = req->proc;
445         hook->unicode     = req->unicode;
446         hook->module      = module;
447         hook->module_size = module_size;
448         reply->handle = hook->handle;
449         reply->active_hooks = get_active_hooks();
450     }
451     else free( module );
452
453 done:
454     if (process) release_object( process );
455     if (thread) release_object( thread );
456     release_object( desktop );
457 }
458
459
460 /* remove a window hook */
461 DECL_HANDLER(remove_hook)
462 {
463     struct hook *hook;
464
465     if (req->handle)
466     {
467         if (!(hook = get_user_object( req->handle, USER_HOOK )))
468         {
469             set_error( STATUS_INVALID_HANDLE );
470             return;
471         }
472     }
473     else
474     {
475         if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
476         {
477             set_error( STATUS_INVALID_PARAMETER );
478             return;
479         }
480         if (!(hook = find_hook( current, req->id - WH_MINHOOK, req->proc )))
481         {
482             set_error( STATUS_INVALID_PARAMETER );
483             return;
484         }
485     }
486     remove_hook( hook );
487     reply->active_hooks = get_active_hooks();
488 }
489
490
491 /* start calling a hook chain */
492 DECL_HANDLER(start_hook_chain)
493 {
494     struct hook *hook;
495     struct hook_table *table = get_queue_hooks( current );
496
497     if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
498     {
499         set_error( STATUS_INVALID_PARAMETER );
500         return;
501     }
502
503     reply->active_hooks = get_active_hooks();
504
505     if (!table || !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK, req->event,
506                                                  req->window, req->object_id, req->child_id )))
507     {
508         /* try global table */
509         if (!(table = get_global_hooks( current )) ||
510             !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK, req->event,
511                                            req->window, req->object_id, req->child_id )))
512             return;  /* no hook set */
513     }
514
515     if (run_hook_in_owner_thread( hook ))
516     {
517         reply->pid  = get_process_id( hook->owner->process );
518         reply->tid  = get_thread_id( hook->owner );
519     }
520     else
521     {
522         reply->pid  = 0;
523         reply->tid  = 0;
524     }
525     reply->proc    = hook->proc;
526     reply->handle  = hook->handle;
527     reply->unicode = hook->unicode;
528     table->counts[hook->index]++;
529     if (hook->module) set_reply_data( hook->module, hook->module_size );
530 }
531
532
533 /* finished calling a hook chain */
534 DECL_HANDLER(finish_hook_chain)
535 {
536     struct hook_table *table = get_queue_hooks( current );
537     struct hook_table *global_hooks = get_global_hooks( current );
538     int index = req->id - WH_MINHOOK;
539
540     if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
541     {
542         set_error( STATUS_INVALID_PARAMETER );
543         return;
544     }
545     if (table) release_hook_chain( table, index );
546     if (global_hooks) release_hook_chain( global_hooks, index );
547 }
548
549
550 /* get the hook information */
551 DECL_HANDLER(get_hook_info)
552 {
553     struct hook *hook;
554
555     if (!(hook = get_user_object( req->handle, USER_HOOK ))) return;
556     if (hook->thread && (hook->thread != current))
557     {
558         set_error( STATUS_INVALID_HANDLE );
559         return;
560     }
561     if (req->get_next && !(hook = get_next_hook( current, hook, req->event, req->window,
562                                                  req->object_id, req->child_id )))
563         return;
564
565     reply->handle  = hook->handle;
566     reply->id      = hook->index + WH_MINHOOK;
567     reply->unicode = hook->unicode;
568     if (hook->module) set_reply_data( hook->module, min(hook->module_size,get_reply_max_size()) );
569     if (run_hook_in_owner_thread( hook ))
570     {
571         reply->pid  = get_process_id( hook->owner->process );
572         reply->tid  = get_thread_id( hook->owner );
573     }
574     else
575     {
576         reply->pid  = 0;
577         reply->tid  = 0;
578     }
579     reply->proc = hook->proc;
580 }