Ignore:
Timestamp:
Feb 12, 2000, 7:09:50 PM (26 years ago)
Author:
cbratschi
Message:

added v5.00 messages

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/user32/HOOK.CPP

    r2469 r2768  
    1 /* $Id: HOOK.CPP,v 1.9 2000-01-18 20:10:30 sandervl Exp $ */
     1/* $Id: HOOK.CPP,v 1.10 2000-02-12 18:09:49 cbratschi Exp $ */
    22
    33/*
    … …  
    2727#include <os2win.h>
    2828#include "hook.h"
    29 #include "win.h"
    3029#include "queue.h"
    3130#include "task.h"
    … …  
    7069typedef VOID (*HOOK_MapFunc)(INT, INT, WPARAM *, LPARAM *);
    7170typedef VOID (*HOOK_UnMapFunc)(INT, INT, WPARAM, LPARAM, WPARAM,
    72                                LPARAM);
     71                               LPARAM);
    7372
    7473/***********************************************************************
    … …  
    7675 */
    7776static void HOOK_Map32ATo32W(INT id, INT code, WPARAM *pwParam,
    78                              LPARAM *plParam)
     77                             LPARAM *plParam)
    7978{
    8079    if (id == WH_CBT && code == HCBT_CREATEWND)
    8180    {
    82         LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)*plParam;
    83         LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)HeapAlloc(GetProcessHeap(), 0,
    84                                                                 sizeof(*lpcbtcwW) );
    85         lpcbtcwW->lpcs = (CREATESTRUCTW*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwW->lpcs) );
    86 
    87         lpcbtcwW->hwndInsertAfter = lpcbtcwA->hwndInsertAfter;
    88         *lpcbtcwW->lpcs = *(LPCREATESTRUCTW)lpcbtcwA->lpcs;
    89 
    90         if (HIWORD(lpcbtcwA->lpcs->lpszName))
    91         {
    92             lpcbtcwW->lpcs->lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0,
     81        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)*plParam;
     82        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)HeapAlloc(GetProcessHeap(), 0,
     83                                                                sizeof(*lpcbtcwW) );
     84        lpcbtcwW->lpcs = (CREATESTRUCTW*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwW->lpcs) );
     85
     86        lpcbtcwW->hwndInsertAfter = lpcbtcwA->hwndInsertAfter;
     87        *lpcbtcwW->lpcs = *(LPCREATESTRUCTW)lpcbtcwA->lpcs;
     88
     89        if (HIWORD(lpcbtcwA->lpcs->lpszName))
     90        {
     91            lpcbtcwW->lpcs->lpszName = HEAP_strdupAtoW( GetProcessHeap(), 0,
    9392                                                    lpcbtcwA->lpcs->lpszName );
    94         }
    95         else
    96           lpcbtcwW->lpcs->lpszName = (LPWSTR)lpcbtcwA->lpcs->lpszName;
    97 
    98         if (HIWORD(lpcbtcwA->lpcs->lpszClass))
    99         {
    100             lpcbtcwW->lpcs->lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
     93        }
     94        else
     95          lpcbtcwW->lpcs->lpszName = (LPWSTR)lpcbtcwA->lpcs->lpszName;
     96
     97        if (HIWORD(lpcbtcwA->lpcs->lpszClass))
     98        {
     99            lpcbtcwW->lpcs->lpszClass = HEAP_strdupAtoW( GetProcessHeap(), 0,
    101100                                                   lpcbtcwA->lpcs->lpszClass );
    102         }
    103         else
    104           lpcbtcwW->lpcs->lpszClass = (LPCWSTR)lpcbtcwA->lpcs->lpszClass;
    105         *plParam = (LPARAM)lpcbtcwW;
     101        }
     102        else
     103          lpcbtcwW->lpcs->lpszClass = (LPCWSTR)lpcbtcwA->lpcs->lpszClass;
     104        *plParam = (LPARAM)lpcbtcwW;
    106105    }
    107106    return;
    … …  
    113112 */
    114113static void HOOK_UnMap32ATo32W(INT id, INT code, WPARAM wParamOrig,
    115                                LPARAM lParamOrig, WPARAM wParam,
    116                                LPARAM lParam)
     114                               LPARAM lParamOrig, WPARAM wParam,
     115                               LPARAM lParam)
    117116{
    118117    if (id == WH_CBT && code == HCBT_CREATEWND)
    119118    {
    120         LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)lParam;
    121         if (HIWORD(lpcbtcwW->lpcs->lpszName))
     119        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)lParam;
     120        if (HIWORD(lpcbtcwW->lpcs->lpszName))
    122121            HeapFree( GetProcessHeap(), 0, (LPWSTR)lpcbtcwW->lpcs->lpszName );
    123         if (HIWORD(lpcbtcwW->lpcs->lpszClass))
     122        if (HIWORD(lpcbtcwW->lpcs->lpszClass))
    124123            HeapFree( GetProcessHeap(), 0, (LPWSTR)lpcbtcwW->lpcs->lpszClass );
    125         HeapFree( GetProcessHeap(), 0, lpcbtcwW->lpcs );
    126         HeapFree( GetProcessHeap(), 0, lpcbtcwW );
     124        HeapFree( GetProcessHeap(), 0, lpcbtcwW->lpcs );
     125        HeapFree( GetProcessHeap(), 0, lpcbtcwW );
    127126    }
    128127    return;
    … …  
    134133 */
    135134static void HOOK_Map32WTo32A(INT id, INT code, WPARAM *pwParam,
    136                              LPARAM *plParam)
     135                             LPARAM *plParam)
    137136{
    138137    if (id == WH_CBT && code == HCBT_CREATEWND)
    139138    {
    140         LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)*plParam;
    141         LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)HeapAlloc(GetProcessHeap(), 0,
    142                                                                 sizeof(*lpcbtcwA) );
    143         lpcbtcwA->lpcs = (CREATESTRUCTA*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwA->lpcs) );
    144 
    145         lpcbtcwA->hwndInsertAfter = lpcbtcwW->hwndInsertAfter;
    146         *lpcbtcwA->lpcs = *(LPCREATESTRUCTA)lpcbtcwW->lpcs;
    147 
    148         if (HIWORD(lpcbtcwW->lpcs->lpszName))
    149           lpcbtcwA->lpcs->lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0,
     139        LPCBT_CREATEWNDW lpcbtcwW = (LPCBT_CREATEWNDW)*plParam;
     140        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)HeapAlloc(GetProcessHeap(), 0,
     141                                                                sizeof(*lpcbtcwA) );
     142        lpcbtcwA->lpcs = (CREATESTRUCTA*)HeapAlloc( GetProcessHeap(), 0, sizeof(*lpcbtcwA->lpcs) );
     143
     144        lpcbtcwA->hwndInsertAfter = lpcbtcwW->hwndInsertAfter;
     145        *lpcbtcwA->lpcs = *(LPCREATESTRUCTA)lpcbtcwW->lpcs;
     146
     147        if (HIWORD(lpcbtcwW->lpcs->lpszName))
     148          lpcbtcwA->lpcs->lpszName = HEAP_strdupWtoA( GetProcessHeap(), 0,
    150149                                                    lpcbtcwW->lpcs->lpszName );
    151         else
    152           lpcbtcwA->lpcs->lpszName = (LPSTR)lpcbtcwW->lpcs->lpszName;
    153 
    154         if (HIWORD(lpcbtcwW->lpcs->lpszClass))
    155           lpcbtcwA->lpcs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
     150        else
     151          lpcbtcwA->lpcs->lpszName = (LPSTR)lpcbtcwW->lpcs->lpszName;
     152
     153        if (HIWORD(lpcbtcwW->lpcs->lpszClass))
     154          lpcbtcwA->lpcs->lpszClass = HEAP_strdupWtoA( GetProcessHeap(), 0,
    156155                                                   lpcbtcwW->lpcs->lpszClass );
    157         else
    158           lpcbtcwA->lpcs->lpszClass = (LPSTR)lpcbtcwW->lpcs->lpszClass;
    159         *plParam = (LPARAM)lpcbtcwA;
     156        else
     157          lpcbtcwA->lpcs->lpszClass = (LPSTR)lpcbtcwW->lpcs->lpszClass;
     158        *plParam = (LPARAM)lpcbtcwA;
    160159    }
    161160    return;
    … …  
    167166 */
    168167static void HOOK_UnMap32WTo32A(INT id, INT code, WPARAM wParamOrig,
    169                                LPARAM lParamOrig, WPARAM wParam,
    170                                LPARAM lParam)
     168                               LPARAM lParamOrig, WPARAM wParam,
     169                               LPARAM lParam)
    171170{
    172171    if (id == WH_CBT && code == HCBT_CREATEWND)
    173172    {
    174         LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)lParam;
    175         if (HIWORD(lpcbtcwA->lpcs->lpszName))
     173        LPCBT_CREATEWNDA lpcbtcwA = (LPCBT_CREATEWNDA)lParam;
     174        if (HIWORD(lpcbtcwA->lpcs->lpszName))
    176175            HeapFree( GetProcessHeap(), 0, (LPSTR)lpcbtcwA->lpcs->lpszName );
    177         if (HIWORD(lpcbtcwA->lpcs->lpszClass))
     176        if (HIWORD(lpcbtcwA->lpcs->lpszClass))
    178177            HeapFree( GetProcessHeap(), 0, (LPSTR)lpcbtcwA->lpcs->lpszClass );
    179         HeapFree( GetProcessHeap(), 0, lpcbtcwA->lpcs );
    180         HeapFree( GetProcessHeap(), 0, lpcbtcwA );
     178        HeapFree( GetProcessHeap(), 0, lpcbtcwA->lpcs );
     179        HeapFree( GetProcessHeap(), 0, lpcbtcwA );
    181180    }
    182181    return;
    … …  
    187186 *           Map Function Tables
    188187 */
    189 static const HOOK_MapFunc HOOK_MapFuncs[3][3] = 
     188static const HOOK_MapFunc HOOK_MapFuncs[3][3] =
    190189{
    191190    { NULL, NULL,             NULL },
    … …  
    194193};
    195194
    196 static const HOOK_UnMapFunc HOOK_UnMapFuncs[3][3] = 
     195static const HOOK_UnMapFunc HOOK_UnMapFuncs[3][3] =
    197196{
    198197    { NULL, NULL,               NULL },
    … …  
    234233  HANDLE hook = 0;
    235234  THDB *thdb;
    236    
     235
    237236    thdb = GetTHDBFromThreadId(threadId);
    238237    if(thdb) {
    239         hook = thdb->hooks[id - WH_MINHOOK];
     238        hook = thdb->hooks[id - WH_MINHOOK];
    240239    }
    241240    if (!hook) hook = HOOK_systemHooks[id - WH_MINHOOK];
    … …  
    251250 */
    252251static HHOOK HOOK_SetHook( INT id, LPVOID proc, INT type,
    253                            HMODULE hModule, DWORD dwThreadId )
     252                           HMODULE hModule, DWORD dwThreadId )
    254253{
    255254  HOOKDATA *data;
    256255  THDB     *thdb;
    257  
     256
    258257    if ((id < WH_MINHOOK) || (id > WH_MAXHOOK) || !proc )
    259258    {
    260         SetLastError(ERROR_INVALID_PARAMETER);
     259        SetLastError(ERROR_INVALID_PARAMETER);
    261260        return 0;
    262261    }
    … …  
    275274    if (dwThreadId)  /* Task-specific hook */
    276275    {
    277         if ((id == WH_JOURNALRECORD) || (id == WH_JOURNALPLAYBACK) ||
    278             (id == WH_SYSMSGFILTER)) {
    279                 SetLastError(ERROR_INVALID_PARAMETER);
    280                 return 0;  /* System-only hooks */
    281         }
     276        if ((id == WH_JOURNALRECORD) || (id == WH_JOURNALPLAYBACK) ||
     277            (id == WH_SYSMSGFILTER)) {
     278                SetLastError(ERROR_INVALID_PARAMETER);
     279                return 0;  /* System-only hooks */
     280        }
    282281    }
    283282
    … …  
    295294    if(dwThreadId)
    296295    {
    297         thdb = GetTHDBFromThreadId(dwThreadId);
    298         if(!thdb) {
    299                 dprintf(("HOOK_SetHook: can't find thread database for thread %x", dwThreadId));
    300                 return 0;
    301         }
    302         threadHookMutex.enter();
     296        thdb = GetTHDBFromThreadId(dwThreadId);
     297        if(!thdb) {
     298                dprintf(("HOOK_SetHook: can't find thread database for thread %x", dwThreadId));
     299                return 0;
     300        }
     301        threadHookMutex.enter();
    303302        data->next = thdb->hooks[id - WH_MINHOOK];
    304303        thdb->hooks[id - WH_MINHOOK] = (DWORD)data;
    305         threadHookMutex.leave();
     304        threadHookMutex.leave();
    306305    }
    307306    else
    308307    {
    309         systemHookMutex.enter();
     308        systemHookMutex.enter();
    310309        data->next = HOOK_systemHooks[id - WH_MINHOOK];
    311310        HOOK_systemHooks[id - WH_MINHOOK] = (HANDLE)data;
    312         systemHookMutex.leave();
     311        systemHookMutex.leave();
    313312    }
    314313
    … …  
    329328
    330329    dprintf(("Removing hook %08x\n", data));
    331    
     330
    332331    if (data->flags & HOOK_INUSE)
    333332    {
    … …  
    341340    if (data->id == WH_JOURNALPLAYBACK) EnableHardwareInput16(TRUE);
    342341#endif
    343      
     342
    344343    /* Remove it from the linked list */
    345344
    346345    if (data->ownerThread)
    347346    {
    348         thdb = GetTHDBFromThreadId(data->ownerThread);
    349         if(!thdb) {
    350                 dprintf(("HOOK_RemoveHook: can't find thread database for thread %x", data->ownerThread));
    351                 return FALSE;
    352         }
    353         hookMutex = &threadHookMutex;
    354         hookMutex->enter();
     347        thdb = GetTHDBFromThreadId(data->ownerThread);
     348        if(!thdb) {
     349                dprintf(("HOOK_RemoveHook: can't find thread database for thread %x", data->ownerThread));
     350                return FALSE;
     351        }
     352        hookMutex = &threadHookMutex;
     353        hookMutex->enter();
    355354        prevHook = (HOOKDATA **)&thdb->hooks[data->id - WH_MINHOOK];
    356355    }
    357356    else {
    358         hookMutex = &systemHookMutex;
    359         hookMutex->enter();
    360         prevHook = (HOOKDATA **)&HOOK_systemHooks[data->id - WH_MINHOOK];
     357        hookMutex = &systemHookMutex;
     358        hookMutex->enter();
     359        prevHook = (HOOKDATA **)&HOOK_systemHooks[data->id - WH_MINHOOK];
    361360    }
    362361    while (*prevHook && *prevHook != data)
    … …  
    364363
    365364    if (!prevHook) {
    366         hookMutex->leave();
    367         return FALSE;
     365        hookMutex->leave();
     366        return FALSE;
    368367    }
    369368    *prevHook = (HOOKDATA *)data->next;
    … …  
    384383    for (;;)
    385384    {
    386         if (!(data = (HOOKDATA *)hook)) return 0;
    387         if (data->proc) return hook;
    388         hook = data->next;
     385        if (!(data = (HOOKDATA *)hook)) return 0;
     386        if (data->proc) return hook;
     387        hook = data->next;
    389388    }
    390389}
    … …  
    444443BOOL HOOK_IsHooked( INT id )
    445444{
    446     /* Hmmm. Use GetThreadQueue(0) instead of GetFastQueue() here to 
     445    /* Hmmm. Use GetThreadQueue(0) instead of GetFastQueue() here to
    447446       avoid queue being created if someone wants to merely check ... */
    448447
    … …  
    458457                           LPARAM lParam )
    459458{
    460     HANDLE hook; 
     459    HANDLE hook;
    461460
    462461    if (!(hook = HOOK_GetHook( id, GetCurrentThreadId() ))) return 0;
    … …  
    473472                           LPARAM lParam )
    474473{
    475     HANDLE hook; 
     474    HANDLE hook;
    476475
    477476    if (!(hook = HOOK_GetHook( id, GetCurrentThreadId() ))) return 0;
    478477    if (!(hook = HOOK_FindValidHook(hook))) return 0;
    479478    return HOOK_CallHook( hook, HOOK_WIN32W, code, wParam,
    480                           lParam );
     479                          lParam );
    481480}
    482481
    … …  
    492491    if ((queue = (MESSAGEQUEUE *)QUEUE_Lock( hQueue )) != NULL)
    493492    {
    494         HOOKDATA*       data;
    495         HHOOK           hook;
    496         int             id;
    497         for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
    498         {
    499             hook = queue->hooks[id - WH_MINHOOK];
    500             while( hook )
    501             {
    502                 if( (data = (HOOKDATA *)hook) )
    503                 {
    504                   data->ownerQueue = hQueue;
    505                   hook = data->next;
    506                 } else break;
    507             }
    508         }
     493        HOOKDATA*       data;
     494        HHOOK           hook;
     495        int             id;
     496        for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
     497        {
     498            hook = queue->hooks[id - WH_MINHOOK];
     499            while( hook )
     500            {
     501                if( (data = (HOOKDATA *)hook) )
     502                {
     503                  data->ownerQueue = hQueue;
     504                  hook = data->next;
     505                } else break;
     506            }
     507        }
    509508
    510509        QUEUE_Unlock( queue );
    … …  
    514513
    515514/***********************************************************************
    516  *           HOOK_FreeModuleHooks
     515 *           HOOK_FreeModuleHooks
    517516 */
    518517void HOOK_FreeModuleHooks( HMODULE hModule )
    … …  
    528527       hook = HOOK_systemHooks[id - WH_MINHOOK];
    529528       while( hook )
    530           if( (hptr = (HOOKDATA *)hook) )
    531             {
    532               next = hptr->next;
    533               if( hptr->ownerModule == hModule )
     529       {
     530          hptr = (HOOKDATA *)hook;
     531          if (hptr)
     532            {
     533              next = hptr->next;
     534              if( hptr->ownerModule == hModule )
    534535                {
    535536                  hptr->flags &= HOOK_MAPTYPE;
    536537                  HOOK_RemoveHook(hptr);
    537538                }
    538               hook = next;
    539             }
    540           else hook = 0;
    541     }
    542 }
    543 
    544 /***********************************************************************
    545  *           HOOK_FreeQueueHooks
     539              hook = next;
     540            }
     541          else hook = 0;
     542       }
     543    }
     544}
     545
     546/***********************************************************************
     547 *           HOOK_FreeQueueHooks
    546548 */
    547549void HOOK_FreeQueueHooks( DWORD threadId )
    … …  
    549551  /* remove all hooks registered by this queue */
    550552
    551   HOOKDATA*     hptr = NULL;
    552   HHOOK         hook, next;
    553   int           id;
     553  HOOKDATA*     hptr = NULL;
     554  HHOOK         hook, next;
     555  int           id;
    554556
    555557  for( id = WH_MINHOOK; id <= WH_MAXHOOK; id++ )
    … …  
    557559       hook = HOOK_GetHook( id, threadId );
    558560       while( hook )
    559         {
    560           next = HOOK_GetNextHook(hook);
    561 
    562           hptr = (HOOKDATA *)hook;
    563           if( hptr && hptr->ownerThread == threadId )
    564             {
    565               hptr->flags &= HOOK_MAPTYPE;
    566               HOOK_RemoveHook(hptr);
    567             }
    568           hook = next;
    569         }
     561        {
     562          next = HOOK_GetNextHook(hook);
     563
     564          hptr = (HOOKDATA *)hook;
     565          if( hptr && hptr->ownerThread == threadId )
     566            {
     567              hptr->flags &= HOOK_MAPTYPE;
     568              HOOK_RemoveHook(hptr);
     569            }
     570          hook = next;
     571        }
    570572    }
    571573}
    … …  
    632634{
    633635    if (CHECK_MAGIC(hhook) == FALSE)
    634         return FALSE;
     636        return FALSE;
    635637
    636638    return HOOK_RemoveHook( (HOOKDATA *)hhook );
    … …  
    646648{
    647649    HANDLE next;
    648     INT fromtype;       /* figure out Ansi/Unicode */
     650    INT fromtype;       /* figure out Ansi/Unicode */
    649651    HOOKDATA *oldhook;
    650652
    651653    if (CHECK_MAGIC(hhook) == FALSE)
    652         return FALSE;
     654        return FALSE;
    653655
    654656    if (!(next = HOOK_GetNextHook( hhook ))) return 0;
    … …  
    670672BOOL WINAPI CallMsgFilterA( LPMSG msg, INT code )
    671673{
    672     if (GetSysModalWindow()) return FALSE;      /* ??? */
     674#if 0 //CB: not a Win32 API and unimplemented
     675    if (GetSysModalWindow()) return FALSE;      /* ??? */
     676#endif
    673677    if (HOOK_CallHooksA( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
    674678      return TRUE;
    … …  
    682686BOOL WINAPI CallMsgFilterW( LPMSG msg, INT code )
    683687{
    684     if (GetSysModalWindow()) return FALSE;      /* ??? */
     688#if 0 //CB: not a Win32 API and unimplemented
     689    if (GetSysModalWindow()) return FALSE;      /* ??? */
     690#endif
    685691    if (HOOK_CallHooksW( WH_SYSMSGFILTER, code, 0, (LPARAM)msg ))
    686692      return TRUE;
Note: See TracChangeset for help on using the changeset viewer.