callback.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_WINDOWPROC_CALLBACK_ARGUMENTS
struct	_SENDASYNCPROC_CALLBACK_ARGUMENTS
struct	_CALL_BACK_INFO
struct	_HOOKPROC_CALLBACK_ARGUMENTS
struct	_HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS
struct	tagCWP_Struct
struct	tagCWPR_Struct
struct	_EVENTPROC_CALLBACK_ARGUMENTS
struct	_LOADMENU_CALLBACK_ARGUMENTS
struct	_COPYIMAGE_CALLBACK_ARGUMENTS
struct	_CLIENT_LOAD_LIBRARY_ARGUMENTS
struct	_GET_CHARSET_INFO
struct	_SETWNDICONS_CALLBACK_ARGUMENTS
struct	_DDEPOSTGET_CALLBACK_ARGUMENTS
struct	_SETOBM_CALLBACK_ARGUMENTS
struct	_LPK_CALLBACK_ARGUMENTS

Macros
#define	USER32_CALLBACK_WINDOWPROC   (0)
#define	USER32_CALLBACK_SENDASYNCPROC   (1)
#define	USER32_CALLBACK_LOADSYSMENUTEMPLATE   (2)
#define	USER32_CALLBACK_LOADDEFAULTCURSORS   (3)
#define	USER32_CALLBACK_HOOKPROC   (4)
#define	USER32_CALLBACK_EVENTPROC   (5)
#define	USER32_CALLBACK_LOADMENU   (6)
#define	USER32_CALLBACK_CLIENTTHREADSTARTUP   (7)
#define	USER32_CALLBACK_CLIENTLOADLIBRARY   (8)
#define	USER32_CALLBACK_GETCHARSETINFO   (9)
#define	USER32_CALLBACK_COPYIMAGE   (10)
#define	USER32_CALLBACK_SETWNDICONS   (11)
#define	USER32_CALLBACK_DELIVERUSERAPC   (12)
#define	USER32_CALLBACK_DDEPOST   (13)
#define	USER32_CALLBACK_DDEGET   (14)
#define	USER32_CALLBACK_SETOBM   (15)
#define	USER32_CALLBACK_LPK   (16)
#define	USER32_CALLBACK_UMPD   (17)
#define	USER32_CALLBACK_MAXIMUM   (17)

Typedefs
typedef struct _WINDOWPROC_CALLBACK_ARGUMENTS	WINDOWPROC_CALLBACK_ARGUMENTS
typedef struct _WINDOWPROC_CALLBACK_ARGUMENTS *	PWINDOWPROC_CALLBACK_ARGUMENTS
typedef struct _SENDASYNCPROC_CALLBACK_ARGUMENTS	SENDASYNCPROC_CALLBACK_ARGUMENTS
typedef struct _SENDASYNCPROC_CALLBACK_ARGUMENTS *	PSENDASYNCPROC_CALLBACK_ARGUMENTS
typedef struct _CALL_BACK_INFO	CALL_BACK_INFO
typedef struct _CALL_BACK_INFO *	PCALL_BACK_INFO
typedef struct _HOOKPROC_CALLBACK_ARGUMENTS	HOOKPROC_CALLBACK_ARGUMENTS
typedef struct _HOOKPROC_CALLBACK_ARGUMENTS *	PHOOKPROC_CALLBACK_ARGUMENTS
typedef struct _HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS	HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS
typedef struct _HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS *	PHOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS
typedef struct tagCWP_Struct	CWP_Struct
typedef struct tagCWP_Struct *	PCWP_Struct
typedef struct tagCWPR_Struct	CWPR_Struct
typedef struct tagCWPR_Struct *	PCWPR_Struct
typedef struct _EVENTPROC_CALLBACK_ARGUMENTS	EVENTPROC_CALLBACK_ARGUMENTS
typedef struct _EVENTPROC_CALLBACK_ARGUMENTS *	PEVENTPROC_CALLBACK_ARGUMENTS
typedef struct _LOADMENU_CALLBACK_ARGUMENTS	LOADMENU_CALLBACK_ARGUMENTS
typedef struct _LOADMENU_CALLBACK_ARGUMENTS *	PLOADMENU_CALLBACK_ARGUMENTS
typedef struct _COPYIMAGE_CALLBACK_ARGUMENTS	COPYIMAGE_CALLBACK_ARGUMENTS
typedef struct _COPYIMAGE_CALLBACK_ARGUMENTS *	PCOPYIMAGE_CALLBACK_ARGUMENTS
typedef struct _CLIENT_LOAD_LIBRARY_ARGUMENTS	CLIENT_LOAD_LIBRARY_ARGUMENTS
typedef struct _CLIENT_LOAD_LIBRARY_ARGUMENTS *	PCLIENT_LOAD_LIBRARY_ARGUMENTS
typedef struct _GET_CHARSET_INFO	GET_CHARSET_INFO
typedef struct _GET_CHARSET_INFO *	PGET_CHARSET_INFO
typedef struct _SETWNDICONS_CALLBACK_ARGUMENTS	SETWNDICONS_CALLBACK_ARGUMENTS
typedef struct _SETWNDICONS_CALLBACK_ARGUMENTS *	PSETWNDICONS_CALLBACK_ARGUMENTS
typedef struct _DDEPOSTGET_CALLBACK_ARGUMENTS	DDEPOSTGET_CALLBACK_ARGUMENTS
typedef struct _DDEPOSTGET_CALLBACK_ARGUMENTS *	PDDEPOSTGET_CALLBACK_ARGUMENTS
typedef struct _SETOBM_CALLBACK_ARGUMENTS	SETOBM_CALLBACK_ARGUMENTS
typedef struct _SETOBM_CALLBACK_ARGUMENTS *	PSETOBM_CALLBACK_ARGUMENTS
typedef struct _LPK_CALLBACK_ARGUMENTS	LPK_CALLBACK_ARGUMENTS
typedef struct _LPK_CALLBACK_ARGUMENTS *	PLPK_CALLBACK_ARGUMENTS

Functions
NTSTATUS WINAPI	User32CallCopyImageFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallSetWndIconsFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallWindowProcFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallSendAsyncProcForKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32LoadSysMenuTemplateForKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32SetupDefaultCursors (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallHookProcFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallEventProcFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallLoadMenuFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallClientThreadSetupFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallClientLoadLibraryFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallGetCharsetInfo (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32DeliverUserAPC (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallDDEPostFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallDDEGetFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallOBMFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallLPKFromKernel (PVOID Arguments, ULONG ArgumentLength)
NTSTATUS WINAPI	User32CallUMPDFromKernel (PVOID Arguments, ULONG ArgumentLength)

Macro Definition Documentation

USER32_CALLBACK_CLIENTLOADLIBRARY

#define USER32_CALLBACK_CLIENTLOADLIBRARY   (8)

Definition at line 12 of file callback.h.

USER32_CALLBACK_CLIENTTHREADSTARTUP

#define USER32_CALLBACK_CLIENTTHREADSTARTUP   (7)

Definition at line 11 of file callback.h.

USER32_CALLBACK_COPYIMAGE

#define USER32_CALLBACK_COPYIMAGE   (10)

Definition at line 14 of file callback.h.

USER32_CALLBACK_DDEGET

#define USER32_CALLBACK_DDEGET   (14)

Definition at line 18 of file callback.h.

USER32_CALLBACK_DDEPOST

#define USER32_CALLBACK_DDEPOST   (13)

Definition at line 17 of file callback.h.

USER32_CALLBACK_DELIVERUSERAPC

#define USER32_CALLBACK_DELIVERUSERAPC   (12)

Definition at line 16 of file callback.h.

USER32_CALLBACK_EVENTPROC

#define USER32_CALLBACK_EVENTPROC   (5)

Definition at line 9 of file callback.h.

USER32_CALLBACK_GETCHARSETINFO

#define USER32_CALLBACK_GETCHARSETINFO   (9)

Definition at line 13 of file callback.h.

USER32_CALLBACK_HOOKPROC

#define USER32_CALLBACK_HOOKPROC   (4)

Definition at line 8 of file callback.h.

USER32_CALLBACK_LOADDEFAULTCURSORS

#define USER32_CALLBACK_LOADDEFAULTCURSORS   (3)

Definition at line 7 of file callback.h.

USER32_CALLBACK_LOADMENU

#define USER32_CALLBACK_LOADMENU   (6)

Definition at line 10 of file callback.h.

USER32_CALLBACK_LOADSYSMENUTEMPLATE

#define USER32_CALLBACK_LOADSYSMENUTEMPLATE   (2)

Definition at line 6 of file callback.h.

USER32_CALLBACK_LPK

#define USER32_CALLBACK_LPK   (16)

Definition at line 20 of file callback.h.

USER32_CALLBACK_MAXIMUM

#define USER32_CALLBACK_MAXIMUM   (17)

Definition at line 22 of file callback.h.

USER32_CALLBACK_SENDASYNCPROC

#define USER32_CALLBACK_SENDASYNCPROC   (1)

Definition at line 5 of file callback.h.

USER32_CALLBACK_SETOBM

#define USER32_CALLBACK_SETOBM   (15)

Definition at line 19 of file callback.h.

USER32_CALLBACK_SETWNDICONS

#define USER32_CALLBACK_SETWNDICONS   (11)

Definition at line 15 of file callback.h.

USER32_CALLBACK_UMPD

#define USER32_CALLBACK_UMPD   (17)

Definition at line 21 of file callback.h.

USER32_CALLBACK_WINDOWPROC

#define USER32_CALLBACK_WINDOWPROC   (0)

Definition at line 4 of file callback.h.

Typedef Documentation

CALL_BACK_INFO

typedef struct _CALL_BACK_INFO CALL_BACK_INFO

CLIENT_LOAD_LIBRARY_ARGUMENTS

typedef struct _CLIENT_LOAD_LIBRARY_ARGUMENTS CLIENT_LOAD_LIBRARY_ARGUMENTS

COPYIMAGE_CALLBACK_ARGUMENTS

typedef struct _COPYIMAGE_CALLBACK_ARGUMENTS COPYIMAGE_CALLBACK_ARGUMENTS

CWP_Struct

typedef struct tagCWP_Struct CWP_Struct

CWPR_Struct

typedef struct tagCWPR_Struct CWPR_Struct

DDEPOSTGET_CALLBACK_ARGUMENTS

typedef struct _DDEPOSTGET_CALLBACK_ARGUMENTS DDEPOSTGET_CALLBACK_ARGUMENTS

EVENTPROC_CALLBACK_ARGUMENTS

typedef struct _EVENTPROC_CALLBACK_ARGUMENTS EVENTPROC_CALLBACK_ARGUMENTS

GET_CHARSET_INFO

typedef struct _GET_CHARSET_INFO GET_CHARSET_INFO

HOOKPROC_CALLBACK_ARGUMENTS

typedef struct _HOOKPROC_CALLBACK_ARGUMENTS HOOKPROC_CALLBACK_ARGUMENTS

HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS

typedef struct _HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS

LOADMENU_CALLBACK_ARGUMENTS

typedef struct _LOADMENU_CALLBACK_ARGUMENTS LOADMENU_CALLBACK_ARGUMENTS

LPK_CALLBACK_ARGUMENTS

typedef struct _LPK_CALLBACK_ARGUMENTS LPK_CALLBACK_ARGUMENTS

PCALL_BACK_INFO

typedef struct _CALL_BACK_INFO * PCALL_BACK_INFO

PCLIENT_LOAD_LIBRARY_ARGUMENTS

typedef struct _CLIENT_LOAD_LIBRARY_ARGUMENTS * PCLIENT_LOAD_LIBRARY_ARGUMENTS

PCOPYIMAGE_CALLBACK_ARGUMENTS

typedef struct _COPYIMAGE_CALLBACK_ARGUMENTS * PCOPYIMAGE_CALLBACK_ARGUMENTS

PCWP_Struct

typedef struct tagCWP_Struct * PCWP_Struct

PCWPR_Struct

typedef struct tagCWPR_Struct * PCWPR_Struct

PDDEPOSTGET_CALLBACK_ARGUMENTS

typedef struct _DDEPOSTGET_CALLBACK_ARGUMENTS * PDDEPOSTGET_CALLBACK_ARGUMENTS

PEVENTPROC_CALLBACK_ARGUMENTS

typedef struct _EVENTPROC_CALLBACK_ARGUMENTS * PEVENTPROC_CALLBACK_ARGUMENTS

PGET_CHARSET_INFO

typedef struct _GET_CHARSET_INFO * PGET_CHARSET_INFO

PHOOKPROC_CALLBACK_ARGUMENTS

typedef struct _HOOKPROC_CALLBACK_ARGUMENTS * PHOOKPROC_CALLBACK_ARGUMENTS

PHOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS

typedef struct _HOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS * PHOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS

PLOADMENU_CALLBACK_ARGUMENTS

typedef struct _LOADMENU_CALLBACK_ARGUMENTS * PLOADMENU_CALLBACK_ARGUMENTS

PLPK_CALLBACK_ARGUMENTS

typedef struct _LPK_CALLBACK_ARGUMENTS * PLPK_CALLBACK_ARGUMENTS

PSENDASYNCPROC_CALLBACK_ARGUMENTS

typedef struct _SENDASYNCPROC_CALLBACK_ARGUMENTS * PSENDASYNCPROC_CALLBACK_ARGUMENTS

PSETOBM_CALLBACK_ARGUMENTS

typedef struct _SETOBM_CALLBACK_ARGUMENTS * PSETOBM_CALLBACK_ARGUMENTS

PSETWNDICONS_CALLBACK_ARGUMENTS

typedef struct _SETWNDICONS_CALLBACK_ARGUMENTS * PSETWNDICONS_CALLBACK_ARGUMENTS

PWINDOWPROC_CALLBACK_ARGUMENTS

typedef struct _WINDOWPROC_CALLBACK_ARGUMENTS * PWINDOWPROC_CALLBACK_ARGUMENTS

SENDASYNCPROC_CALLBACK_ARGUMENTS

typedef struct _SENDASYNCPROC_CALLBACK_ARGUMENTS SENDASYNCPROC_CALLBACK_ARGUMENTS

SETOBM_CALLBACK_ARGUMENTS

typedef struct _SETOBM_CALLBACK_ARGUMENTS SETOBM_CALLBACK_ARGUMENTS

SETWNDICONS_CALLBACK_ARGUMENTS

typedef struct _SETWNDICONS_CALLBACK_ARGUMENTS SETWNDICONS_CALLBACK_ARGUMENTS

WINDOWPROC_CALLBACK_ARGUMENTS

typedef struct _WINDOWPROC_CALLBACK_ARGUMENTS WINDOWPROC_CALLBACK_ARGUMENTS

Function Documentation

User32CallClientLoadLibraryFromKernel()

NTSTATUS WINAPI User32CallClientLoadLibraryFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 528 of file hook.c.

{
    BOOL bResult;
    PCLIENT_LOAD_LIBRARY_ARGUMENTS Argument;

    /* Retireve the callback parameters */
    Argument = (PCLIENT_LOAD_LIBRARY_ARGUMENTS)Arguments;
    if(Argument->strLibraryName.Buffer != NULL)
    {
        Argument->strLibraryName.Buffer = (PWCHAR)((ULONG_PTR)Argument->strLibraryName.Buffer + (ULONG_PTR)Argument);
    }
    if(Argument->strInitFuncName.Buffer != NULL)
    {
        Argument->strInitFuncName.Buffer = (PWCHAR)((ULONG_PTR)Argument->strInitFuncName.Buffer + (ULONG_PTR)Argument);
    }

    /* Call the implementation of the callback */
    bResult = ClientLoadLibrary(&Argument->strLibraryName,
                                &Argument->strInitFuncName,
                                Argument->Unload,
                                Argument->ApiHook);

    return ZwCallbackReturn(&bResult, sizeof(HINSTANCE), STATUS_SUCCESS);
}

User32CallClientThreadSetupFromKernel()

NTSTATUS WINAPI User32CallClientThreadSetupFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 578 of file dllmain.c.

{
  TRACE("User32CallClientThreadSetupFromKernel -->\n");
  // FIXME: Disabling this call is a HACK!! See also ClientThreadSetup...
  // ClientThreadSetupHelper(TRUE);
  TRACE("<-- User32CallClientThreadSetupFromKernel\n");
  return ZwCallbackReturn(NULL, 0, STATUS_SUCCESS);
}

User32CallCopyImageFromKernel()

NTSTATUS WINAPI User32CallCopyImageFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 1938 of file cursoricon.c.

{
  PCOPYIMAGE_CALLBACK_ARGUMENTS Common;
  HANDLE Result;
  Common = (PCOPYIMAGE_CALLBACK_ARGUMENTS) Arguments;

  Result = CopyImage(Common->hImage,
                     Common->uType,
                     Common->cxDesired,
                     Common->cyDesired,
                     Common->fuFlags);

  return ZwCallbackReturn(&Result, sizeof(HANDLE), STATUS_SUCCESS);
}

User32CallDDEGetFromKernel()

NTSTATUS WINAPI User32CallDDEGetFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 288 of file dde.c.

{
  BOOL Ret;
  NTSTATUS Status = STATUS_SUCCESS;
  PDDEPOSTGET_CALLBACK_ARGUMENTS Common = Arguments;

  TRACE("DDE Get CB size %d\n",Common->size);

  Ret = unpack_dde_message( Common->hwnd, Common->message, &Common->lParam, Common->buffer, Common->size );

  if (!Ret)
  {
     ERR("DDE Get CB Return bad msg 0x%x\n",Common->message);
     Status = STATUS_UNSUCCESSFUL;
  }
  return ZwCallbackReturn(Arguments, ArgumentLength, Status);
}

User32CallDDEPostFromKernel()

NTSTATUS WINAPI User32CallDDEPostFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 256 of file dde.c.

{
  struct packed_message data;
  BOOL Ret;
  NTSTATUS Status = STATUS_SUCCESS;
  PDDEPOSTGET_CALLBACK_ARGUMENTS Common = Arguments;

  data.data = 0;
  data.size = 0;
  TRACE("DDE Post CB\n");
  Ret = post_dde_message( &data, Common->message, Common->lParam, &Common->lParam);

  if (Ret)
  {
     Common->pvData = (PVOID)data.data;
     Common->size = data.size;
     TRACE("DDE Post CB size %d\n",data.size);
  }
  else
  {
     ERR("DDE Post CB Return bad msg 0x%x Size %d\n",Common->message,Common->size);
     Status = STATUS_UNSUCCESSFUL;
  }

  return ZwCallbackReturn(Arguments, ArgumentLength, Status);
}

User32CallEventProcFromKernel()

NTSTATUS WINAPI User32CallEventProcFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 795 of file hook.c.

{
  PEVENTPROC_CALLBACK_ARGUMENTS Common;
  WINEVENTPROC Proc;
  WCHAR module[MAX_PATH];
  DWORD len;
  HMODULE mod = NULL;
  BOOL Loaded = FALSE;

  Common = (PEVENTPROC_CALLBACK_ARGUMENTS) Arguments;

  Proc = Common->Proc;

  if (Common->offPfn && Common->Mod)
  {  // Validate the module again.
     if (!(len = GetModuleFileNameW((HINSTANCE)Common->Mod, module, MAX_PATH)) || len >= MAX_PATH)
     {
        ERR("Error check for module!\n");
        Common->Mod = 0;
     }

     if (Common->Mod && !(mod = GetModuleHandleW(module)))
     {
        TRACE("Reloading Event Module.\n");
        if (!(mod = LoadLibraryExW(module, NULL, LOAD_WITH_ALTERED_SEARCH_PATH)))
        {
           ERR("Failed to load Event Module.\n");
        }
        else
        {
           Loaded = TRUE; // Free it only when loaded.
        }
     }

     if (mod)
     {
        TRACE("Loading Event Module. %S\n",module);
        Proc = (WINEVENTPROC)((char *)mod + Common->offPfn);
     }
  }

  Proc(Common->hook,
       Common->event,
       Common->hwnd,
       Common->idObject,
       Common->idChild,
       Common->dwEventThread,
       Common->dwmsEventTime);

  if (Loaded) FreeLibrary(mod);

  return ZwCallbackReturn(NULL, 0, STATUS_SUCCESS);
}

User32CallGetCharsetInfo()

NTSTATUS WINAPI User32CallGetCharsetInfo	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 589 of file dllmain.c.

{
  BOOL Ret;
  PGET_CHARSET_INFO pgci = (PGET_CHARSET_INFO)Arguments;

  TRACE("GetCharsetInfo\n");

  Ret = TranslateCharsetInfo((DWORD *)(ULONG_PTR)pgci->Locale, &pgci->Cs, TCI_SRCLOCALE);

  return ZwCallbackReturn(Arguments, ArgumentLength, Ret ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}

User32CallHookProcFromKernel()

NTSTATUS WINAPI User32CallHookProcFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 554 of file hook.c.

{
  PHOOKPROC_CALLBACK_ARGUMENTS Common;
  CREATESTRUCTW *pCsw = NULL;
  CBT_CREATEWNDW *pCbtCreatewndw = NULL;
  PHOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS CbtCreatewndExtra = NULL;
  KBDLLHOOKSTRUCT KeyboardLlData, *pKeyboardLlData;
  MSLLHOOKSTRUCT MouseLlData, *pMouseLlData;
  MSG *pcMsg, *pMsg;
  PMOUSEHOOKSTRUCT pMHook;
  CWPSTRUCT *pCWP;
  CWPRETSTRUCT *pCWPR;
  PRECTL prl;
  LPCBTACTIVATESTRUCT pcbtas;
  HOOKPROC Proc;
  WPARAM wParam = 0;
  LPARAM lParam = 0;
  LRESULT Result = 0;
  BOOL Hit = FALSE, Loaded = FALSE;
  HMODULE mod = NULL;
  NTSTATUS Status = STATUS_SUCCESS;

  Common = (PHOOKPROC_CALLBACK_ARGUMENTS) Arguments;

  Proc = Common->Proc;
  // HookProc Justin Case module is from another process.
  if (Common->offPfn && Common->Mod)
  {
     if (!(mod = GetModuleHandleW((LPCWSTR)Common->ModuleName)))
     {
        TRACE("Reloading Hook Module.\n");
        if (!(mod = LoadLibraryExW((LPCWSTR)Common->ModuleName, NULL, LOAD_WITH_ALTERED_SEARCH_PATH)))
        {
           ERR("Failed to load Hook Module.\n");
        }
        else
        {
           Loaded = TRUE; // Free it only when loaded.
        }
     }
     if (mod)
     {
        TRACE("Loading Hook Module. %S\n",Common->ModuleName);
        Proc = (HOOKPROC)((char *)mod + Common->offPfn);
     }
  }

  switch(Common->HookId)
  {
    case WH_CBT:
    {
      //ERR("WH_CBT: Code %d\n", Common->Code);
      switch(Common->Code)
      {
        case HCBT_CREATEWND:
          CbtCreatewndExtra = (PHOOKPROC_CBT_CREATEWND_EXTRA_ARGUMENTS)
                              ((PCHAR) Common + Common->lParam);

          pCbtCreatewndw = (CBT_CREATEWNDW*)HeapAlloc(GetProcessHeap(), 0, sizeof(CBT_CREATEWNDW));
          RtlCopyMemory(pCbtCreatewndw, CbtCreatewndExtra, sizeof(CBT_CREATEWNDW));

          pCsw = (CREATESTRUCTW*)HeapAlloc(GetProcessHeap(), 0, sizeof(CREATESTRUCTW));
          RtlCopyMemory(pCsw, &CbtCreatewndExtra->Cs, sizeof(CREATESTRUCTW));

          pCbtCreatewndw->lpcs = pCsw;
          pCbtCreatewndw->hwndInsertAfter = CbtCreatewndExtra->WndInsertAfter;
          wParam = Common->wParam;
          lParam = (LPARAM) pCbtCreatewndw;
          //ERR("HCBT_CREATEWND: hWnd %p Csw %p Name %p Class %p\n", Common->wParam, pCsw, pCsw->lpszName, pCsw->lpszClass);
          break;
        case HCBT_CLICKSKIPPED:
            pMHook = (PMOUSEHOOKSTRUCT)((PCHAR) Common + Common->lParam);
            lParam = (LPARAM) pMHook;
            wParam = Common->wParam;
            break;
        case HCBT_MOVESIZE:
            prl = (PRECTL)((PCHAR) Common + Common->lParam);
            lParam = (LPARAM) prl;
            wParam = Common->wParam;
            break;
        case HCBT_ACTIVATE:
            //ERR("HCBT_ACTIVATE: hwnd %p\n",Common->wParam);
            pcbtas = (LPCBTACTIVATESTRUCT)((PCHAR) Common + Common->lParam);
            lParam = (LPARAM) pcbtas;
            wParam = Common->wParam;
            break;
        case HCBT_KEYSKIPPED: /* The rest SEH support */
        case HCBT_MINMAX:
        case HCBT_SETFOCUS:
        case HCBT_SYSCOMMAND:
        case HCBT_DESTROYWND:
        case HCBT_QS:
            wParam = Common->wParam;
            lParam = Common->lParam;
            break;
        default:
          if (Loaded) FreeLibrary(mod);
          ERR("HCBT_ not supported = %d\n", Common->Code);
          return ZwCallbackReturn(NULL, 0, STATUS_NOT_SUPPORTED);
      }

      if (Proc)
      {
         _SEH2_TRY
         {
            Result = Proc(Common->Code, wParam, lParam);
         }
         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
         {
            Hit = TRUE;
         }
         _SEH2_END;
      }
      else
      {
         ERR("Null Proc! Common = 0x%x, Proc = 0x%x\n",Common,Proc);
      }
      switch(Common->Code)
      {
        case HCBT_CREATEWND:
          CbtCreatewndExtra->WndInsertAfter = pCbtCreatewndw->hwndInsertAfter;
          CbtCreatewndExtra->Cs.x  = pCbtCreatewndw->lpcs->x;
          CbtCreatewndExtra->Cs.y  = pCbtCreatewndw->lpcs->y;
          CbtCreatewndExtra->Cs.cx = pCbtCreatewndw->lpcs->cx;
          CbtCreatewndExtra->Cs.cy = pCbtCreatewndw->lpcs->cy;
          HeapFree(GetProcessHeap(), 0, pCsw);
          HeapFree(GetProcessHeap(), 0, pCbtCreatewndw);
          break;
      }
      break;
    }
    case WH_KEYBOARD_LL:
      //ERR("WH_KEYBOARD_LL: Code %d, wParam %d\n",Common->Code,Common->wParam);
      pKeyboardLlData = (PKBDLLHOOKSTRUCT)((PCHAR) Common + Common->lParam);
      RtlCopyMemory(&KeyboardLlData, pKeyboardLlData, sizeof(KBDLLHOOKSTRUCT));
      Result = Proc(Common->Code, Common->wParam, (LPARAM) &KeyboardLlData);
      break;
    case WH_MOUSE_LL:
      //ERR("WH_MOUSE_LL: Code %d, wParam %d\n",Common->Code,Common->wParam);
      pMouseLlData = (PMSLLHOOKSTRUCT)((PCHAR) Common + Common->lParam);
      RtlCopyMemory(&MouseLlData, pMouseLlData, sizeof(MSLLHOOKSTRUCT));
      Result = Proc(Common->Code, Common->wParam, (LPARAM) &MouseLlData);
      break;
    case WH_MOUSE: /* SEH support */
      pMHook = (PMOUSEHOOKSTRUCT)((PCHAR) Common + Common->lParam);
      _SEH2_TRY
      {
         Result = Proc(Common->Code, Common->wParam, (LPARAM) pMHook);
      }
      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
      {
         Hit = TRUE;
      }
      _SEH2_END;
      break;
    case WH_CALLWNDPROC:
    {
      PCWP_Struct pcwps = (PCWP_Struct)Common;
      CWPSTRUCT *pCWPT = &pcwps->cwps;
      pCWP = HeapAlloc(GetProcessHeap(), 0, Common->lParamSize + sizeof(CWPSTRUCT));
      RtlCopyMemory(pCWP, pCWPT, sizeof(CWPSTRUCT));
//      ERR("WH_CALLWNDPROC: Code %d, wParam %d msg %d\n",Common->Code,Common->wParam,pCWP->message);
      /* If more memory is reserved, then lParam is a pointer.
       * Size of the buffer is stocked in the lParam member, and its content
       * is at the end of the argument buffer */
      if ( Common->lParamSize )
      {
         pCWP->lParam = (LPARAM)((PCHAR)pCWP + sizeof(CWPSTRUCT));
         RtlCopyMemory( (PCHAR)pCWP + sizeof(CWPSTRUCT), &pcwps->Extra, Common->lParamSize );
      }
      Result = Proc(Common->Code, Common->wParam, (LPARAM) pCWP);
      HeapFree(GetProcessHeap(), 0, pCWP);
    }
      break;
    case WH_CALLWNDPROCRET:
      /* Almost the same as WH_CALLWNDPROC */
    {
      PCWPR_Struct pcwprs = (PCWPR_Struct)Common;
      CWPRETSTRUCT *pCWPRT = &pcwprs->cwprs;
      pCWPR = HeapAlloc(GetProcessHeap(), 0, Common->lParamSize + sizeof(CWPRETSTRUCT));
      RtlCopyMemory(pCWPR, pCWPRT, sizeof(CWPSTRUCT));
      if ( Common->lParamSize )
      {
         pCWPR->lParam = (LPARAM)((PCHAR)pCWPR + sizeof(CWPRETSTRUCT));
         RtlCopyMemory( (PCHAR)pCWPR + sizeof(CWPRETSTRUCT), &pcwprs->Extra, Common->lParamSize );
      }
      Result = Proc(Common->Code, Common->wParam, (LPARAM) pCWPR);
      HeapFree(GetProcessHeap(), 0, pCWPR);
    }
      break;
    case WH_MSGFILTER: /* All SEH support */
    case WH_SYSMSGFILTER:
    case WH_GETMESSAGE:
      pMsg = (PMSG)((PCHAR) Common + Common->lParam);
      pcMsg = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MSG));
      RtlCopyMemory(pcMsg, pMsg, sizeof(MSG));
//      ERR("pMsg %d  pcMsg %d\n",pMsg->message, pcMsg->message);
      _SEH2_TRY
      {
         Result = Proc(Common->Code, Common->wParam, (LPARAM) pcMsg);
      }
      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
      {
         Hit = TRUE;
      }
      _SEH2_END;
      if (!Hit && Common->HookId == WH_GETMESSAGE)
         RtlCopyMemory(pMsg, pcMsg, sizeof(MSG));
      HeapFree( GetProcessHeap(), 0, pcMsg );
      break;
    case WH_KEYBOARD:
    case WH_SHELL:
      Result = Proc(Common->Code, Common->wParam, Common->lParam);
      break;
    case WH_FOREGROUNDIDLE: /* <-- SEH support */
      _SEH2_TRY
      {
         Result = Proc(Common->Code, Common->wParam, Common->lParam);
      }
      _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
      {
         Hit = TRUE;
      }
      _SEH2_END;
      break;
    default:
      if (Loaded) FreeLibrary(mod);
      ERR("WH_ not supported = %d\n", Common->HookId);
      return ZwCallbackReturn(NULL, 0, STATUS_NOT_SUPPORTED);
  }
  if (Hit)
  {
     ERR("Hook Exception! Id: %d, Code %d, Proc 0x%x\n",Common->HookId,Common->Code,Proc);
     Status = STATUS_UNSUCCESSFUL;
  }
  if (Loaded) FreeLibrary(mod);
  Common->Result = Result;
  return ZwCallbackReturn(Arguments, ArgumentLength, Status);
}

User32CallLoadMenuFromKernel()

NTSTATUS WINAPI User32CallLoadMenuFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 665 of file menu.c.

{
  PLOADMENU_CALLBACK_ARGUMENTS Common;
  LRESULT Result;

  Common = (PLOADMENU_CALLBACK_ARGUMENTS) Arguments;

  Result = (LRESULT)LoadMenuW(Common->hModule, Common->InterSource ? MAKEINTRESOURCEW(Common->InterSource) : (LPCWSTR)&Common->MenuName);

  return ZwCallbackReturn(&Result, sizeof(LRESULT), STATUS_SUCCESS);
}

User32CallLPKFromKernel()

NTSTATUS WINAPI User32CallLPKFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 664 of file dllmain.c.

{
    BOOL bResult;
    PLPK_CALLBACK_ARGUMENTS Argument;

    Argument = (PLPK_CALLBACK_ARGUMENTS)Arguments;

    Argument->lpString = (LPWSTR)((ULONG_PTR)Argument->lpString + (ULONG_PTR)Argument);

    bResult = ExtTextOutW(Argument->hdc,
                          Argument->x,
                          Argument->y,
                          Argument->flags,
                          (Argument->bRect) ? &Argument->rect : NULL,
                          Argument->lpString,
                          Argument->count,
                          NULL);

    return ZwCallbackReturn(&bResult, sizeof(BOOL), STATUS_SUCCESS);
}

User32CallOBMFromKernel()

NTSTATUS WINAPI User32CallOBMFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 632 of file dllmain.c.

{
  BITMAP bmp;
  PSETOBM_CALLBACK_ARGUMENTS Common = Arguments;

  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_CLOSE)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_CLOSE].cx = bmp.bmWidth;
  Common->oembmi[OBI_CLOSE].cy = bmp.bmHeight;

  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_MNARROW)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_MNARROW].cx = bmp.bmWidth;
  Common->oembmi[OBI_MNARROW].cy = bmp.bmHeight;

  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_DNARROW)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_DNARROW].cx = bmp.bmWidth;
  Common->oembmi[OBI_DNARROW].cy = bmp.bmHeight;

  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_DNARROWI)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_DNARROWI].cx = bmp.bmWidth;
  Common->oembmi[OBI_DNARROWI].cy = bmp.bmHeight;

  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_UPARROW)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_UPARROW].cx = bmp.bmWidth;
  Common->oembmi[OBI_UPARROW].cy = bmp.bmHeight;

  GetObjectW(LoadBitmapW(0, MAKEINTRESOURCEW(OBM_UPARROWI)), sizeof(bmp), &bmp);
  Common->oembmi[OBI_UPARROWI].cx = bmp.bmWidth;
  Common->oembmi[OBI_UPARROWI].cy = bmp.bmHeight;

  return ZwCallbackReturn(Arguments, ArgumentLength, STATUS_SUCCESS);
}

User32CallSendAsyncProcForKernel()

NTSTATUS WINAPI User32CallSendAsyncProcForKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 24 of file window.c.

{
    PSENDASYNCPROC_CALLBACK_ARGUMENTS CallbackArgs;

    TRACE("User32CallSendAsyncProcKernel()\n");

    CallbackArgs = (PSENDASYNCPROC_CALLBACK_ARGUMENTS)Arguments;

    if (ArgumentLength != sizeof(SENDASYNCPROC_CALLBACK_ARGUMENTS))
    {
        return(STATUS_INFO_LENGTH_MISMATCH);
    }

    CallbackArgs->Callback(CallbackArgs->Wnd,
                           CallbackArgs->Msg,
                           CallbackArgs->Context,
                           CallbackArgs->Result);
    return(STATUS_SUCCESS);
}

User32CallSetWndIconsFromKernel()

NTSTATUS WINAPI User32CallSetWndIconsFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 603 of file dllmain.c.

{
  PSETWNDICONS_CALLBACK_ARGUMENTS Common = Arguments;

  if (!gpsi->hIconSmWindows)
  {
      Common->hIconSample    = LoadImageW(0, IDI_APPLICATION, IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconHand      = LoadImageW(0, IDI_HAND,        IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconQuestion  = LoadImageW(0, IDI_QUESTION,    IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconBang      = LoadImageW(0, IDI_EXCLAMATION, IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconNote      = LoadImageW(0, IDI_ASTERISK,    IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconWindows   = LoadImageW(0, IDI_WINLOGO,     IMAGE_ICON, 0, 0, LR_DEFAULTSIZE);
      Common->hIconSmWindows = LoadImageW(0, IDI_WINLOGO, IMAGE_ICON, GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), 0);
      hIconWindows   = Common->hIconWindows;
      hIconSmWindows = Common->hIconSmWindows;
  }
  ERR("hIconSmWindows %p hIconWindows %p \n",hIconSmWindows,hIconWindows);
  return ZwCallbackReturn(Arguments, ArgumentLength, STATUS_SUCCESS);
}

User32CallUMPDFromKernel()

NTSTATUS WINAPI User32CallUMPDFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 685 of file dllmain.c.

{
    DWORD Buffer[MAX_USER_MODE_DRV_BUFFER];
    INT cbSize = 0;
    NTSTATUS Status = STATUS_SUCCESS;
    PUMPDPKTHEAD pkt, pktOut = NULL;

    pkt = (PUMPDPKTHEAD)Arguments;

    if ( pkt->RetSize <= sizeof(Buffer) )
    {
        pktOut = (PUMPDPKTHEAD)Buffer;

        if ( (GdiPrinterThunk( pkt, pktOut, pkt->RetSize ) == GDI_ERROR) )
        {
            pktOut = NULL;
            Status = STATUS_UNSUCCESSFUL;
        }
        else
        {
            cbSize = pkt->RetSize;
        }
    }
    else
    {
       Status = STATUS_NO_MEMORY;   
    }
    return ZwCallbackReturn( pktOut, cbSize, Status );
}

User32CallWindowProcFromKernel()

NTSTATUS WINAPI User32CallWindowProcFromKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 2927 of file message.c.

{
  PWINDOWPROC_CALLBACK_ARGUMENTS CallbackArgs;
  MSG KMMsg, UMMsg;
  PWND pWnd = NULL;
  PCLIENTINFO pci = GetWin32ClientInfo();

  /* Make sure we don't try to access mem beyond what we were given */
  if (ArgumentLength < sizeof(WINDOWPROC_CALLBACK_ARGUMENTS))
    {
      return STATUS_INFO_LENGTH_MISMATCH;
    }

  CallbackArgs = (PWINDOWPROC_CALLBACK_ARGUMENTS) Arguments;
  KMMsg.hwnd = CallbackArgs->Wnd;
  KMMsg.message = CallbackArgs->Msg;
  KMMsg.wParam = CallbackArgs->wParam;
  KMMsg.time = 0;
  KMMsg.pt.x = 0;
  KMMsg.pt.y = 0;
  /* Check if lParam is really a pointer and adjust it if it is */
  if (0 <= CallbackArgs->lParamBufferSize)
    {
      if (ArgumentLength != sizeof(WINDOWPROC_CALLBACK_ARGUMENTS)
                            + CallbackArgs->lParamBufferSize)
        {
          return STATUS_INFO_LENGTH_MISMATCH;
        }
      KMMsg.lParam = (LPARAM) ((char *) CallbackArgs + sizeof(WINDOWPROC_CALLBACK_ARGUMENTS));
     switch(KMMsg.message)
     {
        case WM_CREATE:
        {
            TRACE("WM_CREATE CB %p lParam %p\n",CallbackArgs, KMMsg.lParam);
            break;
        }
        case WM_NCCREATE:
        {
            TRACE("WM_NCCREATE CB %p lParam %p\n",CallbackArgs, KMMsg.lParam);
            break;
        }
        case WM_SYSTIMER:
        {
            TRACE("WM_SYSTIMER %p\n",KMMsg.hwnd);
            break;
        }
        case WM_SIZING:
        {
           PRECT prect = (PRECT) KMMsg.lParam;
           TRACE("WM_SIZING 1 t %d l %d r %d b %d\n",prect->top,prect->left,prect->right,prect->bottom);
           break;
        }
        default:
           break;
     }
    }
  else
    {
      if (ArgumentLength != sizeof(WINDOWPROC_CALLBACK_ARGUMENTS))
        {
          return STATUS_INFO_LENGTH_MISMATCH;
        }
      KMMsg.lParam = CallbackArgs->lParam;
    }

  if (WM_NCCALCSIZE == CallbackArgs->Msg && CallbackArgs->wParam)
    {
      NCCALCSIZE_PARAMS *Params = (NCCALCSIZE_PARAMS *) KMMsg.lParam;
      Params->lppos = (PWINDOWPOS) (Params + 1);
    }

  if (! MsgiKMToUMMessage(&KMMsg, &UMMsg))
    {
    }

  if (pci->CallbackWnd.hWnd == UMMsg.hwnd)
     pWnd = pci->CallbackWnd.pWnd;

  CallbackArgs->Result = IntCallWindowProcW( CallbackArgs->IsAnsiProc,
                                             CallbackArgs->Proc,
                                             pWnd,
                                             UMMsg.hwnd,
                                             UMMsg.message,
                                             UMMsg.wParam,
                                             UMMsg.lParam);

  if (! MsgiKMToUMReply(&KMMsg, &UMMsg, &CallbackArgs->Result))
    {
    }

  if (0 <= CallbackArgs->lParamBufferSize)
  {
     switch(KMMsg.message)
     {
        case WM_SIZING:
        {
           PRECT prect = (PRECT) KMMsg.lParam;
           TRACE("WM_SIZING 2 t %d l %d r %d b %d\n",prect->top,prect->left,prect->right,prect->bottom);
           break;
        }
        default:
           break;
     }
  }
  return ZwCallbackReturn(CallbackArgs, ArgumentLength, STATUS_SUCCESS);
}

User32DeliverUserAPC()

NTSTATUS WINAPI User32DeliverUserAPC	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 625 of file dllmain.c.

{
  return ZwCallbackReturn(0, 0, STATUS_SUCCESS);
}

User32LoadSysMenuTemplateForKernel()

NTSTATUS WINAPI User32LoadSysMenuTemplateForKernel	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 655 of file menu.c.

{
  LRESULT Result = 0;

  // Use this for Menu Ole!!

  return(ZwCallbackReturn(&Result, sizeof(LRESULT), STATUS_SUCCESS));
}

User32SetupDefaultCursors()

NTSTATUS WINAPI User32SetupDefaultCursors	(	PVOID	Arguments,
		ULONG	ArgumentLength
	)

Definition at line 48 of file cursoricon.c.

{
    BOOL *DefaultCursor = (BOOL*)Arguments;
    HCURSOR hCursor;

    /* Load system cursors first */
    LoadSystemCursors();

    if(*DefaultCursor)
    {
        /* set default cursor */
        hCursor = LoadCursorW(0, IDC_ARROW);
        SetCursor(hCursor);
    }
    else
    {
        /* FIXME load system cursor scheme */
        SetCursor(0);
        hCursor = LoadCursorW(0, IDC_ARROW);
        SetCursor(hCursor);
    }

    return(ZwCallbackReturn(&hCursor, sizeof(HCURSOR), STATUS_SUCCESS));
}