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     int                 index;    /* hook table index */
  48     int                 event_min;
  49     int                 event_max;
  50     int                 flags;
  51     void               *proc;     /* hook function */
  52     int                 unicode;  /* is it a unicode hook? */
  53     WCHAR              *module;   /* module name for global hooks */
  54     size_t              module_size;
  55 };
  56
  57 #define WH_WINEVENT (WH_MAXHOOK+1)
  58
  59 #define NB_HOOKS (WH_WINEVENT-WH_MINHOOK+1)
  60 #define HOOK_ENTRY(p)  LIST_ENTRY( (p), struct hook, chain )
  61
  62 struct hook_table
  63 {
  64     struct object obj;              /* object header */
  65     struct list   hooks[NB_HOOKS];  /* array of hook chains */
  66     int           counts[NB_HOOKS]; /* use counts for each hook chain */
  67 };
  68
  69 static void hook_table_dump( struct object *obj, int verbose );
  70 static void hook_table_destroy( struct object *obj );
  71
  72 static const struct object_ops hook_table_ops =
  73 {
  74     sizeof(struct hook_table),    /* size */
  75     hook_table_dump,              /* dump */
  76     no_add_queue,                 /* add_queue */
  77     NULL,                         /* remove_queue */
  78     NULL,                         /* signaled */
  79     NULL,                         /* satisfied */
  80     no_signal,                    /* signal */
  81     no_get_fd,                    /* get_fd */
  82     hook_table_destroy            /* destroy */
  83 };
  84
  85
  86 static struct hook_table *global_hooks;
  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 /* create a new hook and add it to the specified table */
 106 static struct hook *add_hook( struct thread *thread, int index, int global )
 107 {
 108     struct hook *hook;
 109     struct hook_table *table = global ? global_hooks : get_queue_hooks(thread);
 110
 111     if (!table)
 112     {
 113         if (!(table = alloc_hook_table())) return NULL;
 114         if (global) global_hooks = table;
 115         else set_queue_hooks( thread, table );
 116     }
 117     if (!(hook = mem_alloc( sizeof(*hook) ))) return NULL;
 118
 119     if (!(hook->handle = alloc_user_handle( hook, USER_HOOK )))
 120     {
 121         free( hook );
 122         return NULL;
 123     }
 124     hook->thread = thread ? (struct thread *)grab_object( thread ) : NULL;
 125     hook->index  = index;
 126     list_add_head( &table->hooks[index], &hook->chain );
 127     return hook;
 128 }
 129
 130 /* free a hook, removing it from its chain */
 131 static void free_hook( struct hook *hook )
 132 {
 133     free_user_handle( hook->handle );
 134     if (hook->module) free( hook->module );
 135     if (hook->thread) release_object( hook->thread );
 136     if (hook->process) release_object( hook->process );
 137     release_object( hook->owner );
 138     list_remove( &hook->chain );
 139     free( hook );
 140 }
 141
 142 /* find a hook from its index and proc */
 143 static struct hook *find_hook( struct thread *thread, int index, void *proc )
 144 {
 145     struct list *p;
 146     struct hook_table *table = get_queue_hooks( thread );
 147
 148     if (table)
 149     {
 150         LIST_FOR_EACH( p, &table->hooks[index] )
 151         {
 152             struct hook *hook = HOOK_ENTRY( p );
 153             if (hook->proc == proc) return hook;
 154         }
 155     }
 156     return NULL;
 157 }
 158
 159 /* get the hook table that a given hook belongs to */
 160 inline static struct hook_table *get_table( struct hook *hook )
 161 {
 162     if (!hook->thread) return global_hooks;
 163     if (hook->index + WH_MINHOOK == WH_KEYBOARD_LL) return global_hooks;
 164     if (hook->index + WH_MINHOOK == WH_MOUSE_LL) return global_hooks;
 165     return get_queue_hooks(hook->thread);
 166 }
 167
 168 /* get the first hook in the chain */
 169 inline static struct hook *get_first_hook( struct hook_table *table, int index )
 170 {
 171     struct list *elem = list_head( &table->hooks[index] );
 172     return elem ? HOOK_ENTRY( elem ) : NULL;
 173 }
 174
 175 /* check if a given hook should run in the current thread */
 176 inline static int run_hook_in_current_thread( struct hook *hook )
 177 {
 178     if ((!hook->process || hook->process == current->process) &&
 179         (!(hook->flags & WINEVENT_SKIPOWNPROCESS) || hook->process != current->process))
 180     {
 181         if ((!hook->thread || hook->thread == current) &&
 182             (!(hook->flags & WINEVENT_SKIPOWNTHREAD) || hook->thread != current))
 183             return 1;
 184     }
 185     return 0;
 186 }
 187
 188 /* find the first non-deleted hook in the chain */
 189 inline static struct hook *get_first_valid_hook( struct hook_table *table, int index,
 190                                                  int event, user_handle_t win,
 191                                                  int object_id, int child_id )
 192 {
 193     struct hook *hook = get_first_hook( table, index );
 194
 195     while (hook)
 196     {
 197         if (hook->proc && run_hook_in_current_thread( hook ))
 198         {
 199             if (event >= hook->event_min && event <= hook->event_max)
 200             {
 201                 if (hook->flags & WINEVENT_INCONTEXT) return hook;
 202
 203                 /* only winevent hooks may be out of context */
 204                 assert(hook->index + WH_MINHOOK == WH_WINEVENT);
 205                 post_win_event( hook->owner, event, win, object_id, child_id,
 206                                 hook->proc, hook->module, hook->module_size,
 207                                 hook->handle );
 208             }
 209         }
 210         hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
 211     }
 212     return hook;
 213 }
 214
 215 /* find the next hook in the chain, skipping the deleted ones */
 216 static struct hook *get_next_hook( struct hook *hook, int event, user_handle_t win,
 217                                    int object_id, int child_id )
 218 {
 219     struct hook_table *table = get_table( hook );
 220     int index = hook->index;
 221
 222     while ((hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) )))
 223     {
 224         if (hook->proc && run_hook_in_current_thread( hook ))
 225         {
 226             if (event >= hook->event_min && event <= hook->event_max)
 227             {
 228                 if (hook->flags & WINEVENT_INCONTEXT) return hook;
 229
 230                 /* only winevent hooks may be out of context */
 231                 assert(hook->index + WH_MINHOOK == WH_WINEVENT);
 232                 post_win_event( hook->owner, event, win, object_id, child_id,
 233                                 hook->proc, hook->module, hook->module_size,
 234                                 hook->handle );
 235             }
 236         }
 237     }
 238     if (global_hooks && table != global_hooks)  /* now search through the global table */
 239     {
 240         hook = get_first_valid_hook( global_hooks, index, event, win, object_id, child_id );
 241     }
 242     return hook;
 243 }
 244
 245 static void hook_table_dump( struct object *obj, int verbose )
 246 {
 247     struct hook_table *table = (struct hook_table *)obj;
 248     if (table == global_hooks) fprintf( stderr, "Global hook table\n" );
 249     else fprintf( stderr, "Hook table\n" );
 250 }
 251
 252 static void hook_table_destroy( struct object *obj )
 253 {
 254     int i;
 255     struct hook *hook;
 256     struct hook_table *table = (struct hook_table *)obj;
 257
 258     for (i = 0; i < NB_HOOKS; i++)
 259     {
 260         while ((hook = get_first_hook( table, i )) != NULL) free_hook( hook );
 261     }
 262 }
 263
 264 /* free the global hooks table */
 265 void close_global_hooks(void)
 266 {
 267     if (global_hooks) release_object( global_hooks );
 268 }
 269
 270 /* remove a hook, freeing it if the chain is not in use */
 271 static void remove_hook( struct hook *hook )
 272 {
 273     struct hook_table *table = get_table( hook );
 274     if (table->counts[hook->index])
 275         hook->proc = NULL; /* chain is in use, just mark it and return */
 276     else
 277         free_hook( hook );
 278 }
 279
 280 /* release a hook chain, removing deleted hooks if the use count drops to 0 */
 281 static void release_hook_chain( struct hook_table *table, int index )
 282 {
 283     if (!table->counts[index])  /* use count shouldn't already be 0 */
 284     {
 285         set_error( STATUS_INVALID_PARAMETER );
 286         return;
 287     }
 288     if (!--table->counts[index])
 289     {
 290         struct hook *hook = get_first_hook( table, index );
 291         while (hook)
 292         {
 293             struct hook *next = HOOK_ENTRY( list_next( &table->hooks[hook->index], &hook->chain ) );
 294             if (!hook->proc) free_hook( hook );
 295             hook = next;
 296         }
 297     }
 298 }
 299
 300 /* remove all global hooks owned by a given thread */
 301 void remove_thread_hooks( struct thread *thread )
 302 {
 303     int index;
 304
 305     if (!global_hooks) return;
 306
 307     /* only low-level keyboard/mouse global hooks can be owned by a thread */
 308     for (index = WH_KEYBOARD_LL - WH_MINHOOK; index <= WH_MOUSE_LL - WH_MINHOOK; index++)
 309     {
 310         struct hook *hook = get_first_hook( global_hooks, index );
 311         while (hook)
 312         {
 313             struct hook *next = HOOK_ENTRY( list_next( &global_hooks->hooks[index], &hook->chain ) );
 314             if (hook->thread == thread) remove_hook( hook );
 315             hook = next;
 316         }
 317     }
 318 }
 319
 320 /* get a bitmap of active hooks in a hook table */
 321 static int is_hook_active( struct hook_table *table, int index )
 322 {
 323     struct hook *hook = get_first_hook( table, index );
 324
 325     while (hook)
 326     {
 327         if (hook->proc && run_hook_in_current_thread( hook )) return 1;
 328         hook = HOOK_ENTRY( list_next( &table->hooks[index], &hook->chain ) );
 329     }
 330     return 0;
 331 }
 332
 333 /* get a bitmap of all active hooks for the current thread */
 334 unsigned int get_active_hooks(void)
 335 {
 336     struct hook_table *table = get_queue_hooks( current );
 337     unsigned int ret = 1 << 31;  /* set high bit to indicate that the bitmap is valid */
 338     int id;
 339
 340     for (id = WH_MINHOOK; id <= WH_WINEVENT; id++)
 341     {
 342         if ((table && is_hook_active( table, id - WH_MINHOOK )) ||
 343             (global_hooks && is_hook_active( global_hooks, id - WH_MINHOOK )))
 344             ret |= 1 << (id - WH_MINHOOK);
 345     }
 346     return ret;
 347 }
 348
 349 /* set a window hook */
 350 DECL_HANDLER(set_hook)
 351 {
 352     struct process *process = NULL;
 353     struct thread *thread = NULL;
 354     struct hook *hook;
 355     WCHAR *module;
 356     int global;
 357     size_t module_size = get_req_data_size();
 358
 359     if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
 360     {
 361         set_error( STATUS_INVALID_PARAMETER );
 362         return;
 363     }
 364
 365     if (req->pid && !(process = get_process_from_id( req->pid ))) return;
 366
 367     if (req->tid)
 368     {
 369         if (!(thread = get_thread_from_id( req->tid )))
 370         {
 371             if (process) release_object( process );
 372             return;
 373         }
 374         if (process && process != thread->process)
 375         {
 376             release_object( process );
 377             release_object( thread );
 378             set_error( STATUS_INVALID_PARAMETER );
 379             return;
 380         }
 381     }
 382
 383     if (req->id == WH_KEYBOARD_LL || req->id == WH_MOUSE_LL)
 384     {
 385         /* low-level hardware hooks are special: always global, but without a module */
 386         thread = (struct thread *)grab_object( current );
 387         module = NULL;
 388         global = 1;
 389     }
 390     else if (!req->tid)
 391     {
 392         /* out of context hooks do not need a module handle */
 393         if (!module_size && (req->flags & WINEVENT_INCONTEXT))
 394         {
 395             if (process) release_object( process );
 396             if (thread) release_object( thread );
 397             set_error( STATUS_INVALID_PARAMETER );
 398             return;
 399         }
 400
 401         if (!(module = memdup( get_req_data(), module_size ))) return;
 402         thread = NULL;
 403         global = 1;
 404     }
 405     else
 406     {
 407         module = NULL;
 408         global = 0;
 409     }
 410
 411     if ((hook = add_hook( thread, req->id - WH_MINHOOK, global )))
 412     {
 413         hook->owner = (struct thread *)grab_object( current );
 414         hook->process = process ? (struct process *)grab_object( process ) : NULL;
 415         hook->event_min   = req->event_min;
 416         hook->event_max   = req->event_max;
 417         hook->flags       = req->flags;
 418         hook->proc        = req->proc;
 419         hook->unicode     = req->unicode;
 420         hook->module      = module;
 421         hook->module_size = module_size;
 422         reply->handle = hook->handle;
 423         reply->active_hooks = get_active_hooks();
 424     }
 425     else if (module) free( module );
 426
 427     if (process) release_object( process );
 428     if (thread) release_object( thread );
 429 }
 430
 431
 432 /* remove a window hook */
 433 DECL_HANDLER(remove_hook)
 434 {
 435     struct hook *hook;
 436
 437     if (req->handle)
 438     {
 439         if (!(hook = get_user_object( req->handle, USER_HOOK )))
 440         {
 441             set_error( STATUS_INVALID_HANDLE );
 442             return;
 443         }
 444     }
 445     else
 446     {
 447         if (!req->proc || req->id < WH_MINHOOK || req->id > WH_WINEVENT)
 448         {
 449             set_error( STATUS_INVALID_PARAMETER );
 450             return;
 451         }
 452         if (!(hook = find_hook( current, req->id - WH_MINHOOK, req->proc )))
 453         {
 454             set_error( STATUS_INVALID_PARAMETER );
 455             return;
 456         }
 457     }
 458     remove_hook( hook );
 459     reply->active_hooks = get_active_hooks();
 460 }
 461
 462
 463 /* start calling a hook chain */
 464 DECL_HANDLER(start_hook_chain)
 465 {
 466     struct hook *hook;
 467     struct hook_table *table = get_queue_hooks( current );
 468
 469     if (req->id < WH_MINHOOK || req->id > WH_WINEVENT)
 470     {
 471         set_error( STATUS_INVALID_PARAMETER );
 472         return;
 473     }
 474
 475     reply->active_hooks = get_active_hooks();
 476
 477     if (!table || !(hook = get_first_valid_hook( table, req->id - WH_MINHOOK, req->event,
 478                                                  req->window, req->object_id, req->child_id )))
 479     {
 480         /* try global table */
 481         if (!(table = global_hooks) ||
 482             !(hook = get_first_valid_hook( global_hooks, req->id - WH_MINHOOK, req->event,
 483                                            req->window, req->object_id, req->child_id )))
 484             return;  /* no hook set */
 485     }
 486
 487     if (hook->thread && hook->thread != current) /* must run in other thread */
 488     {
 489         reply->pid  = get_process_id( hook->thread->process );
 490         reply->tid  = get_thread_id( hook->thread );
 491     }
 492     else
 493     {
 494         reply->pid  = 0;
 495         reply->tid  = 0;
 496     }
 497     reply->proc    = hook->proc;
 498     reply->handle  = hook->handle;
 499     reply->unicode = hook->unicode;
 500     table->counts[hook->index]++;
 501     if (hook->module) set_reply_data( hook->module, hook->module_size );
 502 }
 503
 504
 505 /* finished calling a hook chain */
 506 DECL_HANDLER(finish_hook_chain)
 507 {
 508     struct hook_table *table = get_queue_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( 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 }