git.oblomov.eu Git - wine/blob - dlls/user/hook.c

   1 /*
   2  * Windows hook functions
   3  *
   4  * Copyright 2002 Alexandre Julliard
   5  *
   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.
  10  *
  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.
  15  *
  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
  19  *
  20  * NOTES:
  21  *   Status of the various hooks:
  22  *     WH_MSGFILTER                 OK
  23  *     WH_JOURNALRECORD             Partially implemented
  24  *     WH_JOURNALPLAYBACK           Partially implemented
  25  *     WH_KEYBOARD                  OK
  26  *     WH_GETMESSAGE                OK (FIXME: A/W mapping?)
  27  *     WH_CALLWNDPROC               OK (FIXME: A/W mapping?)
  28  *     WH_CBT
  29  *       HCBT_MOVESIZE              OK
  30  *       HCBT_MINMAX                OK
  31  *       HCBT_QS                    OK
  32  *       HCBT_CREATEWND             OK
  33  *       HCBT_DESTROYWND            OK
  34  *       HCBT_ACTIVATE              OK
  35  *       HCBT_CLICKSKIPPED          OK
  36  *       HCBT_KEYSKIPPED            OK
  37  *       HCBT_SYSCOMMAND            Not implemented
  38  *       HCBT_SETFOCUS              OK
  39  *     WH_SYSMSGFILTER              OK
  40  *     WH_MOUSE                     OK
  41  *     WH_HARDWARE                  Not supported in Win32
  42  *     WH_DEBUG                     Not implemented
  43  *     WH_SHELL
  44  *       HSHELL_WINDOWCREATED       OK
  45  *       HSHELL_WINDOWDESTROYED     OK
  46  *       HSHELL_ACTIVATESHELLWINDOW Not implemented
  47  *       HSHELL_WINDOWACTIVATED     Not implemented
  48  *       HSHELL_GETMINRECT          Not implemented
  49  *       HSHELL_REDRAW              Not implemented
  50  *       HSHELL_TASKMAN             Not implemented
  51  *       HSHELL_LANGUAGE            Not implemented
  52  *       HSHELL_SYSMENU             Not implemented
  53  *       HSHELL_ENDTASK             Not implemented
  54  *       HSHELL_ACCESSIBILITYSTATE  Not implemented
  55  *       HSHELL_APPCOMMAND          Not implemented
  56  *       HSHELL_WINDOWREPLACED      Not implemented
  57  *       HSHELL_WINDOWREPLACING     Not implemented
  58  *     WH_FOREGROUNDIDLE            Not implemented
  59  *     WH_CALLWNDPROCRET            OK (FIXME: A/W mapping?)
  60  *     WH_KEYBOARD_LL               Implemented but should use SendMessage instead
  61  *     WH_MOUSE_LL                  Implemented but should use SendMessage instead
  62  */
  63
  64 #include "windef.h"
  65 #include "winbase.h"
  66 #include "winuser.h"
  67 #include "winerror.h"
  68 #include "heap.h"
  69 #include "message.h"
  70 #include "win.h"
  71 #include "wine/server.h"
  72 #include "wine/unicode.h"
  73 #include "wine/debug.h"
  74 #include "winternl.h"
  75
  76 WINE_DEFAULT_DEBUG_CHANNEL(hook);
  77 WINE_DECLARE_DEBUG_CHANNEL(relay);
  78
  79 static const char * const hook_names[WH_MAXHOOK - WH_MINHOOK + 1] =
  80 {
  81     "WH_MSGFILTER",
  82     "WH_JOURNALRECORD",
  83     "WH_JOURNALPLAYBACK",
  84     "WH_KEYBOARD",
  85     "WH_GETMESSAGE",
  86     "WH_CALLWNDPROC",
  87     "WH_CBT",
  88     "WH_SYSMSGFILTER",
  89     "WH_MOUSE",
  90     "WH_HARDWARE",
  91     "WH_DEBUG",
  92     "WH_SHELL",
  93     "WH_FOREGROUNDIDLE",
  94     "WH_CALLWNDPROCRET",
  95     "WH_KEYBOARD_LL",
  96     "WH_MOUSE_LL"
  97 };
  98
  99
 100 /***********************************************************************
 101  *              set_windows_hook
 102  *
 103  * Implementation of SetWindowsHookExA and SetWindowsHookExW.
 104  */
 105 static HHOOK set_windows_hook( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid, BOOL unicode )
 106 {
 107     HHOOK handle = 0;
 108     WCHAR module[MAX_PATH];
 109
 110     if (tid)  /* thread-local hook */
 111     {
 112         if (id == WH_JOURNALRECORD ||
 113             id == WH_JOURNALPLAYBACK ||
 114             id == WH_KEYBOARD_LL ||
 115             id == WH_MOUSE_LL ||
 116             id == WH_SYSMSGFILTER)
 117         {
 118             /* these can only be global */
 119             SetLastError( ERROR_INVALID_PARAMETER );
 120             return 0;
 121         }
 122         inst = 0;
 123     }
 124     else  /* system-global hook */
 125     {
 126         if (!inst || !GetModuleFileNameW( inst, module, MAX_PATH ))
 127         {
 128             SetLastError( ERROR_INVALID_PARAMETER );
 129             return 0;
 130         }
 131     }
 132
 133     SERVER_START_REQ( set_hook )
 134     {
 135         req->id      = id;
 136         req->tid     = tid;
 137         req->unicode = unicode;
 138         if (inst) /* make proc relative to the module base */
 139         {
 140             req->proc = (void *)((char *)proc - (char *)inst);
 141             wine_server_add_data( req, module, strlenW(module) * sizeof(WCHAR) );
 142         }
 143         else req->proc = proc;
 144
 145         if (!wine_server_call_err( req )) handle = reply->handle;
 146     }
 147     SERVER_END_REQ;
 148
 149     TRACE( "%s %p %lx -> %p\n", hook_names[id-WH_MINHOOK], proc, tid, handle );
 150     return handle;
 151 }
 152
 153
 154 /***********************************************************************
 155  *              call_hook_AtoW
 156  */
 157 static LRESULT call_hook_AtoW( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
 158 {
 159     LRESULT ret;
 160     UNICODE_STRING usBuffer;
 161     if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
 162     else
 163     {
 164         CBT_CREATEWNDA *cbtcwA = (CBT_CREATEWNDA *)lparam;
 165         CBT_CREATEWNDW cbtcwW;
 166         CREATESTRUCTW csW;
 167
 168         cbtcwW.lpcs = &csW;
 169         cbtcwW.hwndInsertAfter = cbtcwA->hwndInsertAfter;
 170         csW = *(CREATESTRUCTW *)cbtcwA->lpcs;
 171
 172         if (HIWORD(cbtcwA->lpcs->lpszName))
 173         {
 174             RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszName);
 175             csW.lpszName = usBuffer.Buffer;
 176         }
 177         if (HIWORD(cbtcwA->lpcs->lpszClass))
 178         {
 179             RtlCreateUnicodeStringFromAsciiz(&usBuffer,cbtcwA->lpcs->lpszName);
 180             csW.lpszClass = usBuffer.Buffer;
 181         }
 182         ret = proc( code, wparam, (LPARAM)&cbtcwW );
 183         cbtcwA->hwndInsertAfter = cbtcwW.hwndInsertAfter;
 184         if (HIWORD(csW.lpszName)) HeapFree( GetProcessHeap(), 0, (LPWSTR)csW.lpszName );
 185         if (HIWORD(csW.lpszClass)) HeapFree( GetProcessHeap(), 0, (LPWSTR)csW.lpszClass );
 186     }
 187     return ret;
 188 }
 189
 190
 191 /***********************************************************************
 192  *              call_hook_WtoA
 193  */
 194 static LRESULT call_hook_WtoA( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam )
 195 {
 196     LRESULT ret;
 197
 198     if (id != WH_CBT || code != HCBT_CREATEWND) ret = proc( code, wparam, lparam );
 199     else
 200     {
 201         CBT_CREATEWNDW *cbtcwW = (CBT_CREATEWNDW *)lparam;
 202         CBT_CREATEWNDA cbtcwA;
 203         CREATESTRUCTA csA;
 204
 205         cbtcwA.lpcs = &csA;
 206         cbtcwA.hwndInsertAfter = cbtcwW->hwndInsertAfter;
 207         csA = *(CREATESTRUCTA *)cbtcwW->lpcs;
 208
 209         if (HIWORD(cbtcwW->lpcs->lpszName))
 210             csA.lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0, cbtcwW->lpcs->lpszName );
 211         if (HIWORD(cbtcwW->lpcs->lpszClass))
 212             csA.lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0, cbtcwW->lpcs->lpszClass );
 213         ret = proc( code, wparam, (LPARAM)&cbtcwA );
 214         cbtcwW->hwndInsertAfter = cbtcwA.hwndInsertAfter;
 215         if (HIWORD(csA.lpszName)) HeapFree( GetProcessHeap(), 0, (LPSTR)csA.lpszName );
 216         if (HIWORD(csA.lpszClass)) HeapFree( GetProcessHeap(), 0, (LPSTR)csA.lpszClass );
 217     }
 218     return ret;
 219 }
 220
 221
 222 /***********************************************************************
 223  *              call_hook
 224  */
 225 static LRESULT call_hook( HOOKPROC proc, INT id, INT code, WPARAM wparam, LPARAM lparam,
 226                           BOOL prev_unicode, BOOL next_unicode )
 227 {
 228     LRESULT ret;
 229
 230     if (TRACE_ON(relay))
 231         DPRINTF( "%04lx:Call hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx)\n",
 232                  GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam );
 233
 234     if (!prev_unicode == !next_unicode) ret = proc( code, wparam, lparam );
 235     else if (prev_unicode) ret = call_hook_WtoA( proc, id, code, wparam, lparam );
 236     else ret = call_hook_AtoW( proc, id, code, wparam, lparam );
 237
 238     if (TRACE_ON(relay))
 239         DPRINTF( "%04lx:Ret  hook proc %p (id=%s,code=%x,wp=%08x,lp=%08lx) retval=%08lx\n",
 240                  GetCurrentThreadId(), proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, ret );
 241
 242     return ret;
 243 }
 244
 245
 246 /***********************************************************************
 247  *              get_hook_proc
 248  *
 249  * Retrieve the hook procedure real value for a module-relative proc
 250  */
 251 static HOOKPROC get_hook_proc( HOOKPROC proc, const WCHAR *module )
 252 {
 253     HMODULE mod;
 254
 255     if (!(mod = GetModuleHandleW(module)))
 256     {
 257         TRACE( "loading %s\n", debugstr_w(module) );
 258         /* FIXME: the library will never be freed */
 259         if (!(mod = LoadLibraryW(module))) return NULL;
 260     }
 261     return (HOOKPROC)((char *)mod + (ULONG_PTR)proc);
 262 }
 263
 264
 265 /***********************************************************************
 266  *              HOOK_CallHooks
 267  */
 268 LRESULT HOOK_CallHooks( INT id, INT code, WPARAM wparam, LPARAM lparam, BOOL unicode )
 269 {
 270     MESSAGEQUEUE *queue = QUEUE_Current();
 271     HOOKPROC proc = NULL;
 272     HHOOK prev;
 273     WCHAR module[MAX_PATH];
 274     BOOL unicode_hook = FALSE;
 275     LRESULT ret = 0;
 276
 277     if (!queue) return 0;
 278     prev = queue->hook;
 279     SERVER_START_REQ( start_hook_chain )
 280     {
 281         req->id = id;
 282         wine_server_set_reply( req, module, sizeof(module)-sizeof(WCHAR) );
 283         if (!wine_server_call_err( req ))
 284         {
 285             module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
 286             queue->hook = reply->handle;
 287             proc = reply->proc;
 288             unicode_hook = reply->unicode;
 289         }
 290     }
 291     SERVER_END_REQ;
 292
 293     if (proc)
 294     {
 295         TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
 296                proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, debugstr_w(module) );
 297
 298         if (!module[0] || (proc = get_hook_proc( proc, module )) != NULL)
 299         {
 300             int locks = WIN_SuspendWndsLock();
 301             ret = call_hook( proc, id, code, wparam, lparam, unicode, unicode_hook );
 302             WIN_RestoreWndsLock( locks );
 303         }
 304
 305         SERVER_START_REQ( finish_hook_chain )
 306         {
 307             req->id = id;
 308             wine_server_call( req );
 309         }
 310         SERVER_END_REQ;
 311     }
 312
 313     queue->hook = prev;
 314     return ret;
 315 }
 316
 317
 318 /***********************************************************************
 319  *           HOOK_IsHooked
 320  */
 321 BOOL HOOK_IsHooked( INT id )
 322 {
 323     return TRUE;  /* FIXME */
 324 }
 325
 326
 327 /***********************************************************************
 328  *              SetWindowsHookA (USER32.@)
 329  */
 330 HHOOK WINAPI SetWindowsHookA( INT id, HOOKPROC proc )
 331 {
 332     return SetWindowsHookExA( id, proc, 0, GetCurrentThreadId() );
 333 }
 334
 335
 336 /***********************************************************************
 337  *              SetWindowsHookW (USER32.@)
 338  */
 339 HHOOK WINAPI SetWindowsHookW( INT id, HOOKPROC proc )
 340 {
 341     return SetWindowsHookExW( id, proc, 0, GetCurrentThreadId() );
 342 }
 343
 344
 345 /***********************************************************************
 346  *              SetWindowsHookExA (USER32.@)
 347  */
 348 HHOOK WINAPI SetWindowsHookExA( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
 349 {
 350     return set_windows_hook( id, proc, inst, tid, FALSE );
 351 }
 352
 353 /***********************************************************************
 354  *              SetWindowsHookExW (USER32.@)
 355  */
 356 HHOOK WINAPI SetWindowsHookExW( INT id, HOOKPROC proc, HINSTANCE inst, DWORD tid )
 357 {
 358     return set_windows_hook( id, proc, inst, tid, TRUE );
 359 }
 360
 361
 362 /***********************************************************************
 363  *              UnhookWindowsHook (USER32.@)
 364  */
 365 BOOL WINAPI UnhookWindowsHook( INT id, HOOKPROC proc )
 366 {
 367     BOOL ret;
 368
 369     TRACE( "%s %p\n", hook_names[id-WH_MINHOOK], proc );
 370
 371     SERVER_START_REQ( remove_hook )
 372     {
 373         req->handle = 0;
 374         req->id   = id;
 375         req->proc = proc;
 376         ret = !wine_server_call_err( req );
 377     }
 378     SERVER_END_REQ;
 379     return ret;
 380 }
 381
 382
 383
 384 /***********************************************************************
 385  *              UnhookWindowsHookEx (USER32.@)
 386  */
 387 BOOL WINAPI UnhookWindowsHookEx( HHOOK hhook )
 388 {
 389     BOOL ret;
 390
 391     TRACE( "%p\n", hhook );
 392
 393     SERVER_START_REQ( remove_hook )
 394     {
 395         req->handle = hhook;
 396         ret = !wine_server_call_err( req );
 397     }
 398     SERVER_END_REQ;
 399     return ret;
 400 }
 401
 402
 403 /***********************************************************************
 404  *              CallNextHookEx (USER32.@)
 405  */
 406 LRESULT WINAPI CallNextHookEx( HHOOK hhook, INT code, WPARAM wparam, LPARAM lparam )
 407 {
 408     MESSAGEQUEUE *queue = QUEUE_Current();
 409     HHOOK prev;
 410     WCHAR module[MAX_PATH];
 411     HOOKPROC proc = NULL;
 412     INT id = 0;
 413     BOOL prev_unicode = FALSE, next_unicode = FALSE;
 414     LRESULT ret = 0;
 415
 416     if (!queue) return 0;
 417     prev = queue->hook;
 418     SERVER_START_REQ( get_next_hook )
 419     {
 420         req->handle = prev;
 421         wine_server_set_reply( req, module, sizeof(module)-sizeof(WCHAR) );
 422         if (!wine_server_call_err( req ))
 423         {
 424             module[wine_server_reply_size(req) / sizeof(WCHAR)] = 0;
 425             queue->hook  = reply->next;
 426             id           = reply->id;
 427             proc         = reply->proc;
 428             prev_unicode = reply->prev_unicode;
 429             next_unicode = reply->next_unicode;
 430         }
 431     }
 432     SERVER_END_REQ;
 433
 434     if (proc)
 435     {
 436         TRACE( "calling hook %p %s code %x wp %x lp %lx module %s\n",
 437                proc, hook_names[id-WH_MINHOOK], code, wparam, lparam, debugstr_w(module) );
 438
 439         if (!module[0] || (proc = get_hook_proc( proc, module )) != NULL)
 440             return call_hook( proc, id, code, wparam, lparam, prev_unicode, next_unicode );
 441     }
 442     queue->hook = prev;
 443     return ret;
 444 }
 445
 446
 447 /***********************************************************************
 448  *              CallMsgFilterA (USER32.@)
 449  */
 450 BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
 451 {
 452     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, FALSE )) return TRUE;
 453     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, FALSE );
 454 }
 455
 456
 457 /***********************************************************************
 458  *              CallMsgFilterW (USER32.@)
 459  */
 460 BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
 461 {
 462     if (HOOK_CallHooks( WH_SYSMSGFILTER, code, 0, (LPARAM)msg, TRUE )) return TRUE;
 463     return HOOK_CallHooks( WH_MSGFILTER, code, 0, (LPARAM)msg, TRUE );
 464 }
 465
 466
 467 /***********************************************************************
 468  *           SetWinEventHook                            [USER32.@]
 469  *
 470  * Set up an event hook for a set of events.
 471  *
 472  * PARAMS
 473  *  dwMin     [I] Lowest event handled by pfnProc
 474  *  dwMax     [I] Highest event handled by pfnProc
 475  *  hModule   [I] DLL containing pfnProc
 476  *  pfnProc   [I] Callback event hook function
 477  *  dwProcess [I] Process to get events from, or 0 for all processes
 478  *  dwThread  [I] Thread to get events from, or 0 for all threads
 479  *  dwFlags   [I] Flags indicating the status of pfnProc
 480  *
 481  * RETURNS
 482  *  Success: A handle representing the hook.
 483  *  Failure: A NULL handle.
 484  *
 485  * BUGS
 486  *  Not implemented.
 487  */
 488 HWINEVENTHOOK WINAPI SetWinEventHook(DWORD dwMin, DWORD dwMax, HMODULE hModule,
 489                                      WINEVENTPROC pfnProc, DWORD dwProcess,
 490                                      DWORD dwThread, DWORD dwFlags)
 491 {
 492     FIXME("(%ld,%ld,%p,%p,%ld,%ld,0x%08lx)-stub!\n", dwMin, dwMax, hModule,
 493           pfnProc, dwProcess, dwThread, dwFlags);
 494     return 0;
 495 }
 496
 497
 498 /***********************************************************************
 499  *           UnhookWinEvent                             [USER32.@]
 500  *
 501  * Remove an event hook for a set of events.
 502  *
 503  * PARAMS
 504  *  hEventHook [I] Event hook to remove
 505  *
 506  * RETURNS
 507  *  Success: TRUE. The event hook has been removed.
 508  *  Failure: FALSE, if hEventHook is invalid.
 509  *
 510  * BUGS
 511  *  Not implemented.
 512  */
 513 BOOL WINAPI UnhookWinEvent(HWINEVENTHOOK hEventHook)
 514 {
 515     FIXME("(%p)-stub!\n", hEventHook);
 516
 517     return (hEventHook != 0);
 518 }
 519
 520
 521 /***********************************************************************
 522  *           NotifyWinEvent                             [USER32.@]
 523  *
 524  * Inform the OS that an event has occurred.
 525  *
 526  * PARAMS
 527  *  dwEvent  [I] Id of the event
 528  *  hWnd     [I] Window holding the object that created the event
 529  *  nId      [I] Type of object that created the event
 530  *  nChildId [I] Child object of nId, or CHILDID_SELF.
 531  *
 532  * RETURNS
 533  *  Nothing.
 534  *
 535  * BUGS
 536  *  Not implemented.
 537  */
 538 void WINAPI NotifyWinEvent(DWORD dwEvent, HWND hWnd, LONG nId, LONG nChildId)
 539 {
 540     FIXME("(%ld,%p,%ld,%ld)-stub!\n", dwEvent, hWnd, nId, nChildId);
 541 }
 542
 543
 544 /***********************************************************************
 545  *           IsWinEventHookInstalled                       [USER32.@]
 546  *
 547  * Determine if an event hook is installed for an event.
 548  *
 549  * PARAMS
 550  *  dwEvent  [I] Id of the event
 551  *
 552  * RETURNS
 553  *  TRUE,  If there are any hooks installed for the event.
 554  *  FALSE, Otherwise.
 555  *
 556  * BUGS
 557  *  Not implemented.
 558  */
 559 BOOL WINAPI IsWinEventHookInstalled(DWORD dwEvent)
 560 {
 561     FIXME("(%ld)-stub!\n", dwEvent);
 562     return TRUE;
 563 }