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