Added support for system-wide hooks.
[wine/multimedia.git] / server / hook.c
blob05eb3de1ac7bf54429883d15bac1f1baab10f773
1 /*
2 * Server-side window hooks support
4 * Copyright (C) 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 #include "config.h"
22 #include "wine/port.h"
24 #include <assert.h>
25 #include <stdio.h>
27 #include "winbase.h"
28 #include "winuser.h"
30 #include "object.h"
31 #include "request.h"
32 #include "user.h"
34 struct hook_table;
36 struct hook
38 struct list chain; /* hook chain entry */
39 user_handle_t handle; /* user handle for this hook */
40 struct thread *thread; /* thread owning the hook */
41 int index; /* hook table index */
42 void *proc; /* hook function */
43 int unicode; /* is it a unicode hook? */
44 WCHAR *module; /* module name for global hooks */
45 size_t module_size;
48 #define NB_HOOKS (WH_MAXHOOK-WH_MINHOOK+1)
49 #define HOOK_ENTRY(p) LIST_ENTRY( (p), struct hook, chain )
51 struct hook_table
53 struct object obj; /* object header */
54 struct list hooks[NB_HOOKS]; /* array of hook chains */
55 int counts[NB_HOOKS]; /* use counts for each hook chain */
58 static void hook_table_dump( struct object *obj, int verbose );
59 static void hook_table_destroy( struct object *obj );
61 static const struct object_ops hook_table_ops =
63 sizeof(struct hook_table), /* size */
64 hook_table_dump, /* dump */
65 no_add_queue, /* add_queue */
66 NULL, /* remove_queue */
67 NULL, /* signaled */
68 NULL, /* satisfied */
69 NULL, /* get_poll_events */
70 NULL, /* poll_event */
71 no_get_fd, /* get_fd */
72 no_flush, /* flush */
73 no_get_file_info, /* get_file_info */
74 NULL, /* queue_async */
75 hook_table_destroy /* destroy */
79 static struct hook_table *global_hooks;
81 /* create a new hook table */
82 static struct hook_table *alloc_hook_table(void)
84 struct hook_table *table;
85 int i;
87 if ((table = alloc_object( &hook_table_ops, -1 )))
89 for (i = 0; i < NB_HOOKS; i++)
91 list_init( &table->hooks[i] );
92 table->counts[i] = 0;
95 return table;
98 /* create a new hook and add it to the specified table */
99 static struct hook *add_hook( struct thread *thread, int index )
101 struct hook *hook;
102 struct hook_table *table = thread ? thread->hooks : global_hooks;
104 if (!table)
106 if (!(table = alloc_hook_table())) return NULL;
107 if (thread) thread->hooks = table;
108 else global_hooks = table;
110 if (!(hook = mem_alloc( sizeof(*hook) ))) return NULL;
112 if (!(hook->handle = alloc_user_handle( hook, USER_HOOK )))
114 free( hook );
115 return NULL;
117 hook->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
118 hook->index = index;
119 list_add_head( &table->hooks[index], &hook->chain );
120 return hook;
123 /* free a hook, removing it from its chain */
124 static void free_hook( struct hook *hook )
126 free_user_handle( hook->handle );
127 if (hook->module) free( hook->module );
128 if (hook->thread) release_object( hook->thread );
129 list_remove( &hook->chain );
130 free( hook );
133 /* find a hook from its index and proc */
134 static struct hook *find_hook( struct thread *thread, int index, void *proc )
136 struct list *p;
137 struct hook_table *table = thread->hooks;
139 if (table)
141 LIST_FOR_EACH( p, &table->hooks[index] )
143 struct hook *hook = HOOK_ENTRY( p );
144 if (hook->proc == proc) return hook;
147 return NULL;
150 /* get the hook table that a given hook belongs to */
151 inline static struct hook_table *get_table( struct hook *hook )
153 return hook->thread ? hook->thread->hooks : global_hooks;
156 /* get the first hook in the chain */
157 inline static struct hook *get_first_hook( struct hook_table *table, int index )
159 struct list *elem = list_head( &table->hooks[index] );
160 return elem ? HOOK_ENTRY( elem ) : NULL;
163 /* find the first non-deleted hook in the chain */
164 inline static struct hook *get_first_valid_hook( struct hook_table *table, int index )
166 struct hook *hook = get_first_hook( table, index );
167 while (hook && !hook->proc)
168 hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
169 return hook;
172 /* find the next hook in the chain, skipping the deleted ones */
173 static struct hook *get_next_hook( struct hook *hook )
175 struct hook_table *table = get_table( hook );
176 int index = hook->index;
178 while ((hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) )))
180 if (hook->proc) return hook;
182 if (global_hooks && table != global_hooks) /* now search through the global table */
184 hook = get_first_valid_hook( global_hooks, index );
186 return hook;
189 static void hook_table_dump( struct object *obj, int verbose )
191 struct hook_table *table = (struct hook_table *)obj;
192 if (table == global_hooks) fprintf( stderr, "Global hook table\n" );
193 else fprintf( stderr, "Hook table\n" );
196 static void hook_table_destroy( struct object *obj )
198 int i;
199 struct hook *hook;
200 struct hook_table *table = (struct hook_table *)obj;
202 for (i = 0; i < NB_HOOKS; i++)
204 while ((hook = get_first_hook( table, i )) != NULL) free_hook( hook );
208 /* free the global hooks table */
209 void close_global_hooks(void)
211 if (global_hooks) release_object( global_hooks );
214 /* remove a hook, freeing it if the chain is not in use */
215 static void remove_hook( struct hook *hook )
217 struct hook_table *table = get_table( hook );
218 if (table->counts[hook->index])
219 hook->proc = NULL; /* chain is in use, just mark it and return */
220 else
221 free_hook( hook );
224 /* release a hook chain, removing deleted hooks if the use count drops to 0 */
225 static void release_hook_chain( struct hook_table *table, int index )
227 if (!table->counts[index]) /* use count shouldn't already be 0 */
229 set_error( STATUS_INVALID_PARAMETER );
230 return;
232 if (!--table->counts[index])
234 struct hook *hook = get_first_hook( table, index );
235 while (hook)
237 struct hook *next = HOOK_ENTRY( list_next( &table->hooks[hook->index], &hook->chain ) );
238 if (!hook->proc) free_hook( hook );
239 hook = next;
245 /* set a window hook */
246 DECL_HANDLER(set_hook)
248 struct thread *thread;
249 struct hook *hook;
250 WCHAR *module;
251 size_t module_size = get_req_data_size();
253 if (!req->proc || req->id < WH_MINHOOK || req->id > WH_MAXHOOK)
255 set_error( STATUS_INVALID_PARAMETER );
256 return;
258 if (!req->tid)
260 if (!module_size)
262 set_error( STATUS_INVALID_PARAMETER );
263 return;
265 if (!(module = memdup( get_req_data(), module_size ))) return;
266 thread = NULL;
268 else
270 module = NULL;
271 if (!(thread = get_thread_from_id( req->tid ))) return;
274 if ((hook = add_hook( thread, req->id - WH_MINHOOK )))
276 hook->proc = req->proc;
277 hook->unicode = req->unicode;
278 hook->module = module;
279 hook->module_size = module_size;
280 reply->handle = hook->handle;
282 else if (module) free( module );
284 if (thread) release_object( thread );
288 /* remove a window hook */
289 DECL_HANDLER(remove_hook)
291 struct hook *hook;
293 if (req->handle) hook = get_user_object( req->handle, USER_HOOK );
294 else
296 if (!req->proc || req->id < WH_MINHOOK || req->id > WH_MAXHOOK)
298 set_error( STATUS_INVALID_PARAMETER );
299 return;
301 if (!(hook = find_hook( current, req->id - WH_MINHOOK, req->proc )))
302 set_error( STATUS_INVALID_PARAMETER );
304 if (hook) remove_hook( hook );
308 /* start calling a hook chain */
309 DECL_HANDLER(start_hook_chain)
311 struct hook *hook;
312 struct hook_table *table = current->hooks;
314 if (req->id < WH_MINHOOK || req->id > WH_MAXHOOK)
316 set_error( STATUS_INVALID_PARAMETER );
317 return;
320 if (!table || !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK )))
322 /* try global table */
323 if (!(table = global_hooks) ||
324 !(hook = get_first_valid_hook( global_hooks, req->id - WH_MINHOOK )))
325 return; /* no hook set */
327 reply->handle = hook->handle;
328 reply->proc = hook->proc;
329 reply->unicode = hook->unicode;
330 table->counts[hook->index]++;
331 if (hook->module) set_reply_data( hook->module, hook->module_size );
335 /* finished calling a hook chain */
336 DECL_HANDLER(finish_hook_chain)
338 struct hook_table *table = current->hooks;
339 int index = req->id - WH_MINHOOK;
341 if (req->id < WH_MINHOOK || req->id > WH_MAXHOOK)
343 set_error( STATUS_INVALID_PARAMETER );
344 return;
346 if (table) release_hook_chain( table, index );
347 if (global_hooks) release_hook_chain( global_hooks, index );
351 /* get the next hook to call */
352 DECL_HANDLER(get_next_hook)
354 struct hook *hook, *next;
356 if (!(hook = get_user_object( req->handle, USER_HOOK ))) return;
357 if (hook->thread && (hook->thread != current))
359 set_error( STATUS_INVALID_HANDLE );
360 return;
362 if ((next = get_next_hook( hook )))
364 reply->next = next->handle;
365 reply->id = next->index + WH_MINHOOK;
366 reply->proc = next->proc;
367 reply->prev_unicode = hook->unicode;
368 reply->next_unicode = next->unicode;
369 if (hook->module) set_reply_data( hook->module, hook->module_size );