archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 827363a95b
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '827363a95b'
${ noResults }
windows-server-2003/windows/core/ntuser/inc/ntcb.h

8113 lines
216 KiB
Raw Blame History

/****************************** Module Header ******************************\
* Module Name: ntcb.h
*
* Copyright (c) 1985 - 1999, Microsoft Corporation
*
* Kernel mode sending stubs
*
* 07-06-91 ScottLu Created.
\***************************************************************************/
/*
* Reserved bit in the Drive Letter bit mask of a
* WM_DEVICECHANGE message for the following wParam
* (DBT_DEVICEREMOVECOMPLETE or DBT_DEVICEARRIVAL)
* If this bit is set, then this message describes a change with
* global drive letters and we should check if the drive letters
* already exist in the receiver's LUID DosDevices.
* If drive letter exists in the user's LUID DosDevices, then
* un-set this drive letter in the msg's bitmask.
*/
#define DBV_FILTER_MSG 0x40000000
// If SERVER is UNICODE
// Copy UNICODE -> UNICODE
// or Copy ANSI -> UNICODE
// prototypes to client side functions only called by these stubs
// ddetrack.c
DWORD _ClientCopyDDEIn1(HANDLE hClient, PINTDDEINFO pi);
VOID _ClientCopyDDEIn2(PINTDDEINFO pi);
HANDLE _ClientCopyDDEOut1(PINTDDEINFO pi);
BOOL xxxClientCopyDDEIn2(PINTDDEINFO pi);
BOOL FixupDdeExecuteIfNecessary(HGLOBAL *phCommands, BOOL fNeedUnicode);
BOOL _ClientCopyDDEOut2(PINTDDEINFO pi);
BOOL _ClientFreeDDEHandle(HANDLE hDDE, DWORD flags);
DWORD _ClientGetDDEFlags(HANDLE hDDE, DWORD flags);
/*
* prototype for checking the drive letters used in the LUID DosDevice
* map. Does not check if the drive letters are used in the Global
* DosDevices
*/
#ifdef RECVSIDE
DWORD GetLUIDDosDrivesOnly();
#endif // RECVSIDE
typedef struct _GENERICHOOKHEADER {
DWORD nCode;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
} GENERICHOOKHEADER, * LPGENERICHOOKHEADER;
#ifdef RECVSIDE
ULONG_PTR CallHookWithSEH(GENERICHOOKHEADER *pmsg, LPVOID pData, LPDWORD pFlags, ULONG_PTR retval) {
try {
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->nCode,
pmsg->wParam,
pData,
pmsg->xParam);
} except ((*pFlags & HF_GLOBAL) ? W32ExceptionHandler(FALSE, RIP_WARNING) : EXCEPTION_CONTINUE_SEARCH) {
RIPMSG0(RIP_WARNING, "Hook Faulted");
*pFlags |= HF_HOOKFAULTED;
}
return retval;
}
#endif // RECVSIDE
/**************************************************************************\
* fnOUTDWORDDWORD
*
* 14-Aug-1992 mikeke created
\**************************************************************************/
typedef struct _FNOUTDWORDDWORDMSG {
PWND pwnd;
UINT msg;
ULONG_PTR xParam;
PROC xpfnProc;
} FNOUTDWORDDWORDMSG;
#ifdef SENDSIDE
SMESSAGECALL(OUTDWORDDWORD)
{
SETUPPWND(FNOUTDWORDDWORD)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNOUTDWORDDWORD)
LPDWORD lpdwW = (LPDWORD)wParam;
LPDWORD lpdwL = (LPDWORD)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNOUTDWORDDWORD);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
try {
*lpdwW = ProbeAndReadUlong((LPDWORD)pcbs->pOutput);
*lpdwL = ProbeAndReadUlong((LPDWORD)pcbs->pOutput + 1);
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
MSGERROR();
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnOUTDWORDDWORD");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnOUTDWORDDWORD, FNOUTDWORDDWORDMSG)
{
DWORD adwOut[2];
BEGINRECV(0, adwOut, sizeof(adwOut));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
&adwOut[0],
&adwOut[1],
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnOUTDWORDINDWORD
*
* 04-May-1993 IanJa created (for MN_FINDMENUWINDOWFROMPOINT)
\**************************************************************************/
typedef struct _FNOUTDWORDINDWORDMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNOUTDWORDINDWORDMSG;
#ifdef SENDSIDE
SMESSAGECALL(OUTDWORDINDWORD)
{
SETUPPWND(FNOUTDWORDINDWORD)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNOUTDWORDINDWORD)
LPDWORD lpdwW = (LPDWORD)wParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNOUTDWORDINDWORD);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
try {
*lpdwW = ProbeAndReadUlong((LPDWORD)pcbs->pOutput);
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
MSGERROR();
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnOUTDWORDINDWORD");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnOUTDWORDINDWORD, FNOUTDWORDINDWORDMSG)
{
DWORD dwOut;
BEGINRECV(0, &dwOut, sizeof(dwOut));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
&dwOut,
CALLDATA(lParam),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnOPTOUTLPDWORDOPTOUTLPDWORD
*
* 25-Nov-1992 JonPa created
\**************************************************************************/
typedef struct _FNOPTOUTLPDWORDOPTOUTLPDWORDMSG {
PWND pwnd;
UINT msg;
ULONG_PTR xParam;
PROC xpfnProc;
} FNOPTOUTLPDWORDOPTOUTLPDWORDMSG;
#ifdef SENDSIDE
SMESSAGECALL(OPTOUTLPDWORDOPTOUTLPDWORD)
{
SETUPPWND(FNOPTOUTLPDWORDOPTOUTLPDWORD)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNOPTOUTLPDWORDOPTOUTLPDWORD)
LPDWORD lpdwW = (LPDWORD)wParam;
LPDWORD lpdwL = (LPDWORD)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNOPTOUTLPDWORDOPTOUTLPDWORD);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
try {
if (lpdwW != NULL)
*lpdwW = ProbeAndReadUlong((LPDWORD)pcbs->pOutput);
if (lpdwL != NULL)
*lpdwL = ProbeAndReadUlong((LPDWORD)pcbs->pOutput + 1);
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
MSGERROR();
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnOPTOUTLPDWORDOPTOUTLPDWORD");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnOPTOUTLPDWORDOPTOUTLPDWORD, FNOPTOUTLPDWORDOPTOUTLPDWORDMSG)
{
DWORD adwOut[2];
BEGINRECV(0, adwOut, sizeof(adwOut));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
&adwOut[0],
&adwOut[1],
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnDWORDOPTINLPMSG
*
* 03-30-92 scottlu Created
\**************************************************************************/
typedef struct _FNDWORDOPTINLPMSGMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPMSG pmsgstruct;
ULONG_PTR xParam;
PROC xpfnProc;
MSG msgstruct;
} FNDWORDOPTINLPMSGMSG;
#ifdef SENDSIDE
SMESSAGECALL(DWORDOPTINLPMSG)
{
SETUPPWND(FNDWORDOPTINLPMSG)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNDWORDOPTINLPMSG)
LPMSG pmsgstruct = (LPMSG)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
COPYSTRUCTOPT(msgstruct);
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNDWORDOPTINLPMSG);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnDWORDOPTINLPMSG");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnDWORDOPTINLPMSG, FNDWORDOPTINLPMSGMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
PCALLDATAOPT(msgstruct),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnCOPYGLOBALDATA
*
* 6-20-92 Sanfords created
\**************************************************************************/
typedef struct _FNCOPYGLOBALDATAMSG {
CAPTUREBUF CaptureBuf;
DWORD cbSize;
PBYTE pData;
} FNCOPYGLOBALDATAMSG;
#ifdef SENDSIDE
SMESSAGECALL(COPYGLOBALDATA)
{
PBYTE pData = (PBYTE)lParam;
SETUPPWND(FNCOPYGLOBALDATA)
UNREFERENCED_PARAMETER(msg);
UNREFERENCED_PARAMETER(xParam);
UNREFERENCED_PARAMETER(xpfnProc);
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSENDCAPTURE(FNCOPYGLOBALDATA, 1, wParam, TRUE)
if (pData == 0) {
MSGERROR();
}
MSGDATA()->cbSize = (DWORD)wParam;
LARGECOPYBYTES(pData, (DWORD)wParam);
LOCKPWND();
MAKECALLCAPTURE(FNCOPYGLOBALDATA);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnCOPYGLOBALDATA");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnCOPYGLOBALDATA, FNCOPYGLOBALDATAMSG)
{
PBYTE p;
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)GlobalAlloc(GMEM_MOVEABLE, CALLDATA(cbSize));
if (p = GlobalLock((HANDLE)retval)) {
memcpy(p, (PVOID)CALLDATA(pData), CALLDATA(cbSize));
USERGLOBALUNLOCK((HANDLE)retval);
}
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnCOPYDATA
*
* 7-14-92 Sanfords created
\**************************************************************************/
typedef struct _FNCOPYDATAMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
HWND hwndFrom;
BOOL fDataPresent;
COPYDATASTRUCT cds;
ULONG_PTR xParam;
PROC xpfnProc;
} FNCOPYDATAMSG;
#ifdef SENDSIDE
SMESSAGECALL(COPYDATA)
{
HWND hwndFrom = (HWND)wParam;
PCOPYDATASTRUCT pcds = (PCOPYDATASTRUCT)lParam;
DWORD cCapture, cbCapture;
SETUPPWND(FNCOPYDATA)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
if (pcds == NULL) {
cCapture = cbCapture = 0;
} else {
cCapture = 1;
cbCapture = pcds->cbData;
}
BEGINSENDCAPTURE(FNCOPYDATA, cCapture, cbCapture, TRUE);
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->hwndFrom = hwndFrom;
if (pcds != NULL) {
MSGDATA()->fDataPresent = TRUE;
MSGDATA()->cds = *pcds;
LARGECOPYBYTES2(pcds->lpData, cbCapture, cds.lpData);
} else {
MSGDATA()->fDataPresent = FALSE;
}
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNCOPYDATA);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnCOPYDATA");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnCOPYDATA, FNCOPYDATAMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(hwndFrom),
CALLDATA(fDataPresent) ? PCALLDATA(cds) : NULL,
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnSENTDDEMSG
*
* 11-5-92 Sanfords created
*
* This thunks DDE messages that SHOULD be posted. It will only work for
* WOW apps. This thunking is strictly for WOW compatability. No 32 bit
* app should be allowed to get away with this practice because it opens
* the DDE protocol up to deadlocks.
\**************************************************************************/
typedef struct _FNSENTDDEMSGMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
ULONG_PTR xParam;
PROC xpfnProc;
BOOL fIsUnicodeProc;
} FNSENTDDEMSGMSG;
#ifdef SENDSIDE
SMESSAGECALL(SENTDDEMSG)
{
MSG msgs;
SETUPPWND(FNSENTDDEMSG)
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNSENTDDEMSG)
msg &= ~MSGFLAG_DDE_SPECIAL_SEND;
if (msg & MSGFLAG_DDE_MID_THUNK) {
/*
* complete the thunking here.
*/
msgs.hwnd = HW(pwnd);
msgs.message = msg & ~MSGFLAG_DDE_MID_THUNK;
msgs.wParam = wParam;
msgs.lParam = lParam;
xxxDDETrackGetMessageHook((PMSG)&msgs);
MSGDATA()->pwnd = (PWND)((PBYTE)PW(msgs.hwnd) -
pti->ulClientDelta);
MSGDATA()->msg = msgs.message;
MSGDATA()->wParam = msgs.wParam;
MSGDATA()->lParam = msgs.lParam;
} else {
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->lParam = lParam;
}
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MSGDATA()->fIsUnicodeProc = !(dwSCMSFlags & SCMS_FLAGS_ANSI);
LOCKPWND();
MAKECALL(FNSENTDDEMSG);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnSENTDDEMSG");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnSENTDDEMSG, FNSENTDDEMSGMSG)
{
BEGINRECV(0, NULL, 0);
/*
* A DDE message may have been sent via CallWindowProc due to subclassing.
* Since IsWindowUnicode() cannot properly tell what proc a message will
* ultimately reach, we make sure that the Ansi/Unicode form of any
* WM_DDE_EXECUTE data is correct for the documented convention and
* translate it as necessary.
*/
if (CALLDATA(msg) == WM_DDE_EXECUTE) {
BOOL fHandleChanged;
fHandleChanged = FixupDdeExecuteIfNecessary((HGLOBAL *)PCALLDATA(lParam),
CALLDATA(fIsUnicodeProc) &&
IsWindowUnicode((HWND)CALLDATA(wParam)));
/*
* NOTE:
* If the app didn't allocate this DDE memory GMEM_MOVEABLE,
* the fixup may require the handle value to change.
* If this happens things will fall appart when the other side
* or the tracking layer tries to free the old handle value.
*/
UserAssert(!fHandleChanged);
}
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
CALLDATA(lParam),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnDWORD
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNDWORDMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNDWORDMSG;
#ifdef SENDSIDE
SMESSAGECALL(DWORD)
{
SETUPPWND(FNDWORD)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNDWORD)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNDWORD);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnDWORD");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnDWORD, FNDWORDMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
CALLDATA(lParam),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnNCDESTROY
*
* 07-24-00 MHamid Created
\**************************************************************************/
typedef struct _FNNCDESTROYMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNNCDESTROYMSG;
#ifdef SENDSIDE
SMESSAGECALL(NCDESTROY)
{
SETUPPWND(FNNCDESTROY)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNNCDESTROY)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNNCDESTROY);
pwnd->pActCtx = NULL;
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnNCDESTROY");
ENDSEND(LRESULT, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnNCDESTROY, FNNCDESTROYMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
CALLDATA(lParam),
CALLDATA(xParam));
if (CALLDATA(pwnd)->pActCtx) {
RtlReleaseActivationContext(CALLDATA(pwnd)->pActCtx);
}
#ifdef LAME_BUTTON
if (GetProp(HW(CALLDATA(pwnd)), MAKEINTATOM(gatomLameButton)) != NULL) {
UserLocalFree(GetProp(HW(CALLDATA(pwnd)), MAKEINTATOM(gatomLameButton)));
SetProp(HW(CALLDATA(pwnd)), MAKEINTATOM(gatomLameButton), NULL);
}
#endif // LAME_BUTTON
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINWPARAMCHAR
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINWPARAMCHARMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINWPARAMCHARMSG;
#ifdef SENDSIDE
SMESSAGECALL(INWPARAMCHAR)
{
SETUPPWND(FNINWPARAMCHAR)
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINWPARAMCHAR)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
/*
* WM_CHARTOITEM has an index in the hi-word of wParam
*/
if (dwSCMSFlags & SCMS_FLAGS_ANSI) {
if (msg == WM_CHARTOITEM || msg == WM_MENUCHAR) {
WPARAM dwT = wParam & 0xFFFF; // mask of caret pos
RtlWCSMessageWParamCharToMB(msg, &dwT); // convert key portion
UserAssert(HIWORD(dwT) == 0);
wParam = MAKELONG(LOWORD(dwT),HIWORD(wParam)); // rebuild pos & key wParam
} else {
RtlWCSMessageWParamCharToMB(msg, &wParam);
}
}
MSGDATA()->wParam = wParam;
MSGDATA()->lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNDWORD);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINWPARAMCHAR");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
/*
* The fnDWORD routine is used for this message
*/
#endif // RECVSIDE
/**************************************************************************\
* fnINWPARAMDBCSCHAR
*
* 12-Feb-1996 hideyukn Created
\**************************************************************************/
typedef struct _FNINWPARAMDBCSCHARMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
ULONG_PTR xParam;
PROC xpfnProc;
BOOL bAnsi;
} FNINWPARAMDBCSCHARMSG;
#ifdef SENDSIDE
SMESSAGECALL(INWPARAMDBCSCHAR)
{
SETUPPWND(FNINWPARAMDBCSCHAR)
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINWPARAMDBCSCHAR)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->bAnsi = dwSCMSFlags & SCMS_FLAGS_ANSI;
/*
* wParam in WM_CHAR/EM_SETPASSWORDCHAR should be converted to ANSI
* ,if target is ANSI.
*/
if (dwSCMSFlags & SCMS_FLAGS_ANSI) {
RtlWCSMessageWParamCharToMB(msg, &wParam);
}
MSGDATA()->wParam = wParam;
MSGDATA()->lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINWPARAMDBCSCHAR);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINWPARAMDBCSCHAR");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINWPARAMDBCSCHAR, FNINWPARAMDBCSCHARMSG)
{
BOOL bAnsiWndProc;
BEGINRECV(0,NULL,0);
bAnsiWndProc = CALLDATA(bAnsi);
if (bAnsiWndProc) {
PKERNEL_MSG pmsgDbcsCB = GetCallBackDbcsInfo();
WPARAM wParam = pmsg->wParam;
BOOL bDbcsMessaging = FALSE;
//
// Check wParam has Dbcs character or not..
//
if (IS_DBCS_MESSAGE(pmsg->wParam)) {
if (pmsg->wParam & WMCR_IR_DBCSCHAR) {
//
// This is reply for WM_IME_REPORT:IR_DBCSCHAR, then
// We send DBCS chararcter at one time...
// (Do not need to send twice for DBCS LeadByte and TrailByte).
//
// Validation for wParam.. (mask off the secret bit).
//
wParam = (pmsg->wParam & 0x0000FFFF);
} else {
//
// Mark the wParam keeps Dbcs character..
//
bDbcsMessaging = TRUE;
//
// Backup current message. this backupped message will be used
// when Apps peek (or get) message from thier WndProc.
// (see GetMessageA(), PeekMessageA()...)
//
// pmsgDbcsCB->hwnd = HW(pmsg->pwnd);
// pmsgDbcsCB->message = pmsg->msg;
// pmsgDbcsCB->wParam = pmsg->wParam;
// pmsgDbcsCB->lParam = pmsg->lParam;
// pmsgDbcsCB->time = pmsg->time;
// pmsgDbcsCB->pt = pmsg->pt;
//
COPY_MSG_TO_KERNELMSG(pmsgDbcsCB,(PMSG)pmsg);
//
// pwnd should be converted to hwnd.
//
pmsgDbcsCB->hwnd = HW(pmsg->pwnd);
//
// DbcsLeadByte will be sent below soon, we just need DbcsTrailByte
// for further usage..
//
pmsgDbcsCB->wParam = (pmsg->wParam & 0x000000FF);
//
// Pass the LeadingByte of the DBCS character to an ANSI WndProc.
//
wParam = (pmsg->wParam & 0x0000FF00) >> 8;
}
}
//
// Forward Dbcs LeadingByte or Sbcs character to Apps WndProc.
//
retval = CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
wParam,
CALLDATA(lParam),
CALLDATA(xParam) );
//
// Check we need to send trailing byte or not, if the wParam has Dbcs character.
//
if (bDbcsMessaging && pmsgDbcsCB->wParam) {
//
// If an app didn't peek (or get) the trailing byte from within
// WndProc, and then pass the DBCS TrailingByte to the ANSI WndProc here
// pmsgDbcsCB->wParam has DBCS TrailingByte here.. see above..
//
wParam = KERNEL_WPARAM_TO_WPARAM(pmsgDbcsCB->wParam);
//
// Invalidate cached message.
//
pmsgDbcsCB->wParam = 0;
retval = CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
wParam,
CALLDATA(lParam),
CALLDATA(xParam) );
} else {
//
// If an app called Get/PeekMessageA from its
// WndProc, do not do anything.
//
}
} else {
//
// Only LOWORD of WPARAM is valid for WM_CHAR....
// (Mask off DBCS messaging information.)
//
pmsg->wParam &= 0x0000FFFF;
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
pmsg->lParam,
pmsg->xParam);
}
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINOUTDRAGMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
DROPSTRUCT ds;
} FNINOUTDRAGMSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTDRAG)
{
SETUPPWND(FNINOUTDRAG)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNINOUTDRAG)
LPDROPSTRUCT pds = (LPDROPSTRUCT)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->ds = *pds;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINOUTDRAG);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(pds, DROPSTRUCT);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTDRAG");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTDRAG, FNINOUTDRAGMSG)
{
BEGINRECV(0, &pmsg->ds, sizeof(pmsg->ds));
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&pmsg->ds,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnGETTEXTLENGTHS
*
* Gets the Unicode & ANSI lengths
* Internally, lParam pints to the ANSI length in bytes and the return value
* is the Unicode length in bytes. However, the public definition is maintained
* on the client side, where lParam is not used and either ANSI or Unicode is
* returned.
*
* 10-Feb-1992 IanJa Created
\**************************************************************************/
typedef struct _FNGETTEXTLENGTHSMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNGETTEXTLENGTHSMSG;
#ifdef SENDSIDE
SMESSAGECALL(GETTEXTLENGTHS)
{
SETUPPWND(FNGETTEXTLENGTHS)
UNREFERENCED_PARAMETER(lParam);
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNGETTEXTLENGTHS)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNGETTEXTLENGTHS);
UNLOCKPWND();
CHECKRETURN();
/*
* ANSI client wndproc returns us cbANSI. We want cchUnicode,
* so we guess cchUnicode = cbANSI. (It may be less if
* multi-byte characters are involved, but it will never be more).
* Save cbANSI in *lParam in case the server ultimately returns
* the length to an ANSI caller.
*
* Unicode client wndproc returns us cchUnicode. If we want to know
* cbANSI, we must guess how many 'ANSI' chars we would need.
* We guess cbANSI = cchUnicode * 2. (It may be this much if all
* 'ANSI' characters are multi-byte, but it will never be more).
*
* Return cchUnicode (server code is all Unicode internally).
* Put cbANSI in *lParam to be passed along within the server in case
* we ultimately need to return it to the client.
*
* NOTE: this will sometimes cause text lengths to be misreported
* up to twice the real length, but that is expected to be harmless.
* This will only * happen if an app sends WM_GETcode TEXTLENGTH to a
* window with an ANSI client-side wndproc, or a ANSI WM_GETTEXTLENGTH
* is sent to a Unicode client-side wndproc.
*/
TRACECALLBACKMSG("SfnGETTEXTLENGTHS");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnGETTEXTLENGTHS, FNGETTEXTLENGTHSMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
0, // so we don't pass &cbAnsi to apps
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINLPCREATESTRUCTMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
CREATESTRUCT cs;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINLPCREATESTRUCTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPCREATESTRUCT)
{
PCREATESTRUCTEX pcreatestruct = (PCREATESTRUCTEX)lParam;
DWORD cbName = 0, cbClass = 0;
DWORD cCapture = 0;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
SETUPPWND(FNINLPCREATESTRUCT)
UNREFERENCED_PARAMETER(psms);
/*
* Compute ANSI capture lengths. Don't capture if
* the strings are in the client's address space.
*/
if (pcreatestruct) {
if (pcreatestruct->cs.lpszName &&
((BOOL)pcreatestruct->strName.bAnsi != fAnsiReceiver ||
IS_SYSTEM_ADDRESS((PVOID)pcreatestruct->cs.lpszName))) {
CALC_SIZE_IN(cbName, &pcreatestruct->strName);
cCapture++;
}
if (IS_PTR(pcreatestruct->cs.lpszClass) &&
((BOOL)pcreatestruct->strClass.bAnsi != fAnsiReceiver ||
IS_SYSTEM_ADDRESS((PVOID)pcreatestruct->cs.lpszClass))) {
CALC_SIZE_IN(cbClass, &pcreatestruct->strClass);
cCapture++;
}
}
BEGINSENDCAPTURE(FNINLPCREATESTRUCT, cCapture, cbName + cbClass, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->lParam = lParam; // this could be NULL in WOW apps!
if (pcreatestruct != NULL) {
MSGDATA()->cs = pcreatestruct->cs;
// Make it a "Large" copy because it could be an Edit control
if (cbName) {
if (!pcreatestruct->strName.bAnsi) {
WORD wOrdinal;
try {
wOrdinal = *(PWORD)pcreatestruct->cs.lpszName;
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
goto errorexit;
}
if (wOrdinal == 0xffff) {
/*
* Copy out an ordinal of the form 0xffff, ID.
* If the receiver is ANSI, skip the first 0xff.
*/
if (fAnsiReceiver) {
if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf,
(PBYTE)pcreatestruct->cs.lpszName + 1,
3, (PVOID *)&mp->cs.lpszName)))
goto errorexit;
} else {
if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf,
(PBYTE)pcreatestruct->cs.lpszName,
4, (PVOID *)&mp->cs.lpszName)))
goto errorexit;
}
} else if (fAnsiReceiver) {
LARGECOPYSTRINGLPWSTRA(&pcreatestruct->strName, cs.lpszName);
} else {
LARGECOPYSTRINGLPWSTR(&pcreatestruct->strName, cs.lpszName);
}
} else {
BYTE bOrdinal;
try {
bOrdinal = *(PBYTE)pcreatestruct->cs.lpszName;
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
goto errorexit;
}
if (bOrdinal == 0xff) {
/*
* Copy out an ordinal of the form 0xff, ID.
* If the receiver is UNICODE, expand the 0xff to 0xffff.
*/
if (fAnsiReceiver) {
if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf,
(PBYTE)pcreatestruct->cs.lpszName,
3, (PVOID *)&mp->cs.lpszName)))
goto errorexit;
} else {
DWORD dwOrdinal;
try {
dwOrdinal = MAKELONG(0xffff,
(*(DWORD UNALIGNED *)pcreatestruct->cs.lpszName >> 8));
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
goto errorexit;
}
if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf,
&dwOrdinal,
4, (PVOID *)&mp->cs.lpszName)))
goto errorexit;
}
} else if (fAnsiReceiver) {
LARGECOPYSTRINGLPSTR(&pcreatestruct->strName, cs.lpszName);
} else {
LARGECOPYSTRINGLPSTRW(&pcreatestruct->strName, cs.lpszName);
}
}
}
if (cbClass) {
if (!pcreatestruct->strClass.bAnsi) {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPWSTRA(&pcreatestruct->strClass, cs.lpszClass);
} else {
LARGECOPYSTRINGLPWSTR(&pcreatestruct->strClass, cs.lpszClass);
}
} else {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPSTR(&pcreatestruct->strClass, cs.lpszClass);
} else {
LARGECOPYSTRINGLPSTRW(&pcreatestruct->strClass, cs.lpszClass);
}
}
}
}
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNINLPCREATESTRUCT);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINLPCREATESTRUCT");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPCREATESTRUCT, FNINLPCREATESTRUCTMSG)
{
LPARAM lParam;
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
if (pmsg->lParam != 0) {
if ((ULONG_PTR)pmsg->cs.lpszName > gHighestUserAddress)
pmsg->cs.lpszName = REBASEPTR(pmsg->pwnd, pmsg->cs.lpszName);
if ((ULONG_PTR)pmsg->cs.lpszClass > gHighestUserAddress)
pmsg->cs.lpszClass = REBASEPTR(pmsg->pwnd, pmsg->cs.lpszClass);
lParam = (LPARAM)&pmsg->cs;
if ((pmsg->cs.lpCreateParams != NULL) &&
(TestWF(pmsg->pwnd, WEFMDICHILD))) {
// Note -- do not test the flag in cs.dwExStyle -- it gets zapped for Old UI apps, like Quicken
((LPMDICREATESTRUCT)(pmsg->cs.lpCreateParams))->szClass = pmsg->cs.lpszClass;
((LPMDICREATESTRUCT)(pmsg->cs.lpCreateParams))->szTitle = pmsg->cs.lpszName;
}
} else
lParam = 0;
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
lParam,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINLPMDICREATESTRUCT
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINLPMDICREATESTRUCTMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
MDICREATESTRUCT mdics;
ULONG_PTR xParam;
PROC xpfnProc;
int szClass;
int szTitle;
} FNINLPMDICREATESTRUCTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPMDICREATESTRUCT)
{
PMDICREATESTRUCTEX pmdicreatestruct = (PMDICREATESTRUCTEX)lParam;
DWORD cbTitle = 0, cbClass = 0;
DWORD cCapture = 0;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
SETUPPWND(FNINLPMDICREATESTRUCT)
UNREFERENCED_PARAMETER(psms);
/*
* Compute ANSI capture lengths. Don't capture if
* the strings are in the client's address space and
* are Unicode.
*/
if (pmdicreatestruct->mdics.szTitle &&
(IS_SYSTEM_ADDRESS((PVOID)pmdicreatestruct->mdics.szTitle) ||
((BOOL)pmdicreatestruct->strTitle.bAnsi != fAnsiReceiver))) {
CALC_SIZE_IN(cbTitle, &pmdicreatestruct->strTitle);
cCapture = 1;
}
if (IS_PTR(pmdicreatestruct->mdics.szClass) &&
(IS_SYSTEM_ADDRESS((PVOID)pmdicreatestruct->mdics.szClass) ||
((BOOL)pmdicreatestruct->strClass.bAnsi != fAnsiReceiver))) {
CALC_SIZE_IN(cbClass, &pmdicreatestruct->strClass);
cCapture++;
}
BEGINSENDCAPTURE(FNINLPMDICREATESTRUCT, cCapture, cbTitle + cbClass, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->mdics = pmdicreatestruct->mdics;
if (cbTitle) {
if (!pmdicreatestruct->strTitle.bAnsi) {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPWSTRA(&pmdicreatestruct->strTitle, mdics.szTitle);
} else {
LARGECOPYSTRINGLPWSTR(&pmdicreatestruct->strTitle, mdics.szTitle);
}
} else {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPSTR(&pmdicreatestruct->strTitle, mdics.szTitle);
} else {
LARGECOPYSTRINGLPSTRW(&pmdicreatestruct->strTitle, mdics.szTitle);
}
}
}
if (cbClass) {
if (!pmdicreatestruct->strClass.bAnsi) {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPWSTRA(&pmdicreatestruct->strClass, mdics.szClass);
} else {
LARGECOPYSTRINGLPWSTR(&pmdicreatestruct->strClass, mdics.szClass);
}
} else {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPSTR(&pmdicreatestruct->strClass, mdics.szClass);
} else {
LARGECOPYSTRINGLPSTRW(&pmdicreatestruct->strClass, mdics.szClass);
}
}
}
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNINLPMDICREATESTRUCT);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINLPMDICREATESTRUCT");
ENDSENDCAPTURE(LRESULT,0);
DBG_UNREFERENCED_PARAMETER(wParam);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPMDICREATESTRUCT, FNINLPMDICREATESTRUCTMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&pmsg->mdics,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINPAINTCLIPBRD
*
* lParam is a supposed to be a Global Handle to DDESHARE memory.
*
* 22-Jul-1991 johnc Created
\**************************************************************************/
typedef struct _FNINPAINTCLIPBRDMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
PAINTSTRUCT ps;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINPAINTCLIPBRDMSG;
#ifdef SENDSIDE
SMESSAGECALL(INPAINTCLIPBRD)
{
PWND pwndDCOwner;
/*
* We need to check clipboard access rights because the app could
* get the clipboard owner's window handle by enumeration etc and
* send this message
*/
SETUPPWND(FNINPAINTCLIPBRD)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINPAINTCLIPBRD)
LPPAINTSTRUCT pps = (LPPAINTSTRUCT)lParam;
if (RtlAreAllAccessesGranted(PpiCurrent()->amwinsta,
WINSTA_ACCESSCLIPBOARD)) {
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->ps = *pps;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
/*
* We can't just set the owner of the DC and pass the original DC
* because currently GDI won't let you query the current owner
* and we don't know if it is a public or privately owned DC
*/
pwndDCOwner = _WindowFromDC(pps->hdc);
MSGDATA()->ps.hdc = _GetDC(pwndDCOwner);
LOCKPWND();
MAKECALL(FNINPAINTCLIPBRD);
UNLOCKPWND();
CHECKRETURN();
_ReleaseDC(MSGDATA()->ps.hdc);
}
TRACECALLBACKMSG("SfnINPAINTCLIPBRD");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINPAINTCLIPBRD, FNINPAINTCLIPBRDMSG)
{
LPPAINTSTRUCT lpps;
BEGINRECV(0, NULL, 0);
lpps = (LPPAINTSTRUCT)GlobalAlloc(GMEM_FIXED | GMEM_DDESHARE, sizeof(PAINTSTRUCT));
UserAssert(lpps);
if (lpps) {
*lpps = pmsg->ps;
UserAssert(lpps->hdc);
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
lpps,
pmsg->xParam);
GlobalFree((HGLOBAL)lpps);
}
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINSIZECLIPBRD
*
* lParam is a supposed to be a Global Handle to DDESHARE memory.
*
* 11-Jun-1992 sanfords Created
\**************************************************************************/
typedef struct _FNINSIZECLIPBRDMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
RECT rc;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINSIZECLIPBRDMSG;
#ifdef SENDSIDE
SMESSAGECALL(INSIZECLIPBRD)
{
/*
* We need to check clipboard access rights because the app could
* get the clipboard owner's window handle by enumeration etc and
* send this message
*/
SETUPPWND(FNINSIZECLIPBRD)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINSIZECLIPBRD)
LPRECT prc = (LPRECT)lParam;
if (RtlAreAllAccessesGranted(PpiCurrent()->amwinsta,
WINSTA_ACCESSCLIPBOARD)) {
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->rc = *prc;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINSIZECLIPBRD);
UNLOCKPWND();
CHECKRETURN();
}
TRACECALLBACKMSG("SfnINSIZECLIPBRD");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINSIZECLIPBRD, FNINSIZECLIPBRDMSG)
{
LPRECT lprc;
BEGINRECV(0, NULL, 0);
lprc = (LPRECT)GlobalAlloc(GMEM_FIXED | GMEM_DDESHARE, sizeof(RECT));
UserAssert(lprc);
if (lprc) {
*lprc = pmsg->rc;
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
lprc,
pmsg->xParam);
GlobalFree((HGLOBAL)lprc);
}
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINDESTROYCLIPBRD
*
* Special handler so we can call ClientEmptyClipboard on client
*
* 01-16-93 scottlu Created
\**************************************************************************/
typedef struct _FNINDESTROYCLIPBRDMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINDESTROYCLIPBRDMSG;
#ifdef SENDSIDE
SMESSAGECALL(INDESTROYCLIPBRD)
{
SETUPPWND(FNINDESTROYCLIPBRD)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINDESTROYCLIPBRD)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINDESTROYCLIPBRD);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINDESTROYCLIPBRD");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINDESTROYCLIPBRD, FNINDESTROYCLIPBRDMSG)
{
void ClientEmptyClipboard(void);
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
pmsg->lParam,
pmsg->xParam);
/*
* Now empty the client side clipboard cache.
* Don't do this if this is a 16bit app. We don't want to clear out the
* clipboard just because one app is going away. All of the 16bit apps
* share one clipboard.
*/
if ((GetClientInfo()->CI_flags & CI_16BIT) == 0) {
ClientEmptyClipboard();
}
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINOUTLPSCROLLINFOMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
SCROLLINFO info;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINOUTLPSCROLLINFOMSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTLPSCROLLINFO)
{
SETUPPWND(FNINOUTLPSCROLLINFO)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNINOUTLPSCROLLINFO)
LPSCROLLINFO pinfo = (LPSCROLLINFO)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->info = *pinfo;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINOUTLPSCROLLINFO);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(pinfo, SCROLLINFO);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTLPSCROLLINFO");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTLPSCROLLINFO, FNINOUTLPSCROLLINFOMSG)
{
BEGINRECV(0, &pmsg->info, sizeof(pmsg->info));
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&pmsg->info,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINOUTLPPOINT5MSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
POINT5 point5;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINOUTLPPOINT5MSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTLPPOINT5)
{
SETUPPWND(FNINOUTLPPOINT5)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNINOUTLPPOINT5)
LPPOINT5 ppoint5 = (LPPOINT5)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->point5 = *ppoint5;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINOUTLPPOINT5);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(ppoint5, POINT5);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTLPPOINT5");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTLPPOINT5, FNINOUTLPPOINT5MSG)
{
BEGINRECV(0, &pmsg->point5, sizeof(POINT5));
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&pmsg->point5,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINOUTLPRECTMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
RECT rect;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINOUTLPRECTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTLPRECT)
{
SETUPPWND(FNINOUTLPRECT)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNINOUTLPRECT)
LPRECT prect = (LPRECT)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->rect = *prect;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINOUTLPRECT);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(prect, RECT);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTLPRECT");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTLPRECT, FNINOUTLPRECTMSG)
{
BEGINRECV(0, &pmsg->rect, sizeof(pmsg->rect));
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&pmsg->rect,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 11-25-92 ScottLu Created.
\**************************************************************************/
typedef struct _FNINOUTNCCALCSIZEMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
union {
RECT rc;
struct {
NCCALCSIZE_PARAMS params;
WINDOWPOS pos;
} p;
} u;
} FNINOUTNCCALCSIZEMSG;
typedef struct _OUTNCCALCSIZE {
NCCALCSIZE_PARAMS params;
WINDOWPOS pos;
} OUTNCCALCSIZE, *POUTNCCALCSIZE;
#ifdef SENDSIDE
SMESSAGECALL(INOUTNCCALCSIZE)
{
SETUPPWND(FNINOUTNCCALCSIZE)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNINOUTNCCALCSIZE)
LPWINDOWPOS lppos;
UINT cbCallback;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
/*
* If wParam != 0, lParam points to a NCCALCSIZE_PARAMS structure,
* otherwise it points to a rectangle.
*/
if (wParam != 0) {
MSGDATA()->u.p.params = *((LPNCCALCSIZE_PARAMS)lParam);
MSGDATA()->u.p.pos = *(MSGDATA()->u.p.params.lppos);
cbCallback = sizeof(FNINOUTNCCALCSIZEMSG);
} else {
MSGDATA()->u.rc = *((LPRECT)lParam);
cbCallback = FIELD_OFFSET(FNINOUTNCCALCSIZEMSG, u) +
sizeof(RECT);
}
/*
* Don't use the MAKECALL macro so we can
* select the callback data size
*/
LOCKPWND();
LeaveCrit();
Status = (DWORD)KeUserModeCallback(
FI_FNINOUTNCCALCSIZE,
mp,
cbCallback,
&pcbs,
&cbCBStatus);
EnterCrit();
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
try {
ProbeForRead(pcbs->pOutput, pcbs->cbOutput, sizeof(DWORD));
if (wParam != 0) {
lppos = ((LPNCCALCSIZE_PARAMS)lParam)->lppos;
*((LPNCCALCSIZE_PARAMS)lParam) =
((POUTNCCALCSIZE)pcbs->pOutput)->params;
*lppos = ((POUTNCCALCSIZE)pcbs->pOutput)->pos;
((LPNCCALCSIZE_PARAMS)lParam)->lppos = lppos;
} else {
*((LPRECT)lParam) = *(PRECT)pcbs->pOutput;
}
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
MSGERROR();
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTNCCALCSIZE");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTNCCALCSIZE, FNINOUTNCCALCSIZEMSG)
{
BEGINRECV(0, &pmsg->u, sizeof(pmsg->u));
if (CALLDATA(wParam) != 0)
CALLDATA(u.p.params).lppos = PCALLDATA(u.p.pos);
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
(LPARAM)&pmsg->u,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 9/30/94 Sanfords created
\**************************************************************************/
typedef struct _FNINOUTSTYLECHANGEMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
STYLESTRUCT ss;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINOUTSTYLECHANGEMSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTSTYLECHANGE)
{
SETUPPWND(FNINOUTSTYLECHANGE)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINOUTSTYLECHANGE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MSGDATA()->ss = *((LPSTYLESTRUCT)lParam);
LOCKPWND();
MAKECALL(FNINOUTSTYLECHANGE);
UNLOCKPWND();
CHECKRETURN();
if (msg == WM_STYLECHANGING)
OUTSTRUCT(((LPSTYLESTRUCT)lParam), STYLESTRUCT);
TRACECALLBACKMSG("SfnINOUTSTYLECHANGE");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTSTYLECHANGE, FNINOUTSTYLECHANGEMSG)
{
BEGINRECV(0, &pmsg->ss, sizeof(pmsg->ss));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
(LPARAM)&pmsg->ss,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNOUTLPRECTMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNOUTLPRECTMSG;
#ifdef SENDSIDE
SMESSAGECALL(OUTLPRECT)
{
SETUPPWND(FNOUTLPRECT)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNOUTLPRECT)
LPRECT prect = (LPRECT)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNOUTLPRECT);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(prect, RECT);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnOUTLPRECT");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnOUTLPRECT, FNOUTLPRECTMSG)
{
RECT rc;
BEGINRECV(0, &rc, sizeof(rc));
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&rc,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINLPCOMPAREITEMSTRUCTMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
COMPAREITEMSTRUCT compareitemstruct;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINLPCOMPAREITEMSTRUCTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPCOMPAREITEMSTRUCT)
{
SETUPPWND(FNINLPCOMPAREITEMSTRUCT)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINLPCOMPAREITEMSTRUCT)
LPCOMPAREITEMSTRUCT pcompareitemstruct = (LPCOMPAREITEMSTRUCT)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->compareitemstruct = *pcompareitemstruct;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINLPCOMPAREITEMSTRUCT);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINLPCOMPAREITEMSTRUCT");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPCOMPAREITEMSTRUCT, FNINLPCOMPAREITEMSTRUCTMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&(pmsg->compareitemstruct),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINLPDELETEITEMSTRUCTMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
DELETEITEMSTRUCT deleteitemstruct;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINLPDELETEITEMSTRUCTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPDELETEITEMSTRUCT)
{
SETUPPWND(FNINLPDELETEITEMSTRUCT)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINLPDELETEITEMSTRUCT)
LPDELETEITEMSTRUCT pdeleteitemstruct = (LPDELETEITEMSTRUCT)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->deleteitemstruct = *pdeleteitemstruct;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINLPDELETEITEMSTRUCT);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINLPDELETEITEMSTRUCT");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPDELETEITEMSTRUCT, FNINLPDELETEITEMSTRUCTMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&(pmsg->deleteitemstruct),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* FNINHLPSTRUCT
*
* 06-08-92 SanfordS Created
\**************************************************************************/
typedef struct _FNINLPHLPSTRUCTMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
LPHLP lphlp;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINLPHLPSTRUCTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPHLPSTRUCT)
{
LPHLP lphlp = (LPHLP)lParam;
SETUPPWND(FNINLPHLPSTRUCT)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSENDCAPTURE(FNINLPHLPSTRUCT, 1, lphlp->cbData, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
COPYBYTES(lphlp, lphlp->cbData);
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNINLPHLPSTRUCT);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINLPHLPSTRUCT");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPHLPSTRUCT, FNINLPHLPSTRUCTMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
FIXUP(lphlp),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
#ifndef WINHELP4
/**************************************************************************\
* FNINHELPINFOSTRUCT
*
* 06-08-92 SanfordS Created
\**************************************************************************/
typedef struct _FNINLPHELPFINFOSTRUCTMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
LPHELPINFO lphlp;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINLPHELPINFOSTRUCTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPHELPINFOSTRUCT)
{
LPHELPINFO lphlp = (LPHELPINFO)lParam;
SETUPPWND(FNINLPHELPINFOSTRUCT)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSENDCAPTURE(FNINLPHELPINFOSTRUCT, 1, lphlp->cbSize, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
COPYBYTES(lphlp, lphlp->cbSize);
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNINLPHELPINFOSTRUCT);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINLPHELPINFOSTRUCT");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPHELPINFOSTRUCT, FNINLPHELPINFOSTRUCTMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
FIXUP(lphlp),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
#endif // WINHELP4
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINLPDRAWITEMSTRUCTMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
DRAWITEMSTRUCT drawitemstruct;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINLPDRAWITEMSTRUCTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPDRAWITEMSTRUCT)
{
SETUPPWND(FNINLPDRAWITEMSTRUCT)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINLPDRAWITEMSTRUCT)
LPDRAWITEMSTRUCT pdrawitemstruct = (LPDRAWITEMSTRUCT)lParam;
HDC hdcOriginal = (HDC)NULL;
/*
* Make sure that this is not an OLE inter-process DrawItem
*/
if (GreGetObjectOwner((HOBJ)pdrawitemstruct->hDC, DC_TYPE) !=
W32GetCurrentPID()) {
if (pdrawitemstruct->hDC) {
PWND pwndItem;
pwndItem = _WindowFromDC(pdrawitemstruct->hDC);
if (pwndItem) {
hdcOriginal = pdrawitemstruct->hDC;
pdrawitemstruct->hDC = _GetDC(pwndItem);
}
}
}
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->drawitemstruct = *pdrawitemstruct;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINLPDRAWITEMSTRUCT);
UNLOCKPWND();
CHECKRETURN();
if (hdcOriginal) {
_ReleaseDC(pdrawitemstruct->hDC);
pdrawitemstruct->hDC = hdcOriginal;
}
TRACECALLBACKMSG("SfnINLPDRAWITEMSTRUCT");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPDRAWITEMSTRUCT, FNINLPDRAWITEMSTRUCTMSG)
{
BEGINRECV(0, NULL, 0);
if (pmsg->drawitemstruct.hDC == NULL)
MSGERRORCODE(ERROR_INVALID_HANDLE);
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&(pmsg->drawitemstruct),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINOUTLPMEASUREITEMSTRUCT
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINOUTLPMEASUREITEMSTRUCTMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
MEASUREITEMSTRUCT measureitemstruct;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINOUTLPMEASUREITEMSTRUCTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTLPMEASUREITEMSTRUCT)
{
SETUPPWND(FNINOUTLPMEASUREITEMSTRUCT)
BEGINSEND(FNINOUTLPMEASUREITEMSTRUCT)
PMEASUREITEMSTRUCT pmeasureitemstruct = (PMEASUREITEMSTRUCT)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg & ~MSGFLAG_MASK;
MSGDATA()->wParam = wParam;
MSGDATA()->measureitemstruct = *pmeasureitemstruct;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINOUTLPMEASUREITEMSTRUCT);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(pmeasureitemstruct, MEASUREITEMSTRUCT);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTLPMEASUREITEMSTRUCT");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTLPMEASUREITEMSTRUCT, FNINOUTLPMEASUREITEMSTRUCTMSG)
{
BEGINRECV(0, &pmsg->measureitemstruct, sizeof(pmsg->measureitemstruct));
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
&pmsg->measureitemstruct,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINSTRING
*
* 22-Jul-1991 mikeke Created
* 27-Jan-1992 IanJa Unicode/ANSI
\**************************************************************************/
typedef struct _FNINSTRINGMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
LPTSTR pwsz;
} FNINSTRINGMSG;
#ifdef SENDSIDE
SMESSAGECALL(INSTRING)
{
PLARGE_STRING pstr = (PLARGE_STRING)lParam;
DWORD cbCapture;
DWORD cCapture;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
SETUPPWND(FNINSTRING)
UNREFERENCED_PARAMETER(psms);
/*
* Compute ANSI capture lengths. Don't capture if
* the strings are in the client's address space and
* of the correct type.
*/
if (pstr &&
(IS_SYSTEM_ADDRESS((PVOID)pstr->Buffer) ||
((BOOL)pstr->bAnsi != fAnsiReceiver))) {
cCapture = 1;
CALC_SIZE_IN(cbCapture, pstr);
} else {
cbCapture = 0;
cCapture = 0;
}
BEGINSENDCAPTURE(FNINSTRING, cCapture, cbCapture, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
if (cCapture) {
if (!pstr->bAnsi) {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPWSTRA(pstr, pwsz);
} else {
LARGECOPYSTRINGLPWSTR(pstr, pwsz);
}
} else {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPSTR(pstr, pwsz);
} else {
LARGECOPYSTRINGLPSTRW(pstr, pwsz);
}
}
} else {
MSGDATA()->pwsz = (pstr ? pstr->Buffer : NULL);
}
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNINSTRING);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINSTRING");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINSTRING, FNINSTRINGMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
pmsg->pwsz,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINSTRINGNULL
*
* Server-side stub translates Unicode to ANSI if required.
*
* 22-Jul-1991 mikeke Created
* 28-Jan-1992 IanJa Unicode/ANSI (Server translate to ANSI if rquired)
\**************************************************************************/
typedef struct _FNINSTRINGNULLMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
LPTSTR pwsz;
} FNINSTRINGNULLMSG;
#ifdef SENDSIDE
SMESSAGECALL(INSTRINGNULL)
{
PLARGE_STRING pstr = (PLARGE_STRING)lParam;
DWORD cbCapture;
DWORD cCapture;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
SETUPPWND(FNINSTRINGNULL)
UNREFERENCED_PARAMETER(psms);
cCapture = 0;
cbCapture = 0;
if (pstr) {
/*
* Compute ANSI capture lengths. Don't capture if
* the strings are in the client's address space and
* of the correct type.
*/
if (IS_SYSTEM_ADDRESS((PVOID)pstr->Buffer) ||
(BOOL)pstr->bAnsi != fAnsiReceiver) {
cCapture = 1;
CALC_SIZE_IN(cbCapture, pstr);
}
}
BEGINSENDCAPTURE(FNINSTRINGNULL, cCapture, cbCapture, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
if (cCapture) {
if (!pstr->bAnsi) {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPWSTRA(pstr, pwsz);
} else {
LARGECOPYSTRINGLPWSTR(pstr, pwsz);
}
} else {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPSTR(pstr, pwsz);
} else {
LARGECOPYSTRINGLPSTRW(pstr, pwsz);
}
}
} else
MSGDATA()->pwsz = pstr ? pstr->Buffer : NULL;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNINSTRINGNULL);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINSTRINGNULL");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINSTRINGNULL, FNINSTRINGNULLMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
pmsg->pwsz,
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 27-May-1997 GregoryW Created
\**************************************************************************/
typedef struct _FNINLPKDRAWSWITCHWNDMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
LPWSTR pwsz;
RECT rcRect;
} FNINLPKDRAWSWITCHWNDMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPKDRAWSWITCHWND)
{
PLARGE_UNICODE_STRING pstr = &((LPKDRAWSWITCHWND *)lParam)->strName;
DWORD cbCapture;
DWORD cCapture = 1; // Always capture the string
PWND pwndDCOwner;
HDC hdcSwitch;
COLORREF clrOldText, clrOldBk;
HFONT hOldFont;
BOOL fAnsiReceiver = FALSE; // The string is always Unicode
SETUPPWND(FNINLPKDRAWSWITCHWND)
UNREFERENCED_PARAMETER(psms);
UNREFERENCED_PARAMETER(dwSCMSFlags);
CALC_SIZE_IN(cbCapture, pstr);
BEGINSENDCAPTURE(FNINLPKDRAWSWITCHWND, cCapture, cbCapture, TRUE)
LARGECOPYSTRINGLPWSTR(pstr, pwsz);
pwndDCOwner = _WindowFromDC((HDC)wParam);
hdcSwitch = _GetDC(pwndDCOwner);
clrOldText = GreSetTextColor(hdcSwitch, SYSRGB(BTNTEXT));
clrOldBk = GreSetBkColor(hdcSwitch, SYSRGB(3DFACE));
hOldFont = GreSelectFont(hdcSwitch, gpsi->hCaptionFont);
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = (WPARAM)hdcSwitch;
MSGDATA()->rcRect = ((LPKDRAWSWITCHWND *)lParam)->rcRect;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNINLPKDRAWSWITCHWND);
UNLOCKPWND();
GreSelectFont(hdcSwitch, hOldFont);
GreSetBkColor(hdcSwitch, clrOldBk);
GreSetTextColor(hdcSwitch, clrOldText);
_ReleaseDC(hdcSwitch);
CHECKRETURN();
TRACECALLBACKMSG("SfnINLPKDRAWSWITCHWND");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPKDRAWSWITCHWND, FNINLPKDRAWSWITCHWNDMSG)
{
DRAWTEXTPARAMS dtp;
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
dtp.cbSize = sizeof(dtp);
dtp.iLeftMargin = 0;
dtp.iRightMargin = 0;
retval = DrawTextExW(
(HDC)pmsg->wParam,
pmsg->pwsz,
-1,
&(pmsg->rcRect),
DT_NOPREFIX | DT_END_ELLIPSIS | DT_SINGLELINE,
&dtp
);
ENDRECV();
}
#endif // RECVSIDE
typedef struct _FNINDEVICECHANGEMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
LPTSTR pwsz;
BOOL fAnsi;
} FNINDEVICECHANGEMSG;
#ifdef SENDSIDE
SMESSAGECALL(INDEVICECHANGE)
{
PVOID pstr = (PVOID)lParam;
DWORD cbCapture;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
BOOL fPtr = (BOOL)((wParam & 0x8000) == 0x8000);
SETUPPWND(FNINDEVICECHANGE)
UNREFERENCED_PARAMETER(psms);
cbCapture = 0;
if (fPtr && (pstr != NULL)) {
/*
* Compute ANSI capture lengths. Don't capture if
* the strings are in the client's address space and
* of the correct type.
*/
if (IS_SYSTEM_ADDRESS((PVOID)pstr)) {
cbCapture = *((DWORD *)pstr);
}
}
BEGINSENDCAPTURE(FNINDEVICECHANGE, 1, cbCapture, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
if (cbCapture) {
LARGECOPYBYTES2(pstr, *((DWORD *)pstr), pwsz);
} else {
MSGDATA()->pwsz = (LPTSTR)pstr;
}
MSGDATA()->fAnsi = fAnsiReceiver;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNINDEVICECHANGE);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINDEVICECHANGE");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINDEVICECHANGE, FNINDEVICECHANGEMSG)
{
struct _DEV_BROADCAST_HEADER *pHdr;
PDEV_BROADCAST_PORT_A pPortA = NULL;
PDEV_BROADCAST_PORT_W pPortW;
PDEV_BROADCAST_DEVICEINTERFACE_A pInterfaceA = NULL;
PDEV_BROADCAST_DEVICEINTERFACE_W pInterfaceW;
PDEV_BROADCAST_HANDLE pHandleA = NULL;
PDEV_BROADCAST_HANDLE pHandleW;
PDEV_BROADCAST_VOLUME pVolume;
int iStr, iSize;
LPSTR lpStr;
LPARAM lParam;
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
lParam = (LPARAM)pmsg->pwsz;
pHdr = (struct _DEV_BROADCAST_HEADER *)lParam;
if (!lParam || !(pmsg->wParam & 0x8000) ||
(!pmsg->fAnsi &&
((pHdr->dbcd_devicetype != DBT_DEVTYP_VOLUME) || (pmsg->msg != WM_DEVICECHANGE))
)) {
goto shipit;
}
switch (pHdr->dbcd_devicetype) {
case DBT_DEVTYP_PORT:
pPortW = (PDEV_BROADCAST_PORT_W)lParam;
iStr = wcslen(pPortW->dbcp_name);
iSize = FIELD_OFFSET(DEV_BROADCAST_PORT_A, dbcp_name) + DBCS_CHARSIZE*(iStr+1);
pPortA = UserLocalAlloc(0, iSize);
if (pPortA == NULL)
MSGERROR();
RtlCopyMemory(pPortA, pPortW, FIELD_OFFSET(DEV_BROADCAST_PORT_A, dbcp_name));
lpStr = pPortA->dbcp_name;
if (iStr) {
WCSToMB(pPortW->dbcp_name, -1, &lpStr, iStr, FALSE);
}
lpStr[iStr] = 0;
pPortA->dbcp_size = iSize;
lParam = (LPARAM)pPortA;
break;
case DBT_DEVTYP_DEVICEINTERFACE:
pInterfaceW = (PDEV_BROADCAST_DEVICEINTERFACE_W)lParam;
iStr = wcslen(pInterfaceW->dbcc_name);
iSize = FIELD_OFFSET(DEV_BROADCAST_DEVICEINTERFACE_A, dbcc_name) + DBCS_CHARSIZE*(iStr+1);
pInterfaceA = UserLocalAlloc(0, iSize);
if (pInterfaceA == NULL)
MSGERROR();
RtlCopyMemory(pInterfaceA, pInterfaceW, FIELD_OFFSET(DEV_BROADCAST_DEVICEINTERFACE_A, dbcc_name));
lpStr = pInterfaceA->dbcc_name;
if (iStr) {
WCSToMB(pInterfaceW->dbcc_name, -1, &lpStr, iStr, FALSE);
}
lpStr[iStr] = 0;
pInterfaceA->dbcc_size = iSize;
lParam = (LPARAM)pInterfaceA;
break;
case DBT_DEVTYP_HANDLE:
pHandleW = (PDEV_BROADCAST_HANDLE)lParam;
if ((pmsg->wParam != DBT_CUSTOMEVENT) || (pHandleW->dbch_nameoffset < 0)) break;
iStr = wcslen((LPWSTR)(pHandleW->dbch_data+pHandleW->dbch_nameoffset));
iSize = pHandleW->dbch_size;
/*
* MB size can't be bigger than UNICODE size
*/
pHandleA = UserLocalAlloc(0, iSize);
if (pHandleA == NULL)
MSGERROR();
RtlCopyMemory(pHandleA, pHandleW, FIELD_OFFSET(DEV_BROADCAST_HANDLE, dbch_data)+ pHandleW->dbch_nameoffset);
lpStr = pHandleA->dbch_data+pHandleA->dbch_nameoffset;
if (iStr) {
WCSToMB((LPWSTR)(pHandleW->dbch_data+pHandleW->dbch_nameoffset), -1, &lpStr, iStr, FALSE);
}
lpStr[iStr] = 0;
pHandleA->dbch_size = iSize;
lParam = (LPARAM)pHandleA;
break;
case DBT_DEVTYP_VOLUME:
pVolume = (PDEV_BROADCAST_VOLUME)lParam;
if (((pmsg->wParam == DBT_DEVICEREMOVECOMPLETE) ||
(pmsg->wParam == DBT_DEVICEARRIVAL)) &&
(pVolume->dbcv_unitmask & DBV_FILTER_MSG)) {
DWORD LUIDDriveMask, ResultDriveMask;
LUIDDriveMask = GetLUIDDosDrivesOnly();
/*
* Filter out the common drive letter bits & DBV_FILTER_MSG
*/
ResultDriveMask = (((LUIDDriveMask & pVolume->dbcv_unitmask) ^
pVolume->dbcv_unitmask) ^
DBV_FILTER_MSG);
if (ResultDriveMask == 0) {
goto cleanup;
}
pVolume->dbcv_unitmask = ResultDriveMask;
lParam = (LPARAM)pVolume;
}
break;
}
shipit:
retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
lParam,
pmsg->xParam);
cleanup:
if (pInterfaceA) UserLocalFree(pInterfaceA);
if (pPortA) UserLocalFree(pPortA);
if (pHandleA) UserLocalFree(pHandleA);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnOUTSTRING
*
* Warning this message copies but does not count the NULL in retval
* as in WM_GETTEXT
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNOUTSTRINGMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
PBYTE pOutput;
DWORD cbOutput;
} FNOUTSTRINGMSG;
#ifdef SENDSIDE
SMESSAGECALL(OUTSTRING)
{
PLARGE_STRING pstr = (PLARGE_STRING)lParam;
DWORD cbCapture;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
BOOL bInflateWParam = FALSE;
SETUPPWND(FNOUTSTRING)
CALC_SIZE_OUT_STRING(cbCapture, pstr);
BEGINSENDCAPTURE(FNOUTSTRING, 1, cbCapture, FALSE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
/*
* Need to wParam MBCS bytes may be required to form wParam Unicode bytes
*/
if (fAnsiReceiver && !(pstr->bAnsi)) {
/*
* Unicode -> Ansi
*/
MSGDATA()->wParam = (wParam * sizeof(WCHAR));
PtiCurrent()->TIF_flags |= TIF_ANSILENGTH;
bInflateWParam = TRUE;
} else {
/*
* if wParam is already adjusted for ANSI, we need to re-adjust for Unicode...
*
* This logic is for following cases...
*
* +========+===============+=============+================+=============+
* |WndProc |Unicode WndProc->Ansi WndProc->Unicode WndProc->Ansi WndProc|
* +--------+---------------+-------------+----------------+-------------+
* |Length | X -> (X * 2) -> X -> (X * 2) |
* +--------+---------------+-------------+----------------+-------------+
*/
if (!fAnsiReceiver && (PtiCurrent()->TIF_flags & TIF_ANSILENGTH)) {
/* adjust limit also... */
MSGDATA()->wParam = wParam / sizeof(WCHAR);
PtiCurrent()->TIF_flags &= ~TIF_ANSILENGTH;
} else {
MSGDATA()->wParam = wParam;
}
}
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
RESERVEBYTES(cbCapture, pOutput, cbOutput);
LOCKPWND();
MAKECALLCAPTURE(FNOUTSTRING);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
if (retval) {
/*
* Non-zero retval means some text to copy out. Do not copy out
* more than the requested byte count 'wParam'.
*/
COPYOUTLPWSTRLIMIT(pstr, (int)wParam);
} else {
/*
* A dialog function returning FALSE means no text to copy out,
* but an empty string also has retval == 0: put a null char in
* pstr for the latter case.
*/
if (wParam != 0) {
if (pstr->bAnsi) {
*(PCHAR)pstr->Buffer = 0;
} else {
*(PWCHAR)pstr->Buffer = 0;
}
}
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnOUTSTRING");
ENDSENDCAPTUREOUTSTRING(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnOUTSTRING, FNOUTSTRINGMSG)
{
BYTE abOutput[CALLBACKSTACKLIMIT];
BEGINRECV(0, NULL, pmsg->cbOutput);
FIXUPPOINTERS();
if (pmsg->cbOutput <= CALLBACKSTACKLIMIT)
CallbackStatus.pOutput = abOutput;
else
CallbackStatus.pOutput = pmsg->pOutput;
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
(LPARAM)KPVOID_TO_PVOID(CallbackStatus.pOutput),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINCNTOUTSTRING
*
* Does NOT NULL terminate string
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINCNTOUTSTRING {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
WORD cchMax;
PBYTE pOutput;
DWORD cbOutput;
} FNINCNTOUTSTRINGMSG;
#ifdef SENDSIDE
SMESSAGECALL(INCNTOUTSTRING)
{
PLARGE_STRING pstr = (PLARGE_STRING)lParam;
DWORD cbCapture;
WORD cchOriginal;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
SETUPPWND(FNINCNTOUTSTRING)
CALC_SIZE_OUT(cbCapture, pstr);
BEGINSENDCAPTURE(FNINCNTOUTSTRING, 1, cbCapture, FALSE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
cchOriginal = (WORD)pstr->MaximumLength;
if (!pstr->bAnsi)
cchOriginal /= sizeof(WCHAR);
MSGDATA()->cchMax = (WORD)min(cchOriginal, 0xffff);
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
RESERVEBYTES(cbCapture, pOutput, cbOutput);
LOCKPWND();
MAKECALLCAPTURE(FNINCNTOUTSTRING)
UNLOCKPWND();
CHECKRETURN();
/*
* We don't want to do the copy out of the sender died or if
* this message was just sent as part of a CALLWNDPROC hook processing
*/
BEGINCOPYOUT()
if (retval) {
/*
* Non-zero retval means some text to copy out. Do not copy out
* more than the requested char count 'wParam'.
*/
COPYOUTLPWSTRLIMIT(pstr, (int)cchOriginal);
} else {
/*
* A dialog function returning FALSE means no text to copy out,
* but an empty string also has retval == 0: put a null char in
* pstr for the latter case.
*/
if (pstr->bAnsi) {
*(PCHAR)pstr->Buffer = 0;
} else {
*(PWCHAR)pstr->Buffer = 0;
}
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINCNTOUTSTRING");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINCNTOUTSTRING, FNINCNTOUTSTRINGMSG)
{
BYTE abOutput[CALLBACKSTACKLIMIT];
BEGINRECV(0, NULL, pmsg->cbOutput);
FIXUPPOINTERS();
if (pmsg->cbOutput <= CALLBACKSTACKLIMIT)
CallbackStatus.pOutput = abOutput;
else
CallbackStatus.pOutput = pmsg->pOutput;
*(KPWORD)CallbackStatus.pOutput = CALLDATA(cchMax);
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
(LPARAM)KPVOID_TO_PVOID(CallbackStatus.pOutput),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINCNTOUTSTRINGNULL
*
* wParam specifies the maximum number of bytes to copy
* the string is NULL terminated
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINCNTOUTSTRINGNULL {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
PBYTE pOutput;
DWORD cbOutput;
} FNINCNTOUTSTRINGNULLMSG;
#ifdef SENDSIDE
SMESSAGECALL(INCNTOUTSTRINGNULL)
{
PLARGE_STRING pstr = (PLARGE_STRING)lParam;
DWORD cbCapture;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
SETUPPWND(FNINCNTOUTSTRINGNULL)
CALC_SIZE_OUT(cbCapture, pstr);
BEGINSENDCAPTURE(FNINCNTOUTSTRINGNULL, 1, cbCapture, FALSE)
if (wParam < 2) { // However unlikely, this prevents a possible GP
MSGERROR(); // on the server side.
}
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
RESERVEBYTES(cbCapture, pOutput, cbOutput);
LOCKPWND();
MAKECALLCAPTURE(FNINCNTOUTSTRINGNULL)
UNLOCKPWND();
CHECKRETURN();
/*
* We don't want to do the copy out of the sender died or if
* this message was just sent as part of a CALLWNDPROC hook processing
*/
BEGINCOPYOUT()
if (pcbs->cbOutput != 0) {
/*
* Buffer changed means some text to copy out. Do not copy out
* more than the requested byte count 'wParam'.
*/
COPYOUTLPWSTRLIMIT(pstr, (int)wParam);
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINCNTOUTSTRINGNULL");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINCNTOUTSTRINGNULL, FNINCNTOUTSTRINGNULLMSG)
{
BYTE abOutput[CALLBACKSTACKLIMIT];
BEGINRECV(0, NULL, pmsg->cbOutput);
FIXUPPOINTERS();
if (pmsg->cbOutput <= CALLBACKSTACKLIMIT)
CallbackStatus.pOutput = abOutput;
else
CallbackStatus.pOutput = pmsg->pOutput;
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
(LPARAM)KPVOID_TO_PVOID(CallbackStatus.pOutput),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnPOUTLPINT
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNPOUTLPINTMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
PBYTE pOutput;
DWORD cbOutput;
} FNPOUTLPINTMSG;
#ifdef SENDSIDE
SMESSAGECALL(POUTLPINT)
{
DWORD cbCapture;
LPINT pint = (LPINT)lParam;
SETUPPWND(FNPOUTLPINT)
cbCapture = (UINT)wParam * sizeof(INT);
BEGINSENDCAPTURE(FNPOUTLPINT, 1, cbCapture, FALSE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
/*
* Hooks should see the buffer content
*/
if (dwSCMSFlags & SCMS_FLAGS_INONLY) {
MSGDATA()->cbOutput = cbCapture;
LARGECOPYBYTES2(pint, cbCapture, pOutput);
} else {
RESERVEBYTES(cbCapture, pOutput, cbOutput);
}
LOCKPWND();
MAKECALLCAPTURE(FNPOUTLPINT);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
try {
ProbeForRead(pcbs->pOutput, pcbs->cbOutput, sizeof(DWORD));
memcpy(pint, pcbs->pOutput, cbCapture);
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
MSGERROR();
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnPOUTLPINT");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnPOUTLPINT, FNPOUTLPINTMSG)
{
BYTE abOutput[CALLBACKSTACKLIMIT];
BEGINRECV(0, NULL, pmsg->cbOutput);
FIXUPPOINTERS();
if (pmsg->cbOutput <= CALLBACKSTACKLIMIT)
CallbackStatus.pOutput = abOutput;
else
CallbackStatus.pOutput = pmsg->pOutput;
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
(LPARAM)KPVOID_TO_PVOID(CallbackStatus.pOutput),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnPOPTINLPUINT
*
* NOTE!!! -- This function actually thunks arrays of INTs (32bit) and not
* WORDs (16bit). The name was left the same to prevent a global rebuild
* of client and server. The name should be changed to fnPOPTINLPINT as
* soon as we ship the beta! The corresponding callforward function in
* cf2.h should also have its name changed.
*
* 22-Jul-1991 mikeke Created
* 07-Jan-1993 JonPa Changed to pass INTs instead of WORDs
\**************************************************************************/
typedef struct _FNPOPTINLPUINTMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
LPWORD pw;
ULONG_PTR xParam;
PROC xpfnProc;
} FNPOPTINLPUINTMSG;
#ifdef SENDSIDE
SMESSAGECALL(POPTINLPUINT)
{
LPWORD pw = (LPWORD)lParam;
DWORD cCapture, cbCapture;
SETUPPWND(FNPOPTINLPUINT);
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
if (lParam) {
cCapture = 1;
cbCapture = (UINT)wParam * sizeof(UINT);
} else {
cCapture = cbCapture = 0;
}
BEGINSENDCAPTURE(FNPOPTINLPUINT, cCapture, cbCapture, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
COPYBYTESOPT(pw, cbCapture);
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALLCAPTURE(FNPOPTINLPUINT);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnPOPTINLPUINT");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnPOPTINLPUINT, FNPOPTINLPUINTMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
(LPDWORD)FIRSTFIXUPOPT(pw),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINOUTLPWINDOWPOS (for WM_WINDOWPOSCHANGING message)
*
* 08-11-91 darrinm Created.
\**************************************************************************/
typedef struct _FNINOUTLPWINDOWPOSMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
WINDOWPOS wp;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINOUTLPWINDOWPOSMSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTLPWINDOWPOS)
{
SETUPPWND(FNINOUTLPWINDOWPOS)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNINOUTLPWINDOWPOS)
LPWINDOWPOS pwp = (LPWINDOWPOS)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->wp = *pwp;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINOUTLPWINDOWPOS);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(pwp, WINDOWPOS);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTLPWINDOWPOS");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTLPWINDOWPOS, FNINOUTLPWINDOWPOSMSG)
{
BEGINRECV(0, &pmsg->wp, sizeof(pmsg->wp));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
PCALLDATA(wp),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINLPWINDOWPOS (for WM_WINDOWPOSCHANGED message)
*
* 08-11-91 darrinm Created.
\**************************************************************************/
typedef struct _FNINLPWINDOWPOSMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
WINDOWPOS wp;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINLPWINDOWPOSMSG;
#ifdef SENDSIDE
SMESSAGECALL(INLPWINDOWPOS)
{
SETUPPWND(FNINLPWINDOWPOS)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNINLPWINDOWPOS)
LPWINDOWPOS pwp = (LPWINDOWPOS)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->wp = *pwp;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINLPWINDOWPOS);
UNLOCKPWND();
CHECKRETURN();
TRACECALLBACKMSG("SfnINLPWINDOWPOS");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINLPWINDOWPOS, FNINLPWINDOWPOSMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
PCALLDATA(wp),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnINOUTNEXTMENU
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNINOUTNEXTMENUMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
MDINEXTMENU mnm;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINOUTNEXTMENUMSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTNEXTMENU)
{
SETUPPWND(FNINOUTNEXTMENU)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNINOUTNEXTMENU)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MSGDATA()->mnm = *((PMDINEXTMENU)lParam);
LOCKPWND();
MAKECALL(FNINOUTNEXTMENU);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(((PMDINEXTMENU)lParam), MDINEXTMENU);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTNEXTMENU");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTNEXTMENU, FNINOUTNEXTMENUMSG)
{
BEGINRECV(0, &pmsg->mnm, sizeof(pmsg->mnm));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
&CALLDATA(mnm),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnHkINLPCBTCREATESTRUCT
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _CREATESTRUCTDATA {
CREATESTRUCT cs;
HWND hwndInsertAfter;
} CREATESTRUCTDATA;
typedef struct _FNHKINLPCBTCREATESTRUCTMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
CREATESTRUCTDATA d;
PROC xpfnProc;
BOOL bAnsi;
} FNHKINLPCBTCREATESTRUCTMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPCBTCREATESTRUCT(
UINT msg,
WPARAM wParam,
LPCBT_CREATEWND pcbt,
PROC xpfnProc,
BOOL fAnsiReceiver)
{
DWORD cbTitle = 0, cbClass = 0;
DWORD cCapture = 0;
CREATESTRUCTDATA csdOut;
PCREATESTRUCTEX pcreatestruct;
PWND pwnd = _GetDesktopWindow();
SETUPPWND(FNHKINLPCBTCREATESTRUCT)
/*
* Compute ANSI capture lengths. Don't capture if
* the strings are in the client's address space.
*/
pcreatestruct = (PCREATESTRUCTEX)pcbt->lpcs;
if (pcreatestruct->cs.lpszName &&
((BOOL)pcreatestruct->strName.bAnsi != fAnsiReceiver ||
IS_SYSTEM_ADDRESS((PVOID)pcreatestruct->cs.lpszName))) {
CALC_SIZE_IN(cbTitle, &pcreatestruct->strName);
cCapture++;
}
if (IS_PTR(pcreatestruct->cs.lpszClass) &&
((BOOL)pcreatestruct->strClass.bAnsi != fAnsiReceiver ||
IS_SYSTEM_ADDRESS((PVOID)pcreatestruct->cs.lpszClass))) {
CALC_SIZE_IN(cbClass, &pcreatestruct->strClass);
cCapture++;
}
BEGINSENDCAPTURE(FNHKINLPCBTCREATESTRUCT, cCapture, cbTitle + cbClass, TRUE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->d.cs = *(pcbt->lpcs);
if (cbTitle) {
if (!pcreatestruct->strName.bAnsi) {
WORD wOrdinal;
try {
wOrdinal = *(PWORD)pcreatestruct->cs.lpszName;
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
goto errorexit;
}
if (wOrdinal == 0xffff) {
/*
* Copy out an ordinal of the form 0xffff, ID.
* If the receiver is ANSI, skip the first 0xff.
*/
if (fAnsiReceiver) {
if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf,
(PBYTE)pcreatestruct->cs.lpszName + 1,
3, (PVOID *)&mp->d.cs.lpszName)))
goto errorexit;
} else {
if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf,
(PBYTE)pcreatestruct->cs.lpszName,
4, (PVOID *)&mp->d.cs.lpszName)))
goto errorexit;
}
} else if (fAnsiReceiver) {
LARGECOPYSTRINGLPWSTRA(&pcreatestruct->strName, d.cs.lpszName);
} else {
LARGECOPYSTRINGLPWSTR(&pcreatestruct->strName, d.cs.lpszName);
}
} else {
BYTE bOrdinal;
try {
bOrdinal = *(PBYTE)pcreatestruct->cs.lpszName;
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
goto errorexit;
}
if (bOrdinal == 0xff) {
/*
* Copy out an ordinal of the form 0xff, ID.
* If the receiver is UNICODE, expand the 0xff to 0xffff.
*/
if (fAnsiReceiver) {
if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf,
(PBYTE)pcreatestruct->cs.lpszName,
3, (PVOID *)&mp->d.cs.lpszName)))
goto errorexit;
} else {
DWORD dwOrdinal;
try {
dwOrdinal = MAKELONG(0xffff,
(*(DWORD UNALIGNED *)pcreatestruct->cs.lpszName >> 8));
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
goto errorexit;
}
if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf,
&dwOrdinal,
4, (PVOID *)&mp->d.cs.lpszName)))
goto errorexit;
}
} else if (fAnsiReceiver) {
LARGECOPYSTRINGLPSTR(&pcreatestruct->strName, d.cs.lpszName);
} else {
LARGECOPYSTRINGLPSTRW(&pcreatestruct->strName, d.cs.lpszName);
}
}
}
if (cbClass) {
if (!pcreatestruct->strClass.bAnsi) {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPWSTRA(&pcreatestruct->strClass, d.cs.lpszClass);
} else {
LARGECOPYSTRINGLPWSTR(&pcreatestruct->strClass, d.cs.lpszClass);
}
} else {
if (fAnsiReceiver) {
LARGECOPYSTRINGLPSTR(&pcreatestruct->strClass, d.cs.lpszClass);
} else {
LARGECOPYSTRINGLPSTRW(&pcreatestruct->strClass, d.cs.lpszClass);
}
}
}
MSGDATA()->d.hwndInsertAfter = pcbt->hwndInsertAfter;
MSGDATA()->xpfnProc = xpfnProc;
MSGDATA()->bAnsi = fAnsiReceiver;
LOCKPWND();
MAKECALLCAPTURE(FNHKINLPCBTCREATESTRUCT);
UNLOCKPWND();
CHECKRETURN();
/*
* Probe output data
*/
OUTSTRUCT(&csdOut, CREATESTRUCTDATA);
// MS Visual C centers its dialogs with the CBT_CREATEHOOK
pcbt->hwndInsertAfter = csdOut.hwndInsertAfter;
pcbt->lpcs->x = csdOut.cs.x;
pcbt->lpcs->y = csdOut.cs.y;
pcbt->lpcs->cx = csdOut.cs.cx;
pcbt->lpcs->cy = csdOut.cs.cy;
TRACECALLBACK("SfnHkINLPCBTCREATESTRUCT");
ENDSENDCAPTURE(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPCBTCREATESTRUCT, FNHKINLPCBTCREATESTRUCTMSG)
{
CBT_CREATEWND cbt;
BEGINRECV(0, &pmsg->d, sizeof(pmsg->d));
FIXUPPOINTERS();
cbt.lpcs = &pmsg->d.cs;
cbt.hwndInsertAfter = pmsg->d.hwndInsertAfter;
if ((ULONG_PTR)pmsg->d.cs.lpszName > gHighestUserAddress)
pmsg->d.cs.lpszName = REBASEPTR(pmsg->pwnd, pmsg->d.cs.lpszName);
if ((ULONG_PTR)pmsg->d.cs.lpszClass > gHighestUserAddress)
pmsg->d.cs.lpszClass = REBASEPTR(pmsg->pwnd, pmsg->d.cs.lpszClass);
if (pmsg->bAnsi) {
retval = DispatchHookA(
pmsg->msg,
pmsg->wParam,
(LPARAM)&cbt,
(HOOKPROC)pmsg->xpfnProc);
} else {
retval = DispatchHookW(
pmsg->msg,
pmsg->wParam,
(LPARAM)&cbt,
(HOOKPROC)pmsg->xpfnProc);
}
pmsg->d.hwndInsertAfter = cbt.hwndInsertAfter;
pmsg->d.cs.x = cbt.lpcs->x;
pmsg->d.cs.y = cbt.lpcs->y;
pmsg->d.cs.cx = cbt.lpcs->cx;
pmsg->d.cs.cy = cbt.lpcs->cy;
ENDRECV();
}
#endif // RECVSIDE
#ifdef REDIRECTION
/**************************************************************************\
* fnHkINLPPOINT
*
* 29-Jan-1999 clupu Created
\**************************************************************************/
typedef struct _FNHKINLPPOINTMSG {
DWORD nCode;
WPARAM wParam;
POINT pt;
ULONG_PTR xParam;
PROC xpfnProc;
} FNHKINLPPOINTMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPPOINT(
IN DWORD nCode,
IN WPARAM wParam,
IN OUT LPPOINT ppt,
IN ULONG_PTR xParam,
IN PROC xpfnProc)
{
SETUP(FNHKINLPPOINT)
BEGINSEND(FNHKINLPPOINT)
MSGDATA()->nCode = nCode;
MSGDATA()->wParam = wParam;
MSGDATA()->pt = *ppt;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MAKECALL(FNHKINLPPOINT);
CHECKRETURN();
/*
* Probe output data
*/
OUTSTRUCT(ppt, POINT);
TRACECALLBACK("SfnHkINLPPOINT");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPPOINT, FNHKINLPPOINTMSG)
{
BEGINRECV(0, &pmsg->pt, sizeof(POINT));
retval = (DWORD)CALLPROC(pmsg->xpfnProc)(
pmsg->nCode,
pmsg->wParam,
PCALLDATA(pt),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
#endif // REDIRECTION
/**************************************************************************\
* fnHkINLPRECT
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNHKINLPRECTMSG {
DWORD nCode;
WPARAM wParam;
RECT rect;
ULONG_PTR xParam;
PROC xpfnProc;
} FNHKINLPRECTMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPRECT(
IN DWORD nCode,
IN WPARAM wParam,
IN OUT LPRECT prect,
IN ULONG_PTR xParam,
IN PROC xpfnProc)
{
SETUP(FNHKINLPRECT)
BEGINSEND(FNHKINLPRECT)
MSGDATA()->nCode = nCode;
MSGDATA()->wParam = wParam;
MSGDATA()->rect = *prect;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MAKECALL(FNHKINLPRECT);
CHECKRETURN();
/*
* Probe output data
*/
OUTSTRUCT(prect, RECT);
TRACECALLBACK("SfnHkINLPRECT");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPRECT, FNHKINLPRECTMSG)
{
BEGINRECV(0, &pmsg->rect, sizeof(RECT));
retval = (DWORD)CALLPROC(pmsg->xpfnProc)(
pmsg->nCode,
pmsg->wParam,
PCALLDATA(rect),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNHKINDWORDMSG {
GENERICHOOKHEADER ghh;
DWORD flags;
LPARAM lParam;
} FNHKINDWORDMSG;
#ifdef SENDSIDE
LRESULT fnHkINDWORD(
IN DWORD nCode,
IN WPARAM wParam,
IN LPARAM lParam,
IN ULONG_PTR xParam,
IN PROC xpfnProc,
IN OUT LPDWORD lpFlags)
{
SETUP(FNHKINDWORD)
BEGINSEND(FNHKINDWORD)
MSGDATA()->ghh.nCode = nCode;
MSGDATA()->ghh.wParam = wParam;
MSGDATA()->lParam = lParam;
MSGDATA()->ghh.xParam = xParam;
MSGDATA()->ghh.xpfnProc = xpfnProc;
MSGDATA()->flags = *lpFlags;
MAKECALL(FNHKINDWORD);
CHECKRETURN();
/*
* Probe output data
*/
OUTBITMASK(lpFlags, DWORD, HF_HOOKFAULTED);
TRACECALLBACK("SfnHkINDWORD");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINDWORD, FNHKINDWORDMSG)
{
BEGINRECV(0, &pmsg->flags, sizeof(pmsg->flags));
retval = CallHookWithSEH((LPGENERICHOOKHEADER)pmsg, (LPVOID)pmsg->lParam, &pmsg->flags, retval);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNHKINLPMSGDATA {
MSG msg;
DWORD flags;
} FNHKINLPMSGDATA;
typedef struct _FNHKINLPMSGMSG {
GENERICHOOKHEADER ghh;
FNHKINLPMSGDATA d;
} FNHKINLPMSGMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPMSG(
DWORD nCode,
WPARAM wParam,
LPMSG pmsg,
ULONG_PTR xParam,
PROC xpfnProc,
BOOL bAnsi,
LPDWORD lpFlags)
{
SETUP(FNHKINLPMSG)
WPARAM wParamOriginal;
BEGINSEND(FNHKINLPMSG)
MSGDATA()->ghh.nCode = nCode;
MSGDATA()->ghh.wParam = wParam;
MSGDATA()->d.msg = *pmsg;
if (((WM_CHAR == pmsg->message) || (WM_SYSCHAR == pmsg->message)) && bAnsi) {
wParamOriginal = pmsg->wParam;
RtlWCSMessageWParamCharToMB(pmsg->message, &(MSGDATA()->d.msg.wParam));
}
MSGDATA()->ghh.xParam = xParam;
MSGDATA()->ghh.xpfnProc = xpfnProc;
MSGDATA()->d.flags = *lpFlags;
MAKECALL(FNHKINLPMSG);
CHECKRETURN();
/*
* Probe output data
*/
try {
ProbeForRead(pcbs->pOutput, sizeof(FNHKINLPMSGDATA), sizeof(DWORD));
*pmsg = ((FNHKINLPMSGDATA *)pcbs->pOutput)->msg;
COPY_FLAG(*lpFlags, ((FNHKINLPMSGDATA *)pcbs->pOutput)->flags, HF_HOOKFAULTED);
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
MSGERROR();
}
if (((WM_CHAR == pmsg->message) || (WM_SYSCHAR == pmsg->message)) && bAnsi) {
/*
* LATER, DBCS should be handled correctly.
*/
/*
* If the ANSI hook didn't change the wParam we sent it, restore
* the Unicode value we started with, otherwise we just collapse
* Unicode chars to an ANSI codepage (best visual fit or ?)
* The rotten "Intellitype" point32.exe does this.
*/
if (MSGDATA()->d.msg.wParam == pmsg->wParam) {
pmsg->wParam = wParamOriginal;
} else {
RtlMBMessageWParamCharToWCS(pmsg->message, &pmsg->wParam);
}
}
TRACECALLBACK("SfnHkINLPMSG");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPMSG, FNHKINLPMSGMSG)
{
BEGINRECV(0, &pmsg->d, sizeof(pmsg->d));
/*
* LATER, DBCS should be handled correctly.
*/
retval = CallHookWithSEH((LPGENERICHOOKHEADER)pmsg, &pmsg->d.msg, &pmsg->d.flags, retval);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNHKINLPMOUSEHOOKSTRUCTEXMSG {
GENERICHOOKHEADER ghh;
DWORD flags;
MOUSEHOOKSTRUCTEX mousehookstructex;
} FNHKINLPMOUSEHOOKSTRUCTEXMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPMOUSEHOOKSTRUCTEX(
IN DWORD nCode,
IN WPARAM wParam,
IN LPMOUSEHOOKSTRUCTEX pmousehookstructex,
IN ULONG_PTR xParam,
IN PROC xpfnProc,
IN OUT LPDWORD lpFlags)
{
SETUP(FNHKINLPMOUSEHOOKSTRUCTEX)
BEGINSEND(FNHKINLPMOUSEHOOKSTRUCTEX)
MSGDATA()->ghh.nCode = nCode;
MSGDATA()->ghh.wParam = wParam;
MSGDATA()->mousehookstructex = *pmousehookstructex;
MSGDATA()->ghh.xParam = xParam;
MSGDATA()->ghh.xpfnProc = xpfnProc;
MSGDATA()->flags = *lpFlags;
MAKECALL(FNHKINLPMOUSEHOOKSTRUCTEX);
CHECKRETURN();
/*
* Probe output data
*/
OUTBITMASK(lpFlags, DWORD, HF_HOOKFAULTED);
TRACECALLBACK("SfnHkINLPMOUSEHOOKSTRUCTEX");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPMOUSEHOOKSTRUCTEX, FNHKINLPMOUSEHOOKSTRUCTEXMSG)
{
BEGINRECV(0, &pmsg->flags, sizeof(pmsg->flags));
retval = CallHookWithSEH((LPGENERICHOOKHEADER)pmsg, &pmsg->mousehookstructex, &pmsg->flags, retval);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* kbdll
*
* 06-Jun-1996 clupu Created
\**************************************************************************/
typedef struct _FNHKINLPKBDLLHOOKSTRUCTMSG {
GENERICHOOKHEADER ghh;
KBDLLHOOKSTRUCT kbdllhookstruct;
} FNHKINLPKBDLLHOOKSTRUCTMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPKBDLLHOOKSTRUCT(
IN DWORD nCode,
IN WPARAM wParam,
IN LPKBDLLHOOKSTRUCT pkbdllhookstruct,
IN ULONG_PTR xParam,
IN PROC xpfnProc)
{
SETUP(FNHKINLPKBDLLHOOKSTRUCT)
BEGINSEND(FNHKINLPKBDLLHOOKSTRUCT)
MSGDATA()->ghh.nCode = nCode;
MSGDATA()->ghh.wParam = wParam;
MSGDATA()->kbdllhookstruct = *pkbdllhookstruct;
MSGDATA()->ghh.xParam = xParam;
MSGDATA()->ghh.xpfnProc = xpfnProc;
MAKECALL(FNHKINLPKBDLLHOOKSTRUCT);
CHECKRETURN();
TRACECALLBACK("SfnHkINLPKBDLLHOOKSTRUCT");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPKBDLLHOOKSTRUCT, FNHKINLPKBDLLHOOKSTRUCTMSG)
{
BEGINRECV(0, &pmsg->kbdllhookstruct, sizeof(pmsg->kbdllhookstruct));
retval = (DWORD)CALLPROC(pmsg->ghh.xpfnProc)(
pmsg->ghh.nCode,
pmsg->ghh.wParam,
&pmsg->kbdllhookstruct,
pmsg->ghh.xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* msll
*
* 06-Jun-1996 clupu Created
\**************************************************************************/
typedef struct _FNHKINLPMSLLHOOKSTRUCTMSG {
GENERICHOOKHEADER ghh;
MSLLHOOKSTRUCT msllhookstruct;
} FNHKINLPMSLLHOOKSTRUCTMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPMSLLHOOKSTRUCT(
IN DWORD nCode,
IN WPARAM wParam,
IN LPMSLLHOOKSTRUCT pmsllhookstruct,
IN ULONG_PTR xParam,
IN PROC xpfnProc)
{
SETUP(FNHKINLPMSLLHOOKSTRUCT)
BEGINSEND(FNHKINLPMSLLHOOKSTRUCT)
MSGDATA()->ghh.nCode = nCode;
MSGDATA()->ghh.wParam = wParam;
MSGDATA()->msllhookstruct = *pmsllhookstruct;
MSGDATA()->ghh.xParam = xParam;
MSGDATA()->ghh.xpfnProc = xpfnProc;
MAKECALL(FNHKINLPMSLLHOOKSTRUCT);
CHECKRETURN();
TRACECALLBACK("SfnHkINLPMSLLHOOKSTRUCT");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPMSLLHOOKSTRUCT, FNHKINLPMSLLHOOKSTRUCTMSG)
{
BEGINRECV(0, &pmsg->msllhookstruct, sizeof(pmsg->msllhookstruct));
retval = (DWORD)CALLPROC(pmsg->ghh.xpfnProc)(
pmsg->ghh.nCode,
pmsg->ghh.wParam,
&pmsg->msllhookstruct,
pmsg->ghh.xParam);
ENDRECV();
}
#endif // RECVSIDE
#ifdef REDIRECTION
/**************************************************************************\
* ht
*
* 21-Jan-1999 clupu Created
\**************************************************************************/
typedef struct _FNHKINLPHTHOOKSTRUCTMSG {
GENERICHOOKHEADER ghh;
HTHOOKSTRUCT hthookstruct;
} FNHKINLPHTHOOKSTRUCTMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPHTHOOKSTRUCT(
IN DWORD nCode,
IN WPARAM wParam,
IN OUT LPHTHOOKSTRUCT phthookstruct,
IN ULONG_PTR xParam,
IN PROC xpfnProc)
{
SETUP(FNHKINLPHTHOOKSTRUCT)
BEGINSEND(FNHKINLPHTHOOKSTRUCT)
MSGDATA()->ghh.nCode = nCode;
MSGDATA()->ghh.wParam = wParam;
MSGDATA()->hthookstruct = *phthookstruct;
MSGDATA()->ghh.xParam = xParam;
MSGDATA()->ghh.xpfnProc = xpfnProc;
MAKECALL(FNHKINLPHTHOOKSTRUCT);
CHECKRETURN();
/*
* Probe output data
*/
if (phthookstruct != NULL)
OUTSTRUCT(phthookstruct, HTHOOKSTRUCT);
TRACECALLBACK("SfnHkINLPHTHOOKSTRUCT");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPHTHOOKSTRUCT, FNHKINLPHTHOOKSTRUCTMSG)
{
BEGINRECV(0, &pmsg->hthookstruct, sizeof(pmsg->hthookstruct));
retval = (DWORD)CALLPROC(pmsg->ghh.xpfnProc)(
pmsg->ghh.nCode,
pmsg->ghh.wParam,
&pmsg->hthookstruct,
pmsg->ghh.xParam);
ENDRECV();
}
#endif // RECVSIDE
#endif // REDIRECTION
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _FNHKOPTINLPEVENTMSGMSG {
DWORD nCode;
WPARAM wParam;
LPEVENTMSGMSG peventmsgmsg;
ULONG_PTR xParam;
PROC xpfnProc;
EVENTMSG eventmsgmsg;
} FNHKOPTINLPEVENTMSGMSG;
#ifdef SENDSIDE
LRESULT fnHkOPTINLPEVENTMSG(
IN DWORD nCode,
IN WPARAM wParam,
IN OUT LPEVENTMSGMSG peventmsgmsg,
IN ULONG_PTR xParam,
IN PROC xpfnProc)
{
SETUP(FNHKOPTINLPEVENTMSG)
BEGINSEND(FNHKOPTINLPEVENTMSG)
MSGDATA()->nCode = nCode;
MSGDATA()->wParam = wParam;
COPYSTRUCTOPT(eventmsgmsg);
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MAKECALL(FNHKOPTINLPEVENTMSG);
CHECKRETURN();
/*
* Probe output data
*/
if (peventmsgmsg != NULL)
OUTSTRUCT(peventmsgmsg, EVENTMSG);
TRACECALLBACK("SfnHkOPTINLPEVENTMSG");
ENDSEND(DWORD,-1);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkOPTINLPEVENTMSG, FNHKOPTINLPEVENTMSGMSG)
{
PHOOK phk;
BEGINRECV(-1, &pmsg->eventmsgmsg, sizeof(pmsg->eventmsgmsg));
if (pmsg->wParam) {
phk = (PHOOK)HMValidateHandle((HANDLE)pmsg->wParam, TYPE_HOOK);
if (phk != NULL) {
/*
* The HF_NEEDHC_SKIP bit is passed on from the pti when we need to
* pass on a HC_SKIP
*/
if ((phk->flags & HF_NEEDHC_SKIP) &&
(HIWORD(pmsg->nCode) == WH_JOURNALPLAYBACK)) {
UserAssert(LOWORD(pmsg->nCode) == HC_GETNEXT);
CALLPROC(pmsg->xpfnProc)(
MAKELONG(HC_SKIP, HIWORD(pmsg->nCode)),
0,
0,
pmsg->xParam);
}
/*
* Make sure the hook wasn't free'd during the last call to the app
*/
if (HMIsMarkDestroy(phk)) {
retval = (DWORD)-1;
goto AllDoneHere;
}
}
}
pmsg->wParam = 0;
retval = (DWORD)CALLPROC(pmsg->xpfnProc)(
pmsg->nCode,
pmsg->wParam,
PCALLDATAOPT(eventmsgmsg),
pmsg->xParam);
AllDoneHere:
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
/*
* Create a structure big enough to hold the larges item LPARAM points to.
*/
typedef union _DEBUGLPARAM {
MSG msg; // WH_GETMESSAGE, WH_MSGFILTER, WH_SYSMSGFILTER
CWPSTRUCT cwp; // WH_CALLWNDPROC
CWPRETSTRUCT cwpret; // WH_CALLWNDPROCRET
MOUSEHOOKSTRUCTEX mhs; // WH_MOUSE, HCBT_CLICKSKIPPED
EVENTMSG em; // WH_JOURNALRECORD, WH_JOURNALPLAYBACK
CBTACTIVATESTRUCT as; // HCBT_ACTIVATE
CBT_CREATEWND cw; // HCBT_CREATEWND
RECT rc; // HCBT_MOVESIZE
} DEBUGLPARAM;
typedef struct _FNHKINLPDEBUGHOOKSTRUCTMSG {
DWORD nCode;
WPARAM wParam;
DEBUGHOOKINFO debughookstruct;
DEBUGLPARAM dbgLParam;
DWORD cbDbgLParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNHKINLPDEBUGHOOKSTRUCTMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPDEBUGHOOKSTRUCT(
IN DWORD nCode,
IN WPARAM wParam,
IN LPDEBUGHOOKINFO pdebughookstruct,
IN ULONG_PTR xParam,
IN PROC xpfnProc)
{
SETUP(FNHKINLPDEBUGHOOKSTRUCT)
BEGINSEND(FNHKINLPDEBUGHOOKSTRUCT)
MSGDATA()->nCode = nCode;
MSGDATA()->wParam = wParam;
MSGDATA()->debughookstruct = *pdebughookstruct;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MSGDATA()->cbDbgLParam = GetDebugHookLParamSize(wParam, pdebughookstruct);
switch(wParam) {
case WH_MOUSE_LL:
case WH_KEYBOARD_LL:
return 0;
}
/*
* if LPARAM in the debug hook points to struct then copy it over
*/
if (MSGDATA()->cbDbgLParam) {
try {
RtlCopyMemory(&MSGDATA()->dbgLParam, (BYTE *)pdebughookstruct->lParam,
MSGDATA()->cbDbgLParam);
} except (W32ExceptionHandler(FALSE, RIP_WARNING)) {
MSGERROR();
}
}
MAKECALL(FNHKINLPDEBUGHOOKSTRUCT);
CHECKRETURN();
TRACECALLBACK("SfnHkINLPDEBUGHOOKSTRUCT");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPDEBUGHOOKSTRUCT, FNHKINLPDEBUGHOOKSTRUCTMSG)
{
BEGINRECV(0, NULL, 0);
if (pmsg->cbDbgLParam) {
pmsg->debughookstruct.lParam = (LPARAM)&(pmsg->dbgLParam);
}
retval = (DWORD)CALLPROC(pmsg->xpfnProc)(
pmsg->nCode,
pmsg->wParam,
&(pmsg->debughookstruct),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
DWORD GetDebugHookLParamSize(
IN WPARAM wParam,
IN PDEBUGHOOKINFO pdebughookstruct)
{
DWORD cbDbgLParam = 0;
switch(wParam) {
case WH_MSGFILTER:
case WH_SYSMSGFILTER:
case WH_GETMESSAGE:
cbDbgLParam = sizeof(MSG);
break;
case WH_CALLWNDPROC:
cbDbgLParam = sizeof(CWPSTRUCT);
break;
case WH_CALLWNDPROCRET:
cbDbgLParam = sizeof(CWPRETSTRUCT);
break;
case WH_MOUSE:
cbDbgLParam = sizeof(MOUSEHOOKSTRUCTEX);
break;
case WH_JOURNALRECORD:
case WH_JOURNALPLAYBACK:
cbDbgLParam = sizeof(EVENTMSG);
break;
case WH_CBT:
switch (pdebughookstruct->code) {
case HCBT_ACTIVATE:
cbDbgLParam = sizeof(CBTACTIVATESTRUCT);
break;
case HCBT_CLICKSKIPPED:
cbDbgLParam = sizeof(MOUSEHOOKSTRUCTEX);
break;
case HCBT_CREATEWND:
cbDbgLParam = sizeof(CBT_CREATEWND);
break;
case HCBT_MOVESIZE:
cbDbgLParam = sizeof(RECT);
break;
}
break;
case WH_SHELL:
if (pdebughookstruct->code == HSHELL_GETMINRECT) {
cbDbgLParam = sizeof(RECT);
}
break;
}
return cbDbgLParam;
}
/**************************************************************************\
* fnHkINLPCBTACTIVATESTRUCT
*
* 17-Mar-1992 jonpa Created
\**************************************************************************/
typedef struct _FNHKINLPCBTACTIVATESTRUCTMSG {
DWORD nCode;
WPARAM wParam;
CBTACTIVATESTRUCT cbtactivatestruct;
ULONG_PTR xParam;
PROC xpfnProc;
} FNHKINLPCBTACTIVATESTRUCTMSG;
#ifdef SENDSIDE
LRESULT fnHkINLPCBTACTIVATESTRUCT(
IN DWORD nCode,
IN WPARAM wParam,
IN LPCBTACTIVATESTRUCT pcbtactivatestruct,
IN ULONG_PTR xParam,
IN PROC xpfnProc)
{
SETUP(FNHKINLPCBTACTIVATESTRUCT)
BEGINSEND(FNHKINLPCBTACTIVATESTRUCT)
MSGDATA()->nCode = nCode;
MSGDATA()->wParam = wParam;
MSGDATA()->cbtactivatestruct = *pcbtactivatestruct;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MAKECALL(FNHKINLPCBTACTIVATESTRUCT);
CHECKRETURN();
TRACECALLBACK("SfnHkINLPCBTACTIVATESTRUCT");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnHkINLPCBTACTIVATESTRUCT, FNHKINLPCBTACTIVATESTRUCTMSG)
{
BEGINRECV(0, NULL, 0);
retval = (DWORD)CALLPROC(pmsg->xpfnProc)(
pmsg->nCode,
pmsg->wParam,
&(pmsg->cbtactivatestruct),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* ClientLoadMenu
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _CLIENTLOADMENUMSG {
CAPTUREBUF CaptureBuf;
HANDLE hmod;
UNICODE_STRING strName;
} CLIENTLOADMENUMSG;
#ifdef SENDSIDE
PMENU xxxClientLoadMenu(
IN HANDLE hmod,
IN PUNICODE_STRING pstrName)
{
DWORD cCapture, cbCapture;
SETUP(CLIENTLOADMENU)
if (pstrName->MaximumLength) {
cCapture = 1;
cbCapture = pstrName->MaximumLength;
} else
cCapture = cbCapture = 0;
BEGINSENDCAPTURE(CLIENTLOADMENU, cCapture, cbCapture, TRUE)
MSGDATA()->hmod = hmod;
COPYSTRINGID(strName);
MAKECALLCAPTURE(CLIENTLOADMENU);
CHECKRETURN();
retval = (ULONG_PTR)HtoP((HMENU)retval);
TRACECALLBACK("ClientLoadMenu");
ENDSENDCAPTURE(PMENU,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientLoadMenu, CLIENTLOADMENUMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)LoadMenu(
CALLDATA(hmod) ? CALLDATA(hmod) : hmodUser,
(LPTSTR)FIXUPSTRINGID(strName));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* xxxClientLoadImage
*
* 28-Aug-1995 ChrisWil Created
\**************************************************************************/
typedef struct _CLIENTLOADIMAGEMSG {
CAPTUREBUF CaptureBuf;
UNICODE_STRING strModName;
UNICODE_STRING strName;
UINT uImageType;
int cxDesired;
int cyDesired;
UINT LR_flags;
BOOL fWallpaper;
} CLIENTLOADIMAGEMSG;
#ifdef SENDSIDE
HANDLE xxxClientLoadImage(
IN PUNICODE_STRING pstrName,
IN ATOM atomModName,
IN WORD wImageType,
IN int cxDesired,
IN int cyDesired,
IN UINT LR_flags,
IN BOOL fWallpaper)
{
DWORD cCapture;
DWORD cbCapture;
WCHAR awszModName[MAX_PATH];
UNICODE_STRING strModName;
PUNICODE_STRING pstrModName = &strModName;
SETUP(CLIENTLOADIMAGE)
if (pstrName->MaximumLength) {
cCapture = 1;
cbCapture = pstrName->MaximumLength;
} else {
cCapture =
cbCapture = 0;
}
if (atomModName && atomModName != atomUSER32) {
UserGetAtomName(atomModName, awszModName, MAX_PATH);
RtlInitUnicodeString(&strModName, awszModName);
} else {
strModName.Length = strModName.MaximumLength = 0;
strModName.Buffer = NULL;
}
if (pstrModName->MaximumLength) {
cCapture++;
cbCapture += pstrModName->MaximumLength;
}
BEGINSENDCAPTURE(CLIENTLOADIMAGE, cCapture, cbCapture, TRUE)
COPYSTRINGOPT(strModName);
COPYSTRINGID(strName);
MSGDATA()->uImageType = (UINT)wImageType;
MSGDATA()->cxDesired = cxDesired;
MSGDATA()->cyDesired = cyDesired;
MSGDATA()->LR_flags = LR_flags;
MSGDATA()->fWallpaper = fWallpaper;
MAKECALLCAPTURE(CLIENTLOADIMAGE);
CHECKRETURN();
if (retval && (wImageType != IMAGE_BITMAP)) {
retval = (ULONG_PTR)HMRevalidateHandle((HANDLE)retval);
}
TRACECALLBACK("ClientLoadImage");
ENDSENDCAPTURE(PCURSOR,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientLoadImage, CLIENTLOADIMAGEMSG)
{
HMODULE hmod;
LPTSTR filepart;
LPTSTR lpszName;
TCHAR szFullPath[MAX_PATH];
TCHAR szExpandedPath[MAX_PATH];
DWORD dwRet;
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
if (hmod = (HMODULE)FIXUPSTRINGIDOPT(strModName)) {
if ((hmod = GetModuleHandle((LPTSTR)hmod)) == NULL) {
MSGERROR();
}
}
/*
* Find the file. This normalizes the filename.
*/
lpszName = (LPTSTR)FIXUPSTRINGID(strName);
if (CALLDATA(fWallpaper)) {
/*
* Expand any environment strings in the path. This is beneficial
* for people using roaming profiles. See bug #89188.
*/
dwRet = ExpandEnvironmentStrings(lpszName, szExpandedPath, MAX_PATH);
/*
* dwRet > MAX_PATH means that the buffer we supplied was too small. If
* this happens, there's no way the LoadImage can succeed - even if the
* buffer were big enough, as the filename can't possibly refer to a
* valid file - so fail the call.
*/
if (dwRet == 0 || dwRet > MAX_PATH) {
MSGERROR();
}
if (!SearchPath(NULL,
szExpandedPath,
TEXT(".bmp"),
ARRAY_SIZE(szFullPath),
szFullPath,
&filepart)) {
MSGERROR();
}
lpszName = szFullPath;
}
retval = (ULONG_PTR)LoadImage(hmod,
lpszName,
CALLDATA(uImageType),
CALLDATA(cxDesired),
CALLDATA(cyDesired),
CALLDATA(LR_flags));
ENDRECV();
}
#endif // RECVSIDE
/***********************************************************************\
* xxxClientCopyImage
*
* Returns: hIconCopy - note LR_flags could cause this to be the same as
* what came in.
*
* 11/3/1995 Created SanfordS
\***********************************************************************/
typedef struct _CLIENTCOPYIMAGEMSG {
HANDLE hImage;
UINT uImageType;
int cxDesired;
int cyDesired;
UINT LR_flags;
} CLIENTCOPYIMAGEMSG;
#ifdef SENDSIDE
HANDLE xxxClientCopyImage(
IN HANDLE hImage,
IN UINT uImageType,
IN int cxDesired,
IN int cyDesired,
IN UINT LR_flags)
{
SETUP(CLIENTCOPYIMAGE)
BEGINSEND(CLIENTCOPYIMAGE)
MSGDATA()->hImage = hImage;
MSGDATA()->uImageType = uImageType;
MSGDATA()->cxDesired = cxDesired;
MSGDATA()->cyDesired = cyDesired;
MSGDATA()->LR_flags = LR_flags;
MAKECALL(CLIENTCOPYIMAGE);
CHECKRETURN();
if (retval && (uImageType != IMAGE_BITMAP)) {
retval = (ULONG_PTR)HMRevalidateHandle((HANDLE)retval);
}
TRACECALLBACK("ClientCopyImage");
ENDSEND(HANDLE,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientCopyImage, CLIENTCOPYIMAGEMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)InternalCopyImage(CALLDATA(hImage),
CALLDATA(uImageType),
CALLDATA(cxDesired),
CALLDATA(cyDesired),
CALLDATA(LR_flags));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _CLIENTGETLISTBOXSTRINGMSG {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfn;
PBYTE pOutput;
DWORD cbOutput;
} CLIENTGETLISTBOXSTRINGMSG;
#ifdef SENDSIDE
DWORD ClientGetListboxString(
IN PWND pwnd,
IN UINT msg,
IN WPARAM wParam,
OUT PVOID pdata,
IN ULONG_PTR xParam,
IN PROC xpfn,
IN DWORD dwSCMSFlags,
IN BOOL bNotString,
IN PSMS psms)
{
DWORD cbCapture;
DWORD cchRet;
PLARGE_STRING pstr;
BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI);
SETUPPWND(CLIENTGETLISTBOXSTRING)
CheckLock(pwnd);
pstr = (PLARGE_STRING)pdata;
cbCapture = pstr->MaximumLength;
BEGINSENDCAPTURE(CLIENTGETLISTBOXSTRING, 1, cbCapture, FALSE)
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfn = xpfn;
RESERVEBYTES(cbCapture, pOutput, cbOutput);
LOCKPWND();
MAKECALLCAPTURE(CLIENTGETLISTBOXSTRING);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
if (bNotString) {
/*
* This is a 4-byte "object" for ownerdraw listboxes without
* the LBS_HASSTRINGS style.
*/
OUTSTRUCT((PULONG_PTR)pstr->Buffer, ULONG_PTR);
} else {
COPYOUTLPWSTRLIMIT(pstr,
pstr->bAnsi ? (int)pstr->MaximumLength :
(int)pstr->MaximumLength / sizeof(WCHAR));
}
cchRet = pstr->Length;
if (!pstr->bAnsi)
cchRet *= sizeof(WCHAR);
if (!bNotString && retval != LB_ERR && retval > cchRet) {
RIPMSG2(RIP_WARNING, "GetListBoxString: limit %lX chars to %lX\n",
retval, cchRet);
retval = cchRet;
}
ENDCOPYOUT()
TRACECALLBACK("ClientGetListboxString");
ENDSENDCAPTURE(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientGetListboxString, CLIENTGETLISTBOXSTRINGMSG)
{
BYTE abOutput[CALLBACKSTACKLIMIT];
BEGINRECV(0, NULL, pmsg->cbOutput);
FIXUPPOINTERS();
if (pmsg->cbOutput <= CALLBACKSTACKLIMIT)
CallbackStatus.pOutput = abOutput;
else
CallbackStatus.pOutput = pmsg->pOutput;
retval = (DWORD)_ClientGetListboxString(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
(LPSTR)KPVOID_TO_PVOID(CallbackStatus.pOutput),
CALLDATA(xParam),
CALLDATA(xpfn));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _CLIENTLOADLIBRARYMSG {
CAPTUREBUF CaptureBuf;
UNICODE_STRING strLib;
ULONG_PTR offPfnInitUserApiHook;
} CLIENTLOADLIBRARYMSG;
#ifdef SENDSIDE
HANDLE ClientLoadLibrary(
IN PUNICODE_STRING pstrLib,
IN ULONG_PTR offPfnInitUserApiHook)
{
SETUP(CLIENTLOADLIBRARY)
BEGINSENDCAPTURE(CLIENTLOADLIBRARY, 1, pstrLib->MaximumLength, TRUE)
MSGDATA()->offPfnInitUserApiHook = offPfnInitUserApiHook;
COPYSTRING(strLib);
MAKECALLCAPTURE(CLIENTLOADLIBRARY);
CHECKRETURN();
TRACECALLBACK("ClientLoadLibrary");
ENDSENDCAPTURE(HANDLE,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientLoadLibrary, CLIENTLOADLIBRARYMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (ULONG_PTR)LoadLibraryEx((LPTSTR)FIXUPSTRING(strLib), NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
/*
* If we're loading the module containing the UserApiHook's,
* make sure it's correctly initialized.
*/
if ((retval != 0) && CALLDATA(offPfnInitUserApiHook)) {
if (!InitUserApiHook((HMODULE)retval, CALLDATA(offPfnInitUserApiHook))) {
FreeLibrary((HMODULE)retval);
retval = 0;
MSGERROR();
}
}
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* yyy
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _CLIENTFREELIBRARYMSG {
HANDLE hmod;
} CLIENTFREELIBRARYMSG;
#ifdef SENDSIDE
BOOL ClientFreeLibrary(
IN HANDLE hmod)
{
SETUP(CLIENTFREELIBRARY)
BEGINSEND(CLIENTFREELIBRARY)
MSGDATA()->hmod = hmod;
MAKECALL(CLIENTFREELIBRARY);
CHECKRETURN();
TRACECALLBACK("ClientFreeLibrary");
ENDSEND(BOOL,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientFreeLibrary, CLIENTFREELIBRARYMSG)
{
BEGINRECV(0, NULL, 0);
/*
* Make sure we don't free a UserApiHook module that's in use.
*/
if (!ClearUserApiHook(CALLDATA(hmod))) {
MSGERROR();
}
retval = (DWORD)FreeLibrary(CALLDATA(hmod));
ENDRECV();
}
#endif // RECVSIDE
#ifdef MESSAGE_PUMP_HOOK
/**************************************************************************\
* GetMessageMPH()
*
* 06-Dec-2000 JStall Created
\**************************************************************************/
typedef struct _CLIENTGETMESSAGEMPHMSG {
HWND hwndFilter;
UINT msgMin;
UINT msgMax;
UINT flags;
BOOL fGetMessage;
} CLIENTGETMESSAGEMPHMSG;
#ifdef SENDSIDE
BOOL ClientGetMessageMPH(
IN MSG * pmsg,
IN HWND hwndFilter,
IN UINT msgMin,
IN UINT msgMax,
IN UINT flags,
IN BOOL fGetMessage)
{
SETUP(CLIENTGETMESSAGEMPH)
BEGINSEND(CLIENTGETMESSAGEMPH)
MSGDATA()->hwndFilter = hwndFilter;
MSGDATA()->msgMin = msgMin;
MSGDATA()->msgMax = msgMax;
MSGDATA()->flags = flags;
MSGDATA()->fGetMessage = fGetMessage;
MAKECALL(CLIENTGETMESSAGEMPH);
CHECKRETURN();
OUTSTRUCT(pmsg, MSG);
TRACECALLBACK("ClientGetMessageMPH");
ENDSEND(BOOL,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientGetMessageMPH, CLIENTGETMESSAGEMPHMSG)
{
MSG msg;
BEGINRECV(0, &msg, sizeof(msg));
retval = (ULONG_PTR)(gmph.pfnInternalGetMessage)(&msg, CALLDATA(hwndFilter),
CALLDATA(msgMin), CALLDATA(msgMax), CALLDATA(flags), CALLDATA(fGetMessage));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* WaitMessageMPH()
*
* 06-Dec-2000 JStall Created
\**************************************************************************/
typedef struct _CLIENTWAITMESSAGEEXMPHMSG {
UINT fsWakeMask;
DWORD Timeout;
} CLIENTWAITMESSAGEEXMPHMSG;
#ifdef SENDSIDE
BOOL ClientWaitMessageExMPH(
IN UINT fsWakeMask,
IN DWORD Timeout)
{
SETUP(CLIENTWAITMESSAGEEXMPH)
BEGINSEND(CLIENTWAITMESSAGEEXMPH)
MSGDATA()->fsWakeMask = fsWakeMask;
MSGDATA()->Timeout = Timeout;
MAKECALL(CLIENTWAITMESSAGEEXMPH);
CHECKRETURN();
TRACECALLBACK("ClientWaitMessageExMPH");
ENDSEND(BOOL,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientWaitMessageExMPH, CLIENTWAITMESSAGEEXMPHMSG)
{
BEGINRECV(0, NULL, 0);
retval = (ULONG_PTR)(gmph.pfnWaitMessageEx)(CALLDATA(fsWakeMask), CALLDATA(Timeout));
ENDRECV();
}
#endif // RECVSIDE
#endif // MESSAGE_PUMP_HOOK
/**************************************************************************\
* xxxClientGetCharsetInfo
*
* 96-06-11 IanJa Created
\**************************************************************************/
typedef struct _CLIENTGETCHARSETINFOMSG {
LCID lcid;
CHARSETINFO cs;
} CLIENTGETCHARSETINFOMSG;
#ifdef SENDSIDE
BOOL xxxClientGetCharsetInfo(
IN LCID lcid,
OUT PCHARSETINFO pcs)
{
SETUP(CLIENTGETCHARSETINFO)
BEGINSEND(CLIENTGETSCHARSETINFO)
MSGDATA()->lcid = lcid;
MAKECALL(CLIENTGETCHARSETINFO);
CHECKRETURN();
OUTSTRUCT(pcs, CHARSETINFO);
TRACECALLBACK("ClientGetCharsetInfo");
ENDSEND(BOOL,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientGetCharsetInfo, CLIENTGETCHARSETINFOMSG)
{
BEGINRECV(0, &pmsg->cs, sizeof(CHARSETINFO));
// TCI_SRCLOCALE = 0x1000
// Sundown: lcid value should be zero-extended in the TCI_SRCLOCALE case.
retval = (DWORD)TranslateCharsetInfo((DWORD *)ULongToPtr( pmsg->lcid ), &pmsg->cs, TCI_SRCLOCALE);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* ClientFreeDDEHandle
*
* 9-29-91 sanfords Created.
\**************************************************************************/
typedef struct _CLIENTFREEDDEHANDLEMSG {
HANDLE hClient;
DWORD flags;
} CLIENTFREEDDEHANDLEMSG;
#ifdef SENDSIDE
DWORD ClientFreeDDEHandle(
IN HANDLE hClient,
IN DWORD flags)
{
SETUP(CLIENTFREEDDEHANDLE)
BEGINSEND(CLIENTFREEDDEHANDLE)
MSGDATA()->hClient = hClient;
MSGDATA()->flags = flags;
MAKECALL(CLIENTFREEDDEHANDLE);
CHECKRETURN();
TRACECALLBACK("ClientFreeDDEHandle");
ENDSEND(DWORD, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientFreeDDEHandle, CLIENTFREEDDEHANDLEMSG)
{
BEGINRECV(0, NULL, 0);
_ClientFreeDDEHandle(CALLDATA(hClient), CALLDATA(flags));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* ClientGetDDEFlags
*
* This function is used to get a peek at the wStatus flags packed within
* DDE handles - this could either be within the DdePack structure directly
* or within the direct data handle given or referenced via the DdePack
* structure. flags is used to figure out the right thing to do.
*
* 9-29-91 sanfords Created.
\**************************************************************************/
typedef struct _CLIENTGETDDEFLAGSMSG {
HANDLE hClient;
DWORD flags;
} CLIENTGETDDEFLAGSMSG;
#ifdef SENDSIDE
DWORD ClientGetDDEFlags(
IN HANDLE hClient,
IN DWORD flags)
{
SETUP(CLIENTGETDDEFLAGS)
BEGINSEND(CLIENTGETDDEFLAGS)
MSGDATA()->hClient = hClient;
MSGDATA()->flags = flags;
MAKECALL(CLIENTGETDDEFLAGS);
CHECKRETURN();
TRACECALLBACK("ClientGetDDEFlags");
ENDSEND(DWORD, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientGetDDEFlags, CLIENTGETDDEFLAGSMSG)
{
BEGINRECV(0, NULL, 0);
retval = _ClientGetDDEFlags(CALLDATA(hClient), CALLDATA(flags));
ENDRECV();
}
#endif // RECVSIDE
/************************************************************************
* ClientCopyDDEIn1
*
* History:
* 10-22-91 sanfords Created
\***********************************************************************/
typedef struct _CLIENTCOPYDDEIN1MSG {
HANDLE hClient; // client side DDE handle - non-0 on initial call
DWORD flags;
} CLIENTCOPYDDEIN1MSG;
#ifdef SENDSIDE
DWORD xxxClientCopyDDEIn1(
HANDLE hClient,
DWORD flags,
PINTDDEINFO *ppi)
{
PINTDDEINFO pi;
INTDDEINFO IntDdeInfo;
SETUP(CLIENTCOPYDDEIN1)
BEGINSEND(CLIENTCOPYDDEIN1)
retval = FAIL_POST;
*ppi = NULL;
MSGDATA()->hClient = hClient;
MSGDATA()->flags = flags;
MAKECALL(CLIENTCOPYDDEIN1);
CHECKRETURN();
if (retval != DO_POST) {
MSGERROR();
}
try {
OUTSTRUCT(&IntDdeInfo, INTDDEINFO);
pi = (PINTDDEINFO)UserAllocPool(
sizeof(INTDDEINFO) + IntDdeInfo.cbDirect +
IntDdeInfo.cbIndirect, TAG_DDE);
if (pi != NULL) {
*ppi = pi;
*pi = IntDdeInfo;
if (IntDdeInfo.cbDirect) {
RtlCopyMemory((PBYTE)pi + sizeof(INTDDEINFO),
IntDdeInfo.pDirect,
IntDdeInfo.cbDirect);
}
if (IntDdeInfo.cbIndirect) {
RtlCopyMemory((PBYTE)pi + sizeof(INTDDEINFO) +
IntDdeInfo.cbDirect,
IntDdeInfo.pIndirect,
IntDdeInfo.cbIndirect);
}
xxxClientCopyDDEIn2(pi);
} else {
retval = FAILNOFREE_POST;
}
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
if (pi != NULL)
UserFreePool(pi);
retval = FAILNOFREE_POST;
MSGERROR();
}
TRACECALLBACK("ClientCopyDDEIn1");
ENDSEND(DWORD, retval);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientCopyDDEIn1, CLIENTCOPYDDEIN1MSG)
{
INTDDEINFO IntDdeInfo;
BEGINRECV(0, &IntDdeInfo, sizeof(INTDDEINFO));
IntDdeInfo.flags = CALLDATA(flags);
retval = _ClientCopyDDEIn1(CALLDATA(hClient), &IntDdeInfo);
ENDRECV();
}
#endif // RECVSIDE
/************************************************************************
* ClientCopyDDEIn2
*
* History:
* 9-3-91 sanfords Created
\***********************************************************************/
typedef struct _CLIENTCOPYDDEIN2MSG {
INTDDEINFO IntDdeInfo;
} CLIENTCOPYDDEIN2MSG;
#ifdef SENDSIDE
BOOL xxxClientCopyDDEIn2(
PINTDDEINFO pi)
{
SETUP(CLIENTCOPYDDEIN2)
BEGINSEND(CLIENTCOPYDDEIN2)
MSGDATA()->IntDdeInfo = *pi;
MAKECALL(CLIENTCOPYDDEIN2);
CHECKRETURN();
TRACECALLBACK("ClientCopyDDEIn2");
ENDSEND(BOOL, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientCopyDDEIn2, CLIENTCOPYDDEIN2MSG)
{
BEGINRECV(0, NULL, 0);
_ClientCopyDDEIn2(PCALLDATA(IntDdeInfo));
ENDRECV();
}
#endif // RECVSIDE
/************************************************************************
* ClientCopyDDEOut2
*
* History:
* 10-22-91 sanfords Created
\***********************************************************************/
typedef struct _CLIENTCOPYDDEOUT2MSG {
INTDDEINFO IntDdeInfo;
} CLIENTCOPYDDEOUT2MSG;
#ifdef SENDSIDE
DWORD xxxClientCopyDDEOut2(
PINTDDEINFO pi)
{
SETUP(CLIENTCOPYDDEOUT2)
BEGINSEND(CLIENTCOPYDDEOUT2)
MSGDATA()->IntDdeInfo = *pi;
MAKECALL(CLIENTCOPYDDEOUT2);
/*
* This read is covered by a try/except in ClientCopyDDEOut1.
*/
pi->hDirect = MSGDATA()->IntDdeInfo.hDirect;
CHECKRETURN();
TRACECALLBACK("ClientCopyDDEOut2");
ENDSEND(DWORD, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientCopyDDEOut2, CLIENTCOPYDDEOUT2MSG)
{
BEGINRECV(0, NULL, 0);
retval = _ClientCopyDDEOut2(PCALLDATA(IntDdeInfo));
ENDRECV();
}
#endif // RECVSIDE
/************************************************************************
* ClientCopyDDEOut1
*
* History:
* 10-22-91 sanfords Created
\***********************************************************************/
typedef struct _CLIENTCOPYDDEOUT1MSG {
INTDDEINFO IntDdeInfo;
} CLIENTCOPYDDEOUT1MSG;
#ifdef SENDSIDE
HANDLE xxxClientCopyDDEOut1(
PINTDDEINFO pi)
{
INTDDEINFO IntDdeInfo;
SETUP(CLIENTCOPYDDEOUT1)
BEGINSEND(CLIENTCOPYDDEOUT1)
MSGDATA()->IntDdeInfo = *pi;
MAKECALL(CLIENTCOPYDDEOUT1);
CHECKRETURN();
if (retval) {
try {
OUTSTRUCT(&IntDdeInfo, INTDDEINFO);
if (pi->cbDirect) {
ProbeForWrite(IntDdeInfo.pDirect,
pi->cbDirect,
sizeof(BYTE));
RtlCopyMemory(IntDdeInfo.pDirect,
(PBYTE)pi + sizeof(INTDDEINFO),
pi->cbDirect);
}
if (pi->cbIndirect) {
ProbeForWrite(IntDdeInfo.pIndirect,
pi->cbIndirect,
sizeof(BYTE));
RtlCopyMemory(IntDdeInfo.pIndirect,
(PBYTE)pi + sizeof(INTDDEINFO) + pi->cbDirect,
pi->cbIndirect);
}
if (IntDdeInfo.hDirect != NULL) {
BOOL fSuccess = xxxClientCopyDDEOut2(&IntDdeInfo);
if (fSuccess && IntDdeInfo.flags & XS_EXECUTE) {
/*
* In case value was changed by Execute Fixup.
*/
retval = (ULONG_PTR)IntDdeInfo.hDirect;
}
}
*pi = IntDdeInfo;
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
retval = 0;
MSGERROR();
}
}
TRACECALLBACK("ClientCopyDDEOut1");
ENDSEND(HANDLE, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientCopyDDEOut1, CLIENTCOPYDDEOUT1MSG)
{
BEGINRECV(0, &pmsg->IntDdeInfo, sizeof(INTDDEINFO));
retval = (ULONG_PTR)_ClientCopyDDEOut1(&pmsg->IntDdeInfo);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* ClientEventCallback
*
* 11-11-91 sanfords Created
\**************************************************************************/
typedef struct _CLIENTEVENTCALLBACKMSG {
CAPTUREBUF CaptureBuf;
PVOID pcii;
PVOID pep;
} CLIENTEVENTCALLBACKMSG;
#ifdef SENDSIDE
DWORD ClientEventCallback(
IN PVOID pcii,
IN PEVENT_PACKET pep)
{
DWORD cbCapture = pep->cbEventData +
sizeof(EVENT_PACKET) - sizeof(DWORD);
SETUP(CLIENTEVENTCALLBACK)
BEGINSENDCAPTURE(CLIENTEVENTCALLBACK, 1, cbCapture, TRUE)
MSGDATA()->pcii = pcii;
COPYBYTES(pep, cbCapture);
MAKECALLCAPTURE(CLIENTEVENTCALLBACK);
CHECKRETURN();
TRACECALLBACK("ClientEventCallback");
ENDSENDCAPTURE(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientEventCallback, CLIENTEVENTCALLBACKMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
_ClientEventCallback(CALLDATA(pcii), (PEVENT_PACKET)FIXUP(pep));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* ClientGetDDEHookData
*
* 11-11-91 sanfords Created
\**************************************************************************/
typedef struct _CLIENTGETDDEHOOKDATAMSG {
UINT message;
LPARAM lParam;
DDEML_MSG_HOOK_DATA dmhd;
} CLIENTGETDDEHOOKDATAMSG;
#ifdef SENDSIDE
DWORD ClientGetDDEHookData(
IN UINT message,
IN LPARAM lParam,
OUT PDDEML_MSG_HOOK_DATA pdmhd)
{
SETUP(CLIENTGETDDEHOOKDATA)
BEGINSEND(CLIENTGETDDEHOOKDATA)
MSGDATA()->lParam = lParam;
MSGDATA()->message = message;
MAKECALL(CLIENTGETDDEHOOKDATA);
CHECKRETURN();
OUTSTRUCT(pdmhd, DDEML_MSG_HOOK_DATA);
TRACECALLBACK("ClientGetDDEHookData");
ENDSEND(DWORD,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientGetDDEHookData, CLIENTGETDDEHOOKDATAMSG)
{
BEGINRECV(0, &pmsg->dmhd, sizeof(DDEML_MSG_HOOK_DATA));
_ClientGetDDEHookData(CALLDATA(message), CALLDATA(lParam),
(PDDEML_MSG_HOOK_DATA)&pmsg->dmhd);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
*
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _CLIENTCHARTOWCHARMSG {
WORD CodePage;
WORD wch;
} CLIENTCHARTOWCHARMSG;
#ifdef SENDSIDE
WCHAR xxxClientCharToWchar(
IN WORD CodePage,
IN WORD wch)
{
SETUP(CLIENTCHARTOWCHAR)
BEGINSEND(CLIENTCHARTOWCHAR)
MSGDATA()->CodePage = CodePage;
MSGDATA()->wch = wch;
MAKECALL(CLIENTCHARTOWCHAR);
CHECKRETURN();
TRACECALLBACK("ClientCharToWchar");
ENDSEND(WCHAR, L'_');
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientCharToWchar, CLIENTCHARTOWCHARMSG)
{
char ach[2];
WCHAR wch = L'_';
BEGINRECV(0, NULL, 0);
ach[0] = LOBYTE(CALLDATA(wch));
ach[1] = HIBYTE(CALLDATA(wch));
MultiByteToWideChar(
CALLDATA(CodePage), // CP_THREAD_ACP, 437, 850 etc.
MB_PRECOMPOSED | MB_USEGLYPHCHARS, // visual map to precomposed
ach, ach[1] ? 2 : 1, // source & length
&wch, // destination
1); // max poss. precomposed length
retval = (DWORD)wch;
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
*
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _CLIENTFINDMNEMCHARMSG {
CAPTUREBUF CaptureBuf;
UNICODE_STRING strSrc;
WCHAR ch;
BOOL fFirst;
BOOL fPrefix;
} CLIENTFINDMNEMCHARMSG;
#ifdef SENDSIDE
int xxxClientFindMnemChar(
IN PUNICODE_STRING pstrSrc,
IN WCHAR ch,
IN BOOL fFirst,
IN BOOL fPrefix)
{
SETUP(CLIENTFINDMNEMCHAR)
BEGINSENDCAPTURE(CLIENTFINDMNEMCHAR, 1, pstrSrc->MaximumLength, TRUE)
MSGDATA()->ch = ch;
MSGDATA()->fFirst = fFirst;
MSGDATA()->fPrefix = fPrefix;
COPYSTRING(strSrc);
MAKECALLCAPTURE(CLIENTFINDMNEMCHAR);
CHECKRETURN();
TRACECALLBACK("ClientFindMnemChar");
ENDSENDCAPTURE(BOOL,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientFindMnemChar, CLIENTFINDMNEMCHARMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (DWORD)FindMnemChar((LPWSTR)FIXUPSTRING(strSrc),
CALLDATA(ch), CALLDATA(fFirst), CALLDATA(fPrefix));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* xxxClientPSMTextOut
*
* Called when a client-side LanguagePack (LPK) is installed
*
* 18-Sep-1996 GregoryW Created
* 11-Dec-1997 SamerA Calling LPK with user-mode accessible DC
\**************************************************************************/
typedef struct _CLIENTPSMTEXTOUTMSG {
CAPTUREBUF CaptureBuf;
UNICODE_STRING strSrc;
HDC hdc;
int xLeft;
int yTop;
int cch;
DWORD dwFlags;
} CLIENTPSMTEXTOUTMSG;
#ifdef SENDSIDE
void xxxClientPSMTextOut(
IN HDC hdc,
IN int xLeft,
IN int yTop,
IN PUNICODE_STRING pstrSrc,
IN int cch,
IN DWORD dwFlags)
{
SETUPDC(CLIENTPSMTEXTOUT)
/*
* Make sure this routine is called when a client LanguagePack (LPK)
* is installed.
*/
UserAssert(CALL_LPK(PtiCurrentShared()));
BEGINSENDCAPTUREVOIDDC(CLIENTPSMTEXTOUT, 1, pstrSrc->MaximumLength, TRUE)
CheckPublicDC ("xxxClientPSMTextOut: Public DC passed to LPK. hdcUse=%lX", hdcUse);
MSGDATA()->hdc = hdcUse;
MSGDATA()->xLeft = xLeft;
MSGDATA()->yTop = yTop;
MSGDATA()->cch = cch;
MSGDATA()->dwFlags = dwFlags;
COPYSTRING(strSrc);
MAKECALLCAPTUREDC(CLIENTPSMTEXTOUT);
CHECKRETURN();
TRACECALLBACK("ClientPSMTextOut");
ENDSENDCAPTUREVOIDDC();
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientPSMTextOut, CLIENTPSMTEXTOUTMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
PSMTextOut(CALLDATA(hdc), CALLDATA(xLeft), CALLDATA(yTop),
(LPWSTR)FIXUPSTRING(strSrc), CALLDATA(cch), CALLDATA(dwFlags));
retval = 0;
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* xxxClientLpkDrawTextEx
*
* Called when a client-side LanguagePack (LPK) is installed
*
* 18-Sep-1996 GregoryW Created
* 11-Dec-1997 SamerA Calling LPK with user-mode accessible DC
\**************************************************************************/
typedef struct _CLIENTLPKDRAWTEXTEXMSG {
CAPTUREBUF CaptureBuf;
UNICODE_STRING strSrc;
HDC hdc;
int xLeft;
int yTop;
int nCount;
BOOL fDraw;
UINT wFormat;
DRAWTEXTDATA DrawInfo;
UINT bAction;
int iCharSet;
} CLIENTLPKDRAWTEXTEXMSG;
#ifdef SENDSIDE
int xxxClientLpkDrawTextEx(
IN HDC hdc,
IN int xLeft,
IN int yTop,
IN LPCWSTR lpsz,
IN int nCount,
IN BOOL fDraw,
IN UINT wFormat,
IN LPDRAWTEXTDATA lpDrawInfo,
IN UINT bAction,
IN int iCharSet)
{
SETUPDC(CLIENTLPKDRAWTEXTEX)
UNICODE_STRING strSrc;
UNICODE_STRING *pstrSrc = &strSrc;
/*
* Make sure this routine is called when a client LanguagePack (LPK)
* is installed.
*/
UserAssert(CALL_LPK(PtiCurrentShared()));
RtlInitUnicodeString(pstrSrc, lpsz);
BEGINSENDCAPTUREDC(CLIENTLPKDRAWTEXTEX, 1, nCount, TRUE)
CheckPublicDC ("xxxClientLpkDrawTextEx: Public DC passed to LPK. hdcUse=%lX", hdcUse);
MSGDATA()->hdc = hdcUse;
MSGDATA()->xLeft = xLeft;
MSGDATA()->yTop = yTop;
MSGDATA()->nCount = nCount;
MSGDATA()->fDraw = fDraw;
MSGDATA()->wFormat = wFormat;
MSGDATA()->DrawInfo = *lpDrawInfo;
MSGDATA()->bAction = bAction;
MSGDATA()->iCharSet = iCharSet;
COPYSTRING(strSrc);
MAKECALLCAPTUREDC(CLIENTLPKDRAWTEXTEX);
CHECKRETURN();
TRACECALLBACK("ClientLpkDrawTextEx");
ENDSENDCAPTUREDC(int, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientLpkDrawTextEx, CLIENTLPKDRAWTEXTEXMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = (*fpLpkDrawTextEx)(CALLDATA(hdc), CALLDATA(xLeft), CALLDATA(yTop),
(LPWSTR)FIXUPSTRING(strSrc), CALLDATA(nCount), CALLDATA(fDraw),
CALLDATA(wFormat), PCALLDATA(DrawInfo), CALLDATA(bAction), CALLDATA(iCharSet));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* xxxClientExtTextOutW
*
* Called when a client-side LanguagePack (LPK) is installed
*
* 26-Jan-1997 GregoryW Created
* 11-Dec-1997 SamerA Calling LPK with user-mode accessible DC
\**************************************************************************/
typedef struct _CLIENTEXTTEXTOUTW {
CAPTUREBUF CaptureBuf;
UNICODE_STRING strSrc;
HDC hdc;
int x;
int y;
int flOpts;
RECT rcl;
UINT cwc;
BOOL fNullRect;
} CLIENTEXTTEXTOUTWMSG;
#ifdef SENDSIDE
BOOL xxxClientExtTextOutW(
IN HDC hdc,
IN int x,
IN int y,
IN int flOpts,
IN RECT *prcl,
IN LPCWSTR pwsz,
IN UINT cwc,
IN INT *pdx)
{
SETUPDC(CLIENTEXTTEXTOUTW)
UNICODE_STRING strSrc;
UNICODE_STRING *pstrSrc = &strSrc;
/*
* Make sure this routine is called when a client LanguagePack (LPK)
* is installed.
*/
UserAssert(CALL_LPK(PtiCurrentShared()));
RtlInitUnicodeString(pstrSrc, pwsz);
BEGINSENDCAPTUREDC(CLIENTEXTTEXTOUTW, 1, cwc, TRUE)
CheckPublicDC ("xxxClientExtTextOutW: Public DC passed to LPK. hdcUse=%lX", hdcUse);
MSGDATA()->hdc = hdcUse;
MSGDATA()->x = x;
MSGDATA()->y = y;
MSGDATA()->flOpts = flOpts;
/* In order not to pass a NULL ptr */
if( prcl ){
MSGDATA()->rcl = *prcl;
MSGDATA()->fNullRect=TRUE;
}
else {
MSGDATA()->fNullRect=FALSE;
}
MSGDATA()->cwc = cwc;
COPYSTRING(strSrc);
MAKECALLCAPTUREDC(CLIENTEXTTEXTOUTW);
CHECKRETURN();
TRACECALLBACK("ClientExtTextOutW");
ENDSENDCAPTUREDC(BOOL, 0);
UNREFERENCED_PARAMETER(pdx);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientExtTextOutW, CLIENTEXTTEXTOUTWMSG)
{
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = ExtTextOutW(CALLDATA(hdc), CALLDATA(x), CALLDATA(y),
CALLDATA(flOpts), (CALLDATA(fNullRect)) ? PCALLDATA(rcl) : NULL , (LPWSTR)FIXUPSTRING(strSrc),
CALLDATA(cwc), NULL);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* xxxClientGetTextExtentPointW
*
* Called when a client-side LanguagePack (LPK) is installed
*
* 06-Feb-1997 GregoryW Created
* 19-Jan-1998 SamerA EIP_ERROR if a public DC is passed other than hdcGray
\**************************************************************************/
typedef struct _CLIENTGETTEXTEXTENTPOINTW {
CAPTUREBUF CaptureBuf;
UNICODE_STRING strSrc;
HDC hdc;
int cch;
SIZE size;
} CLIENTGETTEXTEXTENTPOINTWMSG;
#ifdef SENDSIDE
BOOL xxxClientGetTextExtentPointW(
IN HDC hdc,
IN LPCWSTR lpstr,
IN int cch,
OUT PSIZE psize)
{
SETUPDC(CLIENTGETTEXTEXTENTPOINTW)
UNICODE_STRING strSrc;
UNICODE_STRING *pstrSrc = &strSrc;
/*
* Make sure this routine is called when a client LanguagePack (LPK)
* is installed.
*/
UserAssert(CALL_LPK(PtiCurrentShared()));
RtlInitUnicodeString(pstrSrc, lpstr);
BEGINSENDCAPTUREDC(CLIENTGETTEXTEXTENTPOINTW, 1, cch, TRUE)
CheckPublicDC ("xxxGetTextExtentPointW: Public DC passed to LPK. hdcUse=%lX", hdcUse);
MSGDATA()->hdc = hdcUse;
MSGDATA()->cch = cch;
COPYSTRING(strSrc);
MAKECALLCAPTUREDC(CLIENTGETTEXTEXTENTPOINTW);
CHECKRETURN();
OUTSTRUCT(psize, SIZE);
TRACECALLBACK("ClientGetTextExtentPointW");
ENDSENDCAPTUREDC(BOOL, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientGetTextExtentPointW, CLIENTGETTEXTEXTENTPOINTWMSG)
{
BEGINRECV(0, &pmsg->size, sizeof(SIZE));
FIXUPPOINTERS();
retval = GetTextExtentPointW(CALLDATA(hdc), (LPWSTR)FIXUPSTRING(strSrc),
CALLDATA(cch), PCALLDATA(size));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
*
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
typedef struct _CLIENTADDFONTRESOURCEWMSG {
CAPTUREBUF CaptureBuf;
UNICODE_STRING strSrc;
DWORD dwFlags;
DESIGNVECTOR dv;
} CLIENTADDFONTRESOURCEWMSG;
#ifdef SENDSIDE
int xxxClientAddFontResourceW(
IN PUNICODE_STRING pstrSrc,
IN DWORD dwFlags,
IN DESIGNVECTOR *pdv)
{
SETUP(CLIENTADDFONTRESOURCEW)
BEGINSENDCAPTURE(CLIENTADDFONTRESOURCEW, 1, pstrSrc->MaximumLength, TRUE)
COPYSTRING(strSrc);
MSGDATA()->dwFlags = dwFlags;
if (pdv && pdv->dvNumAxes) {
MSGDATA()->dv = *pdv;
} else {
MSGDATA()->dv.dvNumAxes = 0;
}
MAKECALLCAPTURE(CLIENTADDFONTRESOURCEW);
CHECKRETURN();
TRACECALLBACK("ClientAddFontResourceW");
ENDSENDCAPTURE(int,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientAddFontResourceW, CLIENTADDFONTRESOURCEWMSG)
{
DWORD AddFont(LPWSTR, DWORD, DESIGNVECTOR*);
BEGINRECV(0, NULL, 0);
FIXUPPOINTERS();
retval = GdiAddFontResourceW((LPWSTR)FIXUPSTRING(strSrc),
CALLDATA(dwFlags), CALLDATA(dv).dvNumAxes ? &CALLDATA(dv) : NULL);
ENDRECV();
}
#endif // RECVSIDE
/******************************Public*Routine******************************\
*
* FontSweep()
*
* History:
* 23-Oct-1995 -by- Bodin Dresevic [BodinD]
* Wrote it.
\**************************************************************************/
#ifdef SENDSIDE
VOID ClientFontSweep(VOID)
{
PVOID p;
ULONG cb;
LeaveCrit();
KeUserModeCallback(
FI_CLIENTFONTSWEEP,
NULL,
0,
&p,
&cb);
EnterCrit();
return;
}
#endif // SENDSIDE
#ifdef RECVSIDE
DWORD __ClientFontSweep(
PVOID p)
{
UNREFERENCED_PARAMETER(p);
vFontSweep();
return NtCallbackReturn(NULL, 0, STATUS_SUCCESS);
}
#endif // RECVSIDE
/******************************Public*Routine******************************\
*
* VOID ClientLoadLocalT1Fonts(VOID)
* very similar to above, only done for t1 fonts
*
* History:
* 25-Apr-1996 -by- Bodin Dresevic [BodinD]
* Wrote it.
\**************************************************************************/
#ifdef SENDSIDE
VOID ClientLoadLocalT1Fonts(VOID)
{
PVOID p;
ULONG cb;
LeaveCrit();
KeUserModeCallback(
FI_CLIENTLOADLOCALT1FONTS,
NULL,
0,
&p,
&cb);
EnterCrit();
return;
}
#endif // SENDSIDE
#ifdef RECVSIDE
DWORD __ClientLoadLocalT1Fonts(
PVOID p)
{
UNREFERENCED_PARAMETER(p);
vLoadLocalT1Fonts();
return NtCallbackReturn(NULL, 0, STATUS_SUCCESS);
}
#endif // RECVSIDE
/******************************Public*Routine******************************\
*
* VOID ClientLoadRemoteT1Fonts(VOID)
* very similar to above, only done for t1 fonts
*
* History:
* 25-Apr-1996 -by- Bodin Dresevic [BodinD]
* Wrote it.
\**************************************************************************/
#ifdef SENDSIDE
VOID ClientLoadRemoteT1Fonts(VOID)
{
PVOID p;
ULONG cb;
LeaveCrit();
KeUserModeCallback(
FI_CLIENTLOADREMOTET1FONTS,
NULL,
0,
&p,
&cb);
EnterCrit();
return;
}
#endif // SENDSIDE
#ifdef RECVSIDE
DWORD __ClientLoadRemoteT1Fonts(
PVOID p)
{
UNREFERENCED_PARAMETER(p);
vLoadRemoteT1Fonts();
return NtCallbackReturn(NULL, 0, STATUS_SUCCESS);
}
#endif // RECVSIDE
/**************************************************************************\
* pppUserModeCallback
*
* Same as xxxUserModeCallback except not leaving/re-entering critical section
*
* 12/9/97 LingyunW Copied from xxxUserModeCallback
\**************************************************************************/
#ifdef SENDSIDE
NTSTATUS pppUserModeCallback (ULONG uApi, PVOID pIn, ULONG cbIn, PVOID pOut, ULONG cbOut)
{
NTSTATUS Status;
PVOID pLocalOut;
ULONG cbLocalOut;
/*
* Call the client
*/
Status = KeUserModeCallback(uApi, pIn, cbIn, &pLocalOut, &cbLocalOut);
/*
* If it failed, bail
*/
if (!NT_SUCCESS(Status)) {
return Status;
}
/*
* If we didn't get the right amount of data, fail.
*/
if (cbLocalOut != cbOut) {
RIPMSG3(RIP_WARNING, "pppUserModeCallback: uAPi: %#lx cbOut: %#lx cbLocalOut: %#lx",
uApi, cbOut, cbLocalOut);
return STATUS_UNSUCCESSFUL;
}
/*
* If we were expecting some data, copy it.
*/
if (cbOut != 0) {
try {
ProbeForRead(pLocalOut, cbLocalOut, sizeof(DWORD));
RtlCopyMemory(pOut, pLocalOut, cbLocalOut);
} except (W32ExceptionHandler(FALSE, RIP_WARNING)) {
RIPMSG2(RIP_WARNING, "pppUserModeCallback: uAPi: %#lx Exception: %#lx", uApi, GetExceptionCode());
Status = STATUS_UNSUCCESSFUL;
}
}
return Status;
}
#endif // SENDSIDE
/******************************Public*Routine******************************\
* ClientPrinterThunk
*
* Callback used as the kernel-to-user transport layer.
*
* Note: User critical section is not held by the caller.
*
* History:
* 22-Jun-1997 -by- Gilman Wong [gilmanw]
* 11/13/97 -by- Lingyun Wang [lingyunw] clean up
*
* Wrote it.
\**************************************************************************/
#define CLIENTPRINTERTHUNKMSG UMTHDR
#ifdef SENDSIDE
DWORD ClientPrinterThunk(PVOID pvIn, ULONG cjIn, PVOID pvOut, ULONG cjOut)
{
NTSTATUS Status;
/*
* (Temporarly..) we return failure if we are holding USERK's crit section
*/
if (ExIsResourceAcquiredExclusiveLite(gpresUser)
|| (ExIsResourceAcquiredSharedLite(gpresUser) != 0)) {
RIPMSG0(RIP_ERROR, "ClientPrinterThunk: Holding USERK critical section!");
return 0xffffffff;
}
/*
* The pvIn buffer must have at least a CLIENTPRINTERTHUNK header.
*/
UserAssertMsg1(cjIn >= sizeof(CLIENTPRINTERTHUNKMSG), "ClientPrinterThunk: incorrect cjIn:%#lx", cjIn);
/*
* Set the private cjOut. The receive-side uses this to allocate
* a return buffer.
*/
((CLIENTPRINTERTHUNKMSG *) pvIn)->ulReserved1 = cjOut;
((CLIENTPRINTERTHUNKMSG *) pvIn)->ulReserved2 = 0;
/*
* Do the callback.
*/
Status = pppUserModeCallback(FI_CLIENTPRINTERTHUNK, pvIn, cjIn, pvOut, cjOut);
return (NT_SUCCESS(Status) ? 0 : 0xFFFFFFFF);
}
#endif // SENDSIDE
#ifdef RECVSIDE
DWORD __ClientPrinterThunk(CLIENTPRINTERTHUNKMSG *pMsg)
{
PVOID pv;
ULONG aul[526];
NTSTATUS Status;
/*
* Check that the local buffer is big enough.
*/
if (pMsg->ulReserved1 <= sizeof(aul)) {
pv = (PVOID) aul;
/*
* Call GDI to process command.
*/
if (GdiPrinterThunk((UMTHDR *) pMsg, pv, pMsg->ulReserved1) != GPT_ERROR) {
Status = STATUS_SUCCESS;
} else {
RIPMSG0(RIP_WARNING, "ClientPrinterThunk failed");
Status = STATUS_UNSUCCESSFUL;
}
} else {
RIPMSG0(RIP_WARNING, "ClientPrinterThunk: buffer too big!");
Status = STATUS_NO_MEMORY;
}
/*
* Return to kernel.
*/
if (NT_SUCCESS(Status)) {
return UserCallbackReturn(pv, pMsg->ulReserved1, Status);
} else {
return UserCallbackReturn(NULL, 0, Status);
}
}
#endif // RECVSIDE
/**************************************************************************\
*
*
* 22-Jul-1991 mikeke Created
\**************************************************************************/
#ifdef SENDSIDE
VOID ClientNoMemoryPopup(VOID)
{
PVOID p;
ULONG cb;
LeaveCrit();
KeUserModeCallback(
FI_CLIENTNOMEMORYPOPUP,
NULL,
0,
&p,
&cb);
EnterCrit();
return;
}
#endif // SENDSIDE
#ifdef RECVSIDE
DWORD __ClientNoMemoryPopup(
PVOID p)
{
WCHAR szNoMem[200];
UNREFERENCED_PARAMETER(p);
if (LoadStringW(hmodUser, STR_NOMEMBITMAP, szNoMem,
sizeof(szNoMem) / sizeof(WCHAR))) {
MessageBoxW(GetActiveWindow(), szNoMem, NULL, MB_OK);
}
return NtCallbackReturn(NULL, 0, STATUS_SUCCESS);
}
#endif // RECVSIDE
/**************************************************************************\
* ClientThreadSetup
*
* Callback to the client to perform thread initialization.
*
* 04-07-95 JimA Created.
\**************************************************************************/
#ifdef SENDSIDE
NTSTATUS xxxClientThreadSetup(VOID)
{
PVOID p;
ULONG cb;
NTSTATUS Status;
LeaveCrit();
Status = KeUserModeCallback(
FI_CLIENTTHREADSETUP,
NULL,
0,
&p,
&cb);
EnterCrit();
return Status;
}
#endif // SENDSIDE
#ifdef RECVSIDE
DWORD __ClientThreadSetup(
PVOID p)
{
BOOL fSuccess;
BOOL ClientThreadSetup(VOID);
UNREFERENCED_PARAMETER(p);
fSuccess = ClientThreadSetup();
return NtCallbackReturn(NULL, 0,
fSuccess ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL);
}
#endif // RECVSIDE
/**************************************************************************\
* ClientDeliverUserApc
*
* Callback to the client to handle a user APC. This is needed to
* ensure that a thread will exit promptly when terminated.
*
* 08-12-95 JimA Created.
\**************************************************************************/
#ifdef SENDSIDE
VOID ClientDeliverUserApc(VOID)
{
PVOID p;
ULONG cb;
LeaveCrit();
KeUserModeCallback(
FI_CLIENTDELIVERUSERAPC,
NULL,
0,
&p,
&cb);
EnterCrit();
}
#endif // SENDSIDE
#ifdef RECVSIDE
DWORD __ClientDeliverUserApc(
PVOID p)
{
UNREFERENCED_PARAMETER(p);
return NtCallbackReturn(NULL, 0, STATUS_SUCCESS);
}
#endif // RECVSIDE
/**************************************************************************\
* ClientImmLoadLayout
*
* 29-Jan-1996 wkwok Created
\**************************************************************************/
typedef struct _CLIENTIMMLOADLAYOUTMSG {
HKL hKL;
} CLIENTIMMLOADLAYOUTMSG;
#ifdef SENDSIDE
BOOL ClientImmLoadLayout(
IN HKL hKL,
OUT PIMEINFOEX piiex)
{
SETUP(CLIENTIMMLOADLAYOUT)
BEGINSEND(CLIENTIMMLOADLAYOUT)
MSGDATA()->hKL = hKL;
MAKECALL(CLIENTIMMLOADLAYOUT);
CHECKRETURN();
if (retval)
OUTSTRUCT(piiex, IMEINFOEX);
TRACECALLBACK("ClientImmLoadLayout");
ENDSEND(BOOL, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientImmLoadLayout, CLIENTIMMLOADLAYOUTMSG)
{
IMEINFOEX iiex;
BEGINRECV(0, &iiex, sizeof(iiex));
retval = fpImmLoadLayout(CALLDATA(hKL), &iiex);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* ClientImmProcessKey
*
* 03-Mar-1996 TakaoK Created
\**************************************************************************/
typedef struct _CLIENTIMMPROCESSKEYMSG {
HWND hWnd;
HKL hkl;
UINT uVKey;
LPARAM lParam;
DWORD dwHotKeyID;
} CLIENTIMMPROCESSKEYMSG;
#ifdef SENDSIDE
DWORD ClientImmProcessKey(
IN HWND hWnd,
IN HKL hkl,
IN UINT uVKey,
IN LPARAM lParam,
IN DWORD dwHotKeyID)
{
SETUP(CLIENTIMMPROCESSKEY)
UserAssert(IS_IME_ENABLED());
BEGINSEND(CLIENTIMMPROCESSKEY)
MSGDATA()->hWnd = hWnd,
MSGDATA()->hkl = hkl;
MSGDATA()->uVKey = uVKey;
MSGDATA()->lParam = lParam;
MSGDATA()->dwHotKeyID = dwHotKeyID;
MAKECALL(CLIENTIMMPROCESSKEY);
CHECKRETURN();
TRACECALLBACK("ClientImmProcessKey");
ENDSEND(DWORD, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientImmProcessKey, CLIENTIMMPROCESSKEYMSG)
{
BEGINRECV(0, NULL, 0);
retval = fpImmProcessKey(CALLDATA(hWnd),
CALLDATA(hkl),
CALLDATA(uVKey),
CALLDATA(lParam),
CALLDATA(dwHotKeyID));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnIMECONTROL
*
* 22-Apr-1996 wkwok Created
\**************************************************************************/
typedef struct _FNIMECONTROL {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
union {
PCANDIDATEFORM pCandForm;
PCOMPOSITIONFORM pCompForm;
PLOGFONTA pLogFontA;
PLOGFONTW pLogFontW;
PSOFTKBDDATA pSoftKbdData;
LPARAM lParam;
} u;
ULONG_PTR xParam;
PROC xpfnProc;
PBYTE pOutput;
DWORD cbOutput;
} FNIMECONTROLMSG;
#ifdef SENDSIDE
void CopyLogFontAtoW(
PLOGFONTW pdest,
PLOGFONTA psrc)
{
LPSTR lpstrFont = (LPSTR)(&psrc->lfFaceName);
LPWSTR lpstrFontW = (LPWSTR)(&pdest->lfFaceName);
memcpy((LPBYTE)pdest, psrc, sizeof(LOGFONTA) - LF_FACESIZE);
memset(pdest->lfFaceName, 0, LF_FACESIZE * sizeof(WCHAR));
MBToWCS(lpstrFont, -1, &lpstrFontW, LF_FACESIZE, FALSE);
}
SMESSAGECALL(IMECONTROL)
{
DWORD cCapture, cbCapture;
SETUPPWND(FNIMECONTROL)
switch (wParam) {
case IMC_GETCANDIDATEPOS:
case IMC_SETCANDIDATEPOS:
cCapture = 1;
cbCapture = sizeof(CANDIDATEFORM);
break;
case IMC_GETCOMPOSITIONWINDOW:
case IMC_SETCOMPOSITIONWINDOW:
cCapture = 1;
cbCapture = sizeof(COMPOSITIONFORM);
break;
case IMC_GETCOMPOSITIONFONT:
case IMC_SETCOMPOSITIONFONT:
case IMC_GETSOFTKBDFONT:
cCapture = 1;
cbCapture = (dwSCMSFlags & SCMS_FLAGS_ANSI)
? sizeof(LOGFONTA) : sizeof(LOGFONTW) ;
break;
case IMC_SETSOFTKBDDATA:
cCapture = 1;
cbCapture = FIELD_OFFSET(SOFTKBDDATA, wCode[0])
+ ((PSOFTKBDDATA)lParam)->uCount * sizeof(WORD) * 256;
break;
default:
cCapture = 0;
cbCapture = 0;
break;
}
BEGINSENDCAPTURE(FNIMECONTROL, cCapture, cbCapture, TRUE);
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->u.lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
switch (wParam) {
case IMC_GETCANDIDATEPOS:
case IMC_GETCOMPOSITIONWINDOW:
case IMC_GETCOMPOSITIONFONT:
case IMC_GETSOFTKBDFONT:
RESERVEBYTES(cbCapture, pOutput, cbOutput);
MAKECALLCAPTURE(FNIMECONTROL);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
try {
ProbeForRead(pcbs->pOutput, pcbs->cbOutput, sizeof(DWORD));
switch (wParam) {
case IMC_GETCANDIDATEPOS:
case IMC_GETCOMPOSITIONWINDOW:
memcpy((LPBYTE)lParam, pcbs->pOutput, cbCapture);
break;
case IMC_GETCOMPOSITIONFONT:
case IMC_GETSOFTKBDFONT:
if (dwSCMSFlags & SCMS_FLAGS_ANSI) {
CopyLogFontAtoW((PLOGFONTW)lParam, (PLOGFONTA)pcbs->pOutput);
}
else {
memcpy((LPBYTE)lParam, pcbs->pOutput, cbCapture);
}
break;
}
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
MSGERROR();
}
ENDCOPYOUT()
break;
case IMC_SETCANDIDATEPOS:
case IMC_SETCOMPOSITIONWINDOW:
case IMC_SETCOMPOSITIONFONT:
case IMC_SETSOFTKBDDATA:
if (wParam == IMC_SETCANDIDATEPOS) {
PCANDIDATEFORM pCandForm = (PCANDIDATEFORM)lParam;
LARGECOPYBYTES2(pCandForm, sizeof(CANDIDATEFORM), u.pCandForm);
}
else if (wParam == IMC_SETCOMPOSITIONWINDOW) {
PCOMPOSITIONFORM pCompForm = (PCOMPOSITIONFORM)lParam;
LARGECOPYBYTES2(pCompForm, sizeof(COMPOSITIONFORM), u.pCompForm);
}
else if (wParam == IMC_SETCOMPOSITIONFONT) {
if (dwSCMSFlags & SCMS_FLAGS_ANSI) {
LOGFONTA LogFontA;
LPSTR lpstrFontA = LogFontA.lfFaceName;
LPWSTR lpstrFontW = ((PLOGFONTW)lParam)->lfFaceName;
memcpy(&LogFontA, (PBYTE)lParam, sizeof(LOGFONTA)-LF_FACESIZE);
memset(lpstrFontA, 0, LF_FACESIZE * sizeof(CHAR));
WCSToMB(lpstrFontW, -1, &lpstrFontA, LF_FACESIZE, FALSE);
LARGECOPYBYTES2(&LogFontA, sizeof(LOGFONTA), u.pLogFontA);
}
else {
PLOGFONTW pLogFontW = (PLOGFONTW)lParam;
LARGECOPYBYTES2(pLogFontW, sizeof(LOGFONTW), u.pLogFontW);
}
}
else if (wParam == IMC_SETSOFTKBDDATA) {
PSOFTKBDDATA pSoftKbdData;
if (dwSCMSFlags & SCMS_FLAGS_ANSI) {
PWORD pCodeA;
PWSTR pCodeW;
CHAR ch[2];
PSTR pch = (PSTR)&ch;
UINT i;
pSoftKbdData = (PSOFTKBDDATA)UserAllocPool(cbCapture, TAG_IME);
if (pSoftKbdData == NULL)
MSGERROR();
pCodeA = &pSoftKbdData->wCode[0][0];
pCodeW = (PWSTR)&((PSOFTKBDDATA)lParam)->wCode[0][0];
pSoftKbdData->uCount = ((PSOFTKBDDATA)lParam)->uCount;
i = pSoftKbdData->uCount * 256;
while (i--) {
pch[1] = '\0';
WCSToMBEx(THREAD_CODEPAGE(), pCodeW, 1, &pch, 2, FALSE);
if (pch[1]) {
*pCodeA = MAKEWORD(pch[1], pch[0]);
} else {
*pCodeA = MAKEWORD(pch[0], 0);
}
pCodeA++; pCodeW++;
}
LARGECOPYBYTES2(pSoftKbdData, cbCapture, u.pSoftKbdData);
UserFreePool(pSoftKbdData);
}
else {
pSoftKbdData = (PSOFTKBDDATA)lParam;
LARGECOPYBYTES2(pSoftKbdData, cbCapture, u.pSoftKbdData);
}
}
/*
* Fall thur.
*/
default:
MAKECALLCAPTURE(FNIMECONTROL);
UNLOCKPWND();
CHECKRETURN();
break;
}
TRACECALLBACKMSG("SfnINSTRINGNULL");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnIMECONTROL, FNIMECONTROLMSG)
{
BYTE abOutput[CALLBACKSTACKLIMIT];
LPARAM lParam;
BEGINRECV(0, NULL, pmsg->cbOutput);
FIXUPPOINTERS();
if (pmsg->cbOutput <= CALLBACKSTACKLIMIT)
CallbackStatus.pOutput = abOutput;
else
CallbackStatus.pOutput = pmsg->pOutput;
switch (CALLDATA(wParam)) {
case IMC_GETCANDIDATEPOS:
case IMC_GETCOMPOSITIONWINDOW:
case IMC_GETCOMPOSITIONFONT:
case IMC_GETSOFTKBDFONT:
lParam = (LPARAM)CallbackStatus.pOutput;
break;
case IMC_SETCANDIDATEPOS:
case IMC_SETCOMPOSITIONWINDOW:
case IMC_SETCOMPOSITIONFONT:
case IMC_SETSOFTKBDDATA:
lParam = FIRSTFIXUP(u.lParam);
break;
default:
lParam = CALLDATA(u.lParam);
break;
}
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
lParam,
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnIMEREQUEST
*
* 22-Apr-1996 Created
\**************************************************************************/
#ifdef LATER
typedef struct _FNIMEREQUEST {
CAPTUREBUF CaptureBuf;
PWND pwnd;
UINT msg;
WPARAM wParam;
union {
LPCANDIDATEFORM pCandidateForm;
LPLOGFONTA pLogFontA;
LPLOGFONTW pLogFontW;
LPCOMPOSITIONFORM pCompositionForm;
LPRECONVERTSTRING pReconvertString;
LPPrivateIMECHARPOSITION pImeCharPosition;
LPARAM lParam;
} u;
ULONG_PTR xParam;
PROC xpfnProc;
PBYTE pOutput;
DWORD cbOutput;
BOOL fAnsi;
} FNIMEREQUESTMSG;
#ifdef SENDSIDE
SMESSAGECALL(IMEREQUEST)
{
DWORD cCapture, cbCapture;
SETUPPWND(FNIMEREQUEST)
//
// IMEREQUEST assumes the callback is within the thread
// (see MESSAGECALL(IMEREQUEST) in kernel/ntstubs.c.)
//
// All the data pointed by lParam should point the valid
// client side address. Thus all the validation and copy
// (if needed) will be done in the receiver side.
//
UserAssert(psms == NULL || psms->ptiSender == psms->ptiReceiver);
switch (wParam) {
case IMR_CANDIDATEWINDOW:
cCapture = 1;
cbCapture = sizeof(CANDIDATEFORM);
break;
case IMR_COMPOSITIONWINDOW:
cCapture = 1;
cbCapture = sizeof(COMPOSITIONFORM);
break;
case IMR_CONFIRMRECONVERTSTRING:
case IMR_RECONVERTSTRING:
case IMR_DOCUMENTFEED:
case IMR_QUERYCHARPOSITION:
cCapture = 0;
cbCapture = 0;
break;
case IMR_COMPOSITIONFONT: // only the exception to the rule above.
cCapture = 1;
cbCapture = (dwSCMSFlags & SCMS_FLAGS_ANSI) ? sizeof(LOGFONTA) : sizeof(LOGFONTW);
break;
default:
UserAssert(FALSE);
cCapture = 0;
cbCapture = 0;
break;
}
BEGINSENDCAPTURE(FNIMEREQUEST, cCapture, cbCapture, TRUE);
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->u.lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
MSGDATA()->fAnsi = (dwSCMSFlags & SCMS_FLAGS_ANSI);
LOCKPWND();
//
// Preparation
//
switch (wParam) {
case IMR_COMPOSITIONFONT:
RESERVEBYTES(cbCapture, pOutput, cbOutput);
break;
}
MAKECALLCAPTURE(FNIMEREQUEST);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
try {
switch (wParam) {
case IMR_COMPOSITIONFONT:
ProbeForRead(pcbs->pOutput, pcbs->cbOutput, sizeof(DWORD));
if (dwSCMSFlags & SCMS_FLAGS_ANSI) {
CopyLogFontAtoW((PLOGFONTW)lParam, (PLOGFONTA)pcbs->pOutput);
}
else {
memcpy((LPBYTE)lParam, pcbs->pOutput, cbCapture);
}
break;
}
} except (EXCEPTION_EXECUTE_HANDLER) {
MSGERROR();
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnIMEREQUEST");
ENDSENDCAPTURE(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnIMEREQUEST, FNIMEREQUESTMSG)
{
BYTE abOutput[CALLBACKSTACKLIMIT];
LPVOID pvNew = NULL;
LPARAM lParam;
BEGINRECV(0, NULL, pmsg->cbOutput);
FIXUPPOINTERS();
if (pmsg->cbOutput <= CALLBACKSTACKLIMIT)
CallbackStatus.pOutput = abOutput;
else
CallbackStatus.pOutput = pmsg->pOutput;
lParam = CALLDATA(u.lParam);
switch (CALLDATA(wParam)) {
case IMR_COMPOSITIONWINDOW:
case IMR_CANDIDATEWINDOW:
// lParam = CALLDATA(lParam);
break;
case IMR_COMPOSITIONFONT:
lParam = (LPARAM)CallbackStatus.pOutput;
break;
case IMR_QUERYCHARPOSITION:
if (CALLDATA(fAnsi)) {
LPPrivateIMECHARPOSITION lpCharPos;
pvNew = UserLocalAlloc(0, sizeof(PrivateIMECHARPOSITION));
if (pvNew == NULL) {
goto error_return;
}
lpCharPos = pvNew;
*lpCharPos = *CALLDATA(u.pImeCharPosition);
lpCharPos->dwCharPos = lpCharPos->dwCharPositionA;
}
break;
case IMR_RECONVERTSTRING:
case IMR_CONFIRMRECONVERTSTRING:
case IMR_DOCUMENTFEED:
// Real W/A conversion may be needed.
if (CALLDATA(fAnsi) && lParam) {
PRECONVERTSTRING Source = (LPRECONVERTSTRING)lParam;
// Do conversion.
DWORD dwNewSize = ImmGetReconvertTotalSize(((LPRECONVERTSTRING)lParam)->dwSize, FROM_IME, TRUE);
if (dwNewSize == 0) {
goto error_return;
}
pvNew = UserLocalAlloc(0, dwNewSize);
if (pvNew == NULL) {
goto error_return;
}
lParam = (LPARAM)pvNew;
#define lpReconv ((LPRECONVERTSTRING)lParam)
// setup the information in the allocated structure
lpReconv->dwVersion = 0;
lpReconv->dwSize = dwNewSize;
if (CALLDATA(wParam) == IMR_CONFIRMRECONVERTSTRING) {
ImmReconversionWorker(lpReconv, (LPRECONVERTSTRING)lParam, TRUE, CP_ACP);
}
}
break;
default:
lParam = CALLDATA(u.lParam);
break;
}
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
lParam,
CALLDATA(xParam));
switch (CALLDATA(wParam)) {
case IMR_RECONVERTSTRING:
case IMR_DOCUMENTFEED:
if (CALLDATA(fAnsi)) {
retval = ImmGetReconvertTotalSize((DWORD)retval, FROM_APP, TRUE);
if (lParam) {
retval = ImmReconversionWorker((LPRECONVERTSTRING)CALLDATA(u.lParam), (LPRECONVERTSTRING)pvNew, FALSE, CP_ACP);
}
}
break;
}
if (pvNew) {
UserLocalFree(pvNew);
}
error_return:
ENDRECV();
}
#undef lpReconv
#endif // RECVSIDE
#endif
/**************************************************************************\
* fnGETDBCSTEXTLENGTHS (DBCS-aware Version)
*
* Gets the Unicode & ANSI lengths
* Internally, lParam pints to the ANSI length in bytes and the return value
* is the Unicode length in bytes. However, the public definition is maintained
* on the client side, where lParam is not used and either ANSI or Unicode is
* returned.
*
* 14-Mar-1996 HideyukN Created
\**************************************************************************/
#if (WM_GETTEXTLENGTH - WM_GETTEXT) != 1
#error "WM_GETTEXT Messages no longer 1 apart. Error in code."
#endif
#if (LB_GETTEXTLEN - LB_GETTEXT) != 1
#error "LB_GETTEXT Messages no longer 1 apart. Error in code."
#endif
#if (CB_GETLBTEXTLEN - CB_GETLBTEXT) != 1
#error "CB_GETLBTEXT Messages no longer 1 apart. Error in code."
#endif
typedef struct _FNGETDBCSTEXTLENGTHSMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
ULONG_PTR xParam;
PROC xpfnProc;
} FNGETDBCSTEXTLENGTHSMSG;
#ifdef SENDSIDE
SMESSAGECALL(GETDBCSTEXTLENGTHS)
{
BOOL fAnsiSender = !!(BOOL)lParam;
BOOL fAnsiReceiver = ((dwSCMSFlags & SCMS_FLAGS_ANSI) != 0);
LPVOID pfnSavedWndProc = pwnd->lpfnWndProc;
SETUPPWND(FNGETDBCSTEXTLENGTHS)
BEGINSEND(FNGETDBCSTEXTLENGTHS)
UserAssert((fAnsiReceiver & 1) == fAnsiReceiver && (fAnsiSender & 1) == fAnsiSender);
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNGETTEXTLENGTHS);
UNLOCKPWND();
CHECKRETURN1();
/*
* ANSI client wndproc returns us cbANSI. We want cchUnicode,
* so we guess cchUnicode = cbANSI. (It may be less if
* multi-byte characters are involved, but it will never be more).
* Save cbANSI in *lParam in case the server ultimately returns
* the length to an ANSI caller.
*
* Unicode client wndproc returns us cchUnicode. If we want to know
* cbANSI, we must guess how many 'ANSI' chars we would need.
* We guess cbANSI = cchUnicode * 2. (It may be this much if all
* 'ANSI' characters are multi-byte, but it will never be more).
*
* Return cchUnicode (server code is all Unicode internally).
* Put cbANSI in *lParam to be passed along within the server in case
* we ultimately need to return it to the client.
*
* NOTE: this will sometimes cause text lengths to be misreported
* up to twice the real length, but that is expected to be harmless.
* This will only * happen if an app sends WM_GETcode TEXTLENGTH to a
* window with an ANSI client-side wndproc, or a ANSI WM_GETTEXTLENGTH
* is sent to a Unicode client-side wndproc.
*/
BEGINCOPYOUT()
//
// retval can be [CB|LB]_ERR (-1) or [CB|LB]_ERRSPACE (-2)
// then, it should be grater then zero. otherwise we can handle
// it as error, or zero length string.
//
if ((LONG)retval > 0) {
//
// Check we need to Ansi <-> Unicode conversion.
//
if (fAnsiSender != fAnsiReceiver) {
if (pwnd->lpfnWndProc != pfnSavedWndProc) {
// The window procedure is changed during the first callback.
// Let's take a guess for the worst case.
RIPMSG1(RIP_WARNING, "GETTEXTLENGTHS(pwnd=%x): The subclass status of winproc changed during 1st callback.",
pwnd);
retval *= 2;
}
else {
BOOL bNotString = FALSE; // default is string....
if (msg != WM_GETTEXTLENGTH) {
DWORD dw;
if (!RevalidateHwnd(HW(pwnd))) {
MSGERROR1();
}
//
// Get window style.
//
dw = pwnd->style;
if (msg == LB_GETTEXTLEN) {
//
// See if the control is ownerdraw and does not have the LBS_HASSTRINGS
// style.
//
bNotString = (!(dw & LBS_HASSTRINGS) &&
(dw & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE)));
} else if (msg == CB_GETLBTEXTLEN) {
//
// See if the control is ownerdraw and does not have the CBS_HASSTRINGS
// style.
//
bNotString = (!(dw & CBS_HASSTRINGS) &&
(dw & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE)));
} else {
MSGERROR1();
}
//
// if so, the length should be ULONG_PTR.
//
if (bNotString) {
retval = sizeof(ULONG_PTR);
}
}
//
// if the target data is "string", get it, and compute the length
//
if (!bNotString) {
if (PtiCurrent()->TIF_flags & TIF_INGETTEXTLENGTH) {
if (fAnsiSender) {
UserAssert(!fAnsiReceiver);
//
// retval has Unicode character count, guessed DBCS length.
//
retval *= 2;
}
} else {
//
// fAnsiReceiver == 1, retval has MBCS character count.
// fAnsiReceiver == 0, retval has Unicode character count.
//
// Add 1 to make room for zero-terminator.
//
DWORD cchText = (DWORD)retval + 1;
DWORD cbCapture = cchText;
SETUPPWND(FNOUTSTRING)
PtiCurrent()->TIF_flags |= TIF_INGETTEXTLENGTH;
//
// if reciver is Unicode, The buffder should be reserved as musg as
// (TextLength * sizeof(WCHAR).
//
if (!fAnsiReceiver) {
cbCapture *= sizeof(WCHAR);
}
BEGINSENDCAPTURE(FNOUTSTRING, 1, cbCapture, FALSE)
MSGDATA()->pwnd = pwndClient;
//
// Use (msg-1) for sending the WM_GETTEXT, LB_GETTEXT or CB_GETLBTEXT
// since the above precompiler checks passed.
//
MSGDATA()->msg = msg-1;
if (msg == WM_GETTEXTLENGTH) {
//
// WM_GETTEXT:
// wParam = cchTextMax; // number of character to copy.
// lParam = lpszText; // address of buffer for text.
//
MSGDATA()->wParam = cchText;
} else {
//
// LB_GETTEXT:
// CB_GETLBTEXT:
// wParam = index; // item index
// lParam = lpszText; // address of buffer for text.
//
MSGDATA()->wParam = wParam;
}
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
RESERVEBYTES(cbCapture, pOutput, cbOutput);
LOCKPWND();
MAKECALLCAPTURE(FNOUTSTRING);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
//
// retval can be [CB|LB]_ERR (-1) or [CB|LB]_ERRSPACE (-2)
// then, it should be grater then zero.
//
if ((LONG)retval > 0) {
/*
* Non-zero retval means some text to copy out.
*/
CALC_SIZE_STRING_OUT((LONG)retval);
}
ENDCOPYOUT()
PtiCurrent()->TIF_flags &= ~TIF_INGETTEXTLENGTH;
TRACECALLBACKMSG("SfnOUTSTRING");
ENDSENDCAPTURE(LRESULT,0);
}
}
}
}
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnGETDBCSTEXTLENGTHS");
ENDSEND1(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
/*
* The fnGETTEXTLENGTHS routine is used for this message (see... client\dispcb.tpl)
*/
#endif // RECVSIDE
/***************************************************************************\
* xxxClientMonitorEnumProc
*
* Calls the client callback given to EnumDisplayMonitors.
*
* History:
* 05-Sep-1996 adams Created.
\***************************************************************************/
typedef struct _CLIENTMONITORENUMPROCMSG {
HMONITOR hMonitor;
HDC hdcMonitor;
RECT rc;
LPARAM dwData;
MONITORENUMPROC xpfnProc;
} CLIENTMONITORENUMPROCMSG;
#ifdef SENDSIDE
BOOL xxxClientMonitorEnumProc(
HMONITOR hMonitor,
HDC hdcMonitor,
LPRECT lprc,
LPARAM dwData,
MONITORENUMPROC xpfnProc)
{
SETUP(CLIENTMONITORENUMPROC)
BEGINSEND(CLIENTMONITORENUMPROCMSG)
MSGDATA()->hMonitor = hMonitor;
MSGDATA()->hdcMonitor = hdcMonitor;
MSGDATA()->rc = *lprc;
MSGDATA()->dwData = dwData;
MSGDATA()->xpfnProc = xpfnProc;
MAKECALL(CLIENTMONITORENUMPROC);
CHECKRETURN();
TRACECALLBACK("SxxxClientMonitorEnumProc");
ENDSEND(BOOL,FALSE);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientMonitorEnumProc, CLIENTMONITORENUMPROCMSG)
{
BEGINRECV(FALSE, NULL, 0);
retval = (DWORD)CALLPROC(pmsg->xpfnProc)(
CALLDATA(hMonitor),
CALLDATA(hdcMonitor),
PCALLDATA(rc),
CALLDATA(dwData));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* xxxUserModeCallback
*
* Generic kernel callback stub
*
* 10/28/96 GerardoB Created
\**************************************************************************/
#ifdef SENDSIDE
NTSTATUS xxxUserModeCallback (ULONG uApi, PVOID pIn, ULONG cbIn, PVOID pOut, ULONG cbOut)
{
NTSTATUS Status;
PVOID pLocalOut;
ULONG cbLocalOut;
/*
* Call the client
*/
LeaveCrit();
Status = KeUserModeCallback(uApi, pIn, cbIn, &pLocalOut, &cbLocalOut);
EnterCrit();
/*
* If it failed, bail
*/
if (!NT_SUCCESS(Status)) {
return Status;
}
/*
* If we didn't get the right amount of data, fail.
*/
if (cbLocalOut != cbOut) {
RIPMSG3(RIP_WARNING, "xxxUserModeCallback: uAPi: %#lx cbOut: %#lx cbLocalOut: %#lx",
uApi, cbOut, cbLocalOut);
return STATUS_UNSUCCESSFUL;
}
/*
* If we were expecting some data, copy it.
*/
if (cbOut != 0) {
try {
ProbeForRead(pLocalOut, cbLocalOut, sizeof(DWORD));
RtlCopyMemory(pOut, pLocalOut, cbLocalOut);
} except (W32ExceptionHandler(FALSE, RIP_WARNING)) {
RIPMSG2(RIP_WARNING, "xxxUserModeCallback: uAPi: %#lx Exception: %#lx", uApi, GetExceptionCode());
Status = STATUS_UNSUCCESSFUL;
}
}
return Status;
}
#endif // SENDSIDE
/**************************************************************************\
* fnINOUTMENUGETOBJECT
*
* 11/12/96 GerardoB Created
\**************************************************************************/
typedef struct _FNINOUTMENUGETOBJECTMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
MENUGETOBJECTINFO mngoi;
ULONG_PTR xParam;
PROC xpfnProc;
} FNINOUTMENUGETOBJECTMSG;
#ifdef SENDSIDE
SMESSAGECALL(INOUTMENUGETOBJECT)
{
SETUPPWND(FNINOUTMENUGETOBJECT)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNOUTDWORDINDWORD)
PMENUGETOBJECTINFO pmngoi = (PMENUGETOBJECTINFO)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->mngoi = *pmngoi;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNINOUTMENUGETOBJECT);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
try {
UserAssert(pcbs->cbOutput == sizeof(pmngoi->pvObj));
ProbeForRead(pcbs->pOutput, sizeof(pmngoi->pvObj), sizeof(DWORD));
pmngoi->pvObj = *((PVOID *)(pcbs->pOutput));
} except (W32ExceptionHandler(TRUE, RIP_WARNING)) {
MSGERROR();
}
ENDCOPYOUT()
TRACECALLBACKMSG("SfnINOUTMENUGETOBJECT");
ENDSEND(LRESULT, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnINOUTMENUGETOBJECT, FNINOUTMENUGETOBJECTMSG)
{
BEGINRECV(0, &(pmsg->mngoi.pvObj), sizeof(pmsg->mngoi.pvObj));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
PCALLDATA(mngoi),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnLOGONNOTIFY
*
* 2/1/97 JerrySh Created
\**************************************************************************/
typedef struct _FNLOGONNOTIFYMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
LPARAM lParam;
POWERSTATEPARAMS psParams;
ULONG_PTR xParam;
PROC xpfnProc;
} FNLOGONNOTIFYMSG;
#ifdef SENDSIDE
SMESSAGECALL(LOGONNOTIFY)
{
SETUPPWND(FNLOGONNOTIFY)
UNREFERENCED_PARAMETER(dwSCMSFlags);
UNREFERENCED_PARAMETER(psms);
BEGINSEND(FNLOGONNOTIFY)
PPOWERSTATEPARAMS ppsParams = (PPOWERSTATEPARAMS)lParam;
if (wParam == LOGON_POWERSTATE ||
wParam == LOGON_REMOVE_POWER_MESSAGE ||
wParam == LOGON_SHOW_POWER_MESSAGE) {
MSGDATA()->psParams = *((PPOWERSTATEPARAMS)lParam);
}
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->lParam = lParam;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNLOGONNOTIFY);
UNLOCKPWND();
CHECKRETURN();
if (wParam == LOGON_POWERSTATE) {
BEGINCOPYOUT()
OUTSTRUCT(ppsParams, POWERSTATEPARAMS);
ENDCOPYOUT()
}
TRACECALLBACKMSG("SfnLOGONNOTIFY");
ENDSEND(LRESULT, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnLOGONNOTIFY, FNLOGONNOTIFYMSG)
{
BEGINRECV(0, &pmsg->psParams, sizeof(pmsg->psParams));
if (CALLDATA(wParam) == LOGON_POWERSTATE ||
CALLDATA(wParam) == LOGON_REMOVE_POWER_MESSAGE ||
CALLDATA(wParam) == LOGON_SHOW_POWER_MESSAGE) {
CALLDATA(lParam) = (LPARAM)&CALLDATA(psParams);
}
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
CALLDATA(pwnd),
CALLDATA(msg),
CALLDATA(wParam),
CALLDATA(lParam),
CALLDATA(xParam));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* xxxClientCallWinEventProc
*
* cf. Win'97 Call32BitEventProc() in user_40\user32\user.c
*
* 1996-10-18 IanJa Created
\**************************************************************************/
typedef struct _CLIENTCALLWINEVENTPROCMSG {
WINEVENTPROC pfn;
HWINEVENTHOOK hWinEventHook;
DWORD event;
HWND hwnd;
LONG idObject;
LONG idChild;
DWORD idEventThread;
DWORD dwmsEventTime;
} CLIENTCALLWINEVENTPROCMSG;
#ifdef SENDSIDE
BOOL xxxClientCallWinEventProc(
WINEVENTPROC pfn,
PEVENTHOOK pEventHook,
PNOTIFY pNotify)
{
SETUP(CLIENTCALLWINEVENTPROC)
BEGINSEND(CLIENTCALLWINEVENTPROC)
MSGDATA()->pfn = pfn;
MSGDATA()->hWinEventHook = (HWINEVENTHOOK)PtoH(pEventHook);
MSGDATA()->hwnd = pNotify->hwnd;
MSGDATA()->event = pNotify->event;
MSGDATA()->idObject = pNotify->idObject;
MSGDATA()->idChild = pNotify->idChild;
MSGDATA()->idEventThread = pNotify->idSenderThread;
MSGDATA()->dwmsEventTime = pNotify->dwEventTime;
MAKECALL(CLIENTCALLWINEVENTPROC);
CHECKRETURN();
TRACECALLBACK("xxxClientCallWinEventProc");
ENDSEND(BOOL, FALSE);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientCallWinEventProc, CLIENTCALLWINEVENTPROCMSG)
{
BEGINRECV(FALSE, NULL, 0);
retval = (DWORD)CALLPROC(pmsg->pfn)(
CALLDATA(hWinEventHook),
CALLDATA(event),
CALLDATA(hwnd),
CALLDATA(idObject),
CALLDATA(idChild),
CALLDATA(idEventThread),
CALLDATA(dwmsEventTime));
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* WOWGetProcModule
*
* 3/25/97 FritzS created
\**************************************************************************/
typedef struct _CLIENTWOWGETPROCMODULEMSG {
WNDPROC_PWND pfn;
} CLIENTWOWGETPROCMODULEMSG;
#ifdef SENDSIDE
WORD xxxClientWOWGetProcModule(
WNDPROC_PWND pfn)
{
SETUP(CLIENTWOWGETPROCMODULE)
BEGINSEND(CLIENTWOWGETPROCMODULE)
MSGDATA()->pfn = pfn;
MAKECALL(CLIENTWOWGETPROCMODULE);
CHECKRETURN();
TRACECALLBACK("xxxWOWGetProcModule");
ENDSEND(WORD, FALSE);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientWOWGetProcModule, CLIENTWOWGETPROCMODULEMSG)
{
ULONG ulReal;
BEGINRECV(0, NULL, 0);
if ((pfnWowGetProcModule == NULL) || !IsWOWProc(CALLDATA(pfn))) {
retval = 0;
} else {
UnMarkWOWProc(CALLDATA(pfn),ulReal);
retval = (pfnWowGetProcModule)(ulReal);
}
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* WOWTask16SchedNotify
*
* 12/20/00 ARR created
\**************************************************************************/
typedef struct _CLIENTWOWTASK16SCHEDNOTIFYMSG {
DWORD NotifyParm;
DWORD dwParam;
} CLIENTWOWTASK16SCHEDNOTIFYMSG;
#ifdef SENDSIDE
DWORD xxxClientWOWTask16SchedNotify(
DWORD NotifyParm,
DWORD dwParam)
{
SETUP(CLIENTWOWTASK16SCHEDNOTIFY)
BEGINSEND(CLIENTWOWTASK16SCHEDNOTIFY)
MSGDATA()->NotifyParm = NotifyParm;
MSGDATA()->dwParam = dwParam;
MAKECALL(CLIENTWOWTASK16SCHEDNOTIFY);
CHECKRETURN();
TRACECALLBACK("xxxWOWTask16SchedNotify");
ENDSEND(DWORD, FALSE);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(ClientWOWTask16SchedNotify, CLIENTWOWTASK16SCHEDNOTIFYMSG)
{
BEGINRECV(0, NULL, 0);
if (pfnWowTask16SchedNotify == NULL) {
retval = 1;
} else {
retval = (pfnWowTask16SchedNotify)(CALLDATA(NotifyParm),CALLDATA(dwParam));
}
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* xxxClientLoadStringW
*
* Called to load per user ToolTip strings
*
* 24-Feb-2000 Mhamid Created
\**************************************************************************/
typedef struct _CLIENTLOADSTRINGWMSG {
CAPTUREBUF CaptureBuf;
UINT StrID;
int cch;
PBYTE pOutput;
DWORD cbOutput;
} CLIENTLOADSTRINGWMSG;
#ifdef SENDSIDE
int xxxClientLoadStringW(
IN UINT StrID,
OUT LPWSTR szText,
IN int cch)
{
DWORD cbCapture;
PLARGE_STRING pstr;
BOOL fAnsiReceiver = FALSE;
LARGE_UNICODE_STRING strName;
SETUP(CLIENTLOADSTRINGW)
cbCapture = cch * sizeof(WCHAR);
RtlInitLargeUnicodeString(&strName, szText, cbCapture);
pstr = (PLARGE_STRING)&strName;
BEGINSENDCAPTURE(CLIENTLOADSTRINGW, 1, cbCapture, FALSE)
MSGDATA()->StrID = StrID;
MSGDATA()->cch = cch;
RESERVEBYTES(cbCapture, pOutput, cbOutput);
MAKECALLCAPTURE(CLIENTLOADSTRINGW);
CHECKRETURN();
COPYOUTLPWSTRLIMIT(pstr,cch);
TRACECALLBACK("ClientLoadStringW");
ENDSENDCAPTURE(int, 0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
VOID CheckMsgFontDimensions();
RECVCALL(ClientLoadStringW, CLIENTLOADSTRINGWMSG)
{
BYTE abOutput[CALLBACKSTACKLIMIT];
BEGINRECV(0, NULL, pmsg->cbOutput);
FIXUPPOINTERS();
if (pmsg->cbOutput <= CALLBACKSTACKLIMIT)
CallbackStatus.pOutput = abOutput;
else
CallbackStatus.pOutput = pmsg->pOutput;
retval = (DWORD)LoadStringOrError(
hmodUser,
CALLDATA(StrID),
(LPWSTR)KPVOID_TO_PVOID(CallbackStatus.pOutput),
CALLDATA(cch),
0);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnOUTLPCOMBOBOXINFO (for CB_GETCOMBOBOXINFO message)
*
* 05/12/00 MHamid Created
\**************************************************************************/
typedef struct _FNOUTLPCOMBOBOXINFOMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
COMBOBOXINFO cbinfo;
ULONG_PTR xParam;
PROC xpfnProc;
} FNOUTLPCOMBOBOXINFOMSG;
#ifdef SENDSIDE
SMESSAGECALL(OUTLPCOMBOBOXINFO)
{
SETUPPWND(FNOUTLPCOMBOBOXINFO)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNOUTLPCOMBOBOXINFO)
PCOMBOBOXINFO pcbinfo = (PCOMBOBOXINFO)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->cbinfo = *pcbinfo;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNOUTLPCOMBOBOXINFO);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(pcbinfo, COMBOBOXINFO);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnOUTLPCOMBOBOXINFO");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnOUTLPCOMBOBOXINFO, FNOUTLPCOMBOBOXINFOMSG)
{
BEGINRECV(0, &pmsg->cbinfo, sizeof(pmsg->cbinfo));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
PCALLDATA(cbinfo),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* fnOUTLPSCROLLBARINFO (for SBM_GETSCROLLBARINFO message)
*
* 05/12/00 MHamid Created
\**************************************************************************/
typedef struct _FNOUTLPSCROLLBARINFOMSG {
PWND pwnd;
UINT msg;
WPARAM wParam;
SCROLLBARINFO sbinfo;
ULONG_PTR xParam;
PROC xpfnProc;
} FNOUTLPSCROLLBARINFOMSG;
#ifdef SENDSIDE
SMESSAGECALL(OUTLPSCROLLBARINFO)
{
SETUPPWND(FNOUTLPSCROLLBARINFO)
UNREFERENCED_PARAMETER(dwSCMSFlags);
BEGINSEND(FNOUTLPSCROLLBARINFO)
PSCROLLBARINFO psbinfo = (PSCROLLBARINFO)lParam;
MSGDATA()->pwnd = pwndClient;
MSGDATA()->msg = msg;
MSGDATA()->wParam = wParam;
MSGDATA()->sbinfo = *psbinfo;
MSGDATA()->xParam = xParam;
MSGDATA()->xpfnProc = xpfnProc;
LOCKPWND();
MAKECALL(FNOUTLPSCROLLBARINFO);
UNLOCKPWND();
CHECKRETURN();
BEGINCOPYOUT()
OUTSTRUCT(psbinfo, SCROLLBARINFO);
ENDCOPYOUT()
TRACECALLBACKMSG("SfnOUTLPSCROLLBARINFO");
ENDSEND(LRESULT,0);
}
#endif // SENDSIDE
#ifdef RECVSIDE
RECVCALL(fnOUTLPSCROLLBARINFO, FNOUTLPSCROLLBARINFOMSG)
{
BEGINRECV(0, &pmsg->sbinfo, sizeof(pmsg->sbinfo));
retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))(
pmsg->pwnd,
pmsg->msg,
pmsg->wParam,
PCALLDATA(sbinfo),
pmsg->xParam);
ENDRECV();
}
#endif // RECVSIDE
/**************************************************************************\
* GetLUIDDosDrivesOnly
*
* Called to check the drive letters used in the LUID DosDevice
* map. Does not check if the drive letters are used in the Global
* DosDevices
*
* 08/18/00 ELi Created
\**************************************************************************/
#ifdef RECVSIDE
__inline DWORD GetLUIDDosDrivesOnly()
{
NTSTATUS Status;
PROCESS_DEVICEMAP_INFORMATION_EX ProcessDeviceMapInfoEx;
ProcessDeviceMapInfoEx.Flags = PROCESS_LUID_DOSDEVICES_ONLY;
Status = NtQueryInformationProcess( NtCurrentProcess(),
ProcessDeviceMap,
&ProcessDeviceMapInfoEx,
sizeof( ProcessDeviceMapInfoEx ),
NULL
);
if (NT_SUCCESS( Status )) {
return ProcessDeviceMapInfoEx.Query.DriveMap;
}
else {
return 0;
}
}
#endif // RECVSIDE