test: ntcb.h Source File

00001 /****************************** Module Header ******************************\ 00002 * Module Name: ntcb.h 00003 * 00004 * Copyright (c) 1985 - 1999, Microsoft Corporation 00005 * 00006 * Kernel mode sending stubs 00007 * 00008 * 07-06-91 ScottLu Created. 00009 \***************************************************************************/ 00010 00011 // If SERVER is UNICODE 00012 // Copy UNICODE -> UNICODE 00013 // or Copy ANSI -> UNICODE 00014 00015 // prototypes to client side functions only called by these stubs 00016 00017 // ddetrack.c 00018 00019 DWORD _ClientCopyDDEIn1(HANDLE hClient, PINTDDEINFO pi); 00020 VOID _ClientCopyDDEIn2(PINTDDEINFO pi); 00021 HANDLE _ClientCopyDDEOut1(PINTDDEINFO pi); 00022 BOOL xxxClientCopyDDEIn2(PINTDDEINFO pi); 00023 BOOL FixupDdeExecuteIfNecessary(HGLOBAL *phCommands, BOOL fNeedUnicode); 00024 BOOL _ClientCopyDDEOut2(PINTDDEINFO pi); 00025 BOOL _ClientFreeDDEHandle(HANDLE hDDE, DWORD flags); 00026 DWORD _ClientGetDDEFlags(HANDLE hDDE, DWORD flags); 00027 00028 00029 typedef struct _GENERICHOOKHEADER { 00030 DWORD nCode; 00031 WPARAM wParam; 00032 ULONG_PTR xParam; 00033 PROC xpfnProc; 00034 } GENERICHOOKHEADER, * LPGENERICHOOKHEADER; 00035 00036 #ifdef RECVSIDE 00037 ULONG_PTR CallHookWithSEH(GENERICHOOKHEADER *pmsg, LPVOID pData, LPDWORD pFlags, ULONG_PTR retval) { 00038 00039 try { 00040 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 00041 pmsg->nCode, 00042 pmsg->wParam, 00043 pData, 00044 pmsg->xParam); 00045 00046 } except ((*pFlags & HF_GLOBAL) ? W32ExceptionHandler(FALSE, RIP_WARNING) : EXCEPTION_CONTINUE_SEARCH) { 00047 RIPMSG0(RIP_WARNING, "Hook Faulted"); 00048 *pFlags |= HF_HOOKFAULTED; 00049 } 00050 00051 return retval; 00052 } 00053 #endif // RECVSIDE 00054 00055 #if DBG 00056 #ifdef SENDSIDE 00057 __inline void CheckPublicDC (LPSTR lpszStr, HDC hdc) 00058 { 00059 W32PID pid; 00060 pid = GreGetObjectOwner((HOBJ)hdc, DC_TYPE); 00061 if(pid == OBJECT_OWNER_PUBLIC) { 00062 RIPMSG1(RIP_ERROR, lpszStr, hdc); 00063 } 00064 } 00065 #endif // SENDSIDE 00066 #endif 00067 00068 00069 /**************************************************************************\ 00070 * fnOUTDWORDDWORD 00071 * 00072 * 14-Aug-1992 mikeke created 00073 \**************************************************************************/ 00074 00075 typedef struct _FNOUTDWORDDWORDMSG { 00076 PWND pwnd; 00077 UINT msg; 00078 ULONG_PTR xParam; 00079 PROC xpfnProc; 00080 } FNOUTDWORDDWORDMSG; 00081 00082 #ifdef SENDSIDE 00083 SMESSAGECALL(OUTDWORDDWORD) 00084 { 00085 SETUPPWND(FNOUTDWORDDWORD) 00086 00087 UNREFERENCED_PARAMETER(dwSCMSFlags); 00088 00089 BEGINSEND(FNOUTDWORDDWORD) 00090 00091 LPDWORD lpdwW = (LPDWORD)wParam; 00092 LPDWORD lpdwL = (LPDWORD)lParam; 00093 00094 MSGDATA()->pwnd = pwndClient; 00095 MSGDATA()->msg = msg; 00096 MSGDATA()->xParam = xParam; 00097 MSGDATA()->xpfnProc = xpfnProc; 00098 00099 LOCKPWND(); 00100 MAKECALL(FNOUTDWORDDWORD); 00101 UNLOCKPWND(); 00102 CHECKRETURN(); 00103 00104 BEGINCOPYOUT() 00105 try { 00106 *lpdwW = ProbeAndReadUlong((LPDWORD)pcbs->pOutput); 00107 *lpdwL = ProbeAndReadUlong((LPDWORD)pcbs->pOutput + 1); 00108 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 00109 MSGERROR(); 00110 } 00111 ENDCOPYOUT() 00112 00113 TRACECALLBACKMSG("SfnOUTDWORDDWORD"); 00114 ENDSEND(DWORD,0); 00115 } 00116 #endif // SENDSIDE 00117 00118 #ifdef RECVSIDE 00119 RECVCALL(fnOUTDWORDDWORD, FNOUTDWORDDWORDMSG) 00120 { 00121 DWORD adwOut[2]; 00122 BEGINRECV(0, adwOut, sizeof(adwOut)); 00123 00124 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 00125 CALLDATA(pwnd), 00126 CALLDATA(msg), 00127 &adwOut[0], 00128 &adwOut[1], 00129 CALLDATA(xParam)); 00130 00131 ENDRECV(); 00132 } 00133 #endif // RECVSIDE 00134 00135 /**************************************************************************\ 00136 * fnOUTDWORDINDWORD 00137 * 00138 * 04-May-1993 IanJa created (for MN_FINDMENUWINDOWFROMPOINT) 00139 \**************************************************************************/ 00140 00141 typedef struct _FNOUTDWORDINDWORDMSG { 00142 PWND pwnd; 00143 UINT msg; 00144 WPARAM wParam; 00145 LPARAM lParam; 00146 ULONG_PTR xParam; 00147 PROC xpfnProc; 00148 } FNOUTDWORDINDWORDMSG; 00149 00150 #ifdef SENDSIDE 00151 SMESSAGECALL(OUTDWORDINDWORD) 00152 { 00153 SETUPPWND(FNOUTDWORDINDWORD) 00154 00155 UNREFERENCED_PARAMETER(dwSCMSFlags); 00156 00157 BEGINSEND(FNOUTDWORDINDWORD) 00158 00159 LPDWORD lpdwW = (LPDWORD)wParam; 00160 00161 MSGDATA()->pwnd = pwndClient; 00162 MSGDATA()->msg = msg; 00163 MSGDATA()->lParam = lParam; 00164 MSGDATA()->xParam = xParam; 00165 MSGDATA()->xpfnProc = xpfnProc; 00166 00167 LOCKPWND(); 00168 MAKECALL(FNOUTDWORDINDWORD); 00169 UNLOCKPWND(); 00170 CHECKRETURN(); 00171 00172 BEGINCOPYOUT() 00173 try { 00174 *lpdwW = ProbeAndReadUlong((LPDWORD)pcbs->pOutput); 00175 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 00176 MSGERROR(); 00177 } 00178 ENDCOPYOUT() 00179 00180 TRACECALLBACKMSG("SfnOUTDWORDINDWORD"); 00181 ENDSEND(DWORD,0); 00182 } 00183 #endif // SENDSIDE 00184 00185 #ifdef RECVSIDE 00186 RECVCALL(fnOUTDWORDINDWORD, FNOUTDWORDINDWORDMSG) 00187 { 00188 DWORD dwOut; 00189 BEGINRECV(0, &dwOut, sizeof(dwOut)); 00190 00191 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 00192 CALLDATA(pwnd), 00193 CALLDATA(msg), 00194 &dwOut, 00195 CALLDATA(lParam), 00196 CALLDATA(xParam)); 00197 00198 ENDRECV(); 00199 } 00200 #endif // RECVSIDE 00201 00202 /**************************************************************************\ 00203 * fnOPTOUTLPDWORDOPTOUTLPDWORD 00204 * 00205 * 25-Nov-1992 JonPa created 00206 \**************************************************************************/ 00207 00208 typedef struct _FNOPTOUTLPDWORDOPTOUTLPDWORDMSG { 00209 PWND pwnd; 00210 UINT msg; 00211 ULONG_PTR xParam; 00212 PROC xpfnProc; 00213 } FNOPTOUTLPDWORDOPTOUTLPDWORDMSG; 00214 00215 #ifdef SENDSIDE 00216 SMESSAGECALL(OPTOUTLPDWORDOPTOUTLPDWORD) 00217 { 00218 SETUPPWND(FNOPTOUTLPDWORDOPTOUTLPDWORD) 00219 00220 UNREFERENCED_PARAMETER(dwSCMSFlags); 00221 00222 BEGINSEND(FNOPTOUTLPDWORDOPTOUTLPDWORD) 00223 00224 LPDWORD lpdwW = (LPDWORD)wParam; 00225 LPDWORD lpdwL = (LPDWORD)lParam; 00226 00227 MSGDATA()->pwnd = pwndClient; 00228 MSGDATA()->msg = msg; 00229 MSGDATA()->xParam = xParam; 00230 MSGDATA()->xpfnProc = xpfnProc; 00231 00232 LOCKPWND(); 00233 MAKECALL(FNOPTOUTLPDWORDOPTOUTLPDWORD); 00234 UNLOCKPWND(); 00235 CHECKRETURN(); 00236 00237 BEGINCOPYOUT() 00238 try { 00239 if (lpdwW != NULL) 00240 *lpdwW = ProbeAndReadUlong((LPDWORD)pcbs->pOutput); 00241 if (lpdwL != NULL) 00242 *lpdwL = ProbeAndReadUlong((LPDWORD)pcbs->pOutput + 1); 00243 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 00244 MSGERROR(); 00245 } 00246 ENDCOPYOUT() 00247 00248 TRACECALLBACKMSG("SfnOPTOUTLPDWORDOPTOUTLPDWORD"); 00249 ENDSEND(DWORD,0); 00250 } 00251 #endif // SENDSIDE 00252 00253 #ifdef RECVSIDE 00254 RECVCALL(fnOPTOUTLPDWORDOPTOUTLPDWORD, FNOPTOUTLPDWORDOPTOUTLPDWORDMSG) 00255 { 00256 DWORD adwOut[2]; 00257 BEGINRECV(0, adwOut, sizeof(adwOut)); 00258 00259 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 00260 CALLDATA(pwnd), 00261 CALLDATA(msg), 00262 &adwOut[0], 00263 &adwOut[1], 00264 CALLDATA(xParam)); 00265 00266 ENDRECV(); 00267 } 00268 #endif // RECVSIDE 00269 00270 /**************************************************************************\ 00271 * fnDWORDOPTINLPMSG 00272 * 00273 * 03-30-92 scottlu Created 00274 \**************************************************************************/ 00275 00276 typedef struct _FNDWORDOPTINLPMSGMSG { 00277 PWND pwnd; 00278 UINT msg; 00279 WPARAM wParam; 00280 LPMSG pmsgstruct; 00281 ULONG_PTR xParam; 00282 PROC xpfnProc; 00283 MSG msgstruct; 00284 } FNDWORDOPTINLPMSGMSG; 00285 00286 #ifdef SENDSIDE 00287 SMESSAGECALL(DWORDOPTINLPMSG) 00288 { 00289 SETUPPWND(FNDWORDOPTINLPMSG) 00290 00291 UNREFERENCED_PARAMETER(dwSCMSFlags); 00292 UNREFERENCED_PARAMETER(psms); 00293 00294 BEGINSEND(FNDWORDOPTINLPMSG) 00295 00296 LPMSG pmsgstruct = (LPMSG)lParam; 00297 00298 MSGDATA()->pwnd = pwndClient; 00299 MSGDATA()->msg = msg; 00300 MSGDATA()->wParam = wParam; 00301 COPYSTRUCTOPT(msgstruct); 00302 MSGDATA()->xParam = xParam; 00303 MSGDATA()->xpfnProc = xpfnProc; 00304 00305 LOCKPWND(); 00306 MAKECALL(FNDWORDOPTINLPMSG); 00307 UNLOCKPWND(); 00308 CHECKRETURN(); 00309 00310 TRACECALLBACKMSG("SfnDWORDOPTINLPMSG"); 00311 ENDSEND(DWORD,0); 00312 } 00313 #endif // SENDSIDE 00314 00315 #ifdef RECVSIDE 00316 RECVCALL(fnDWORDOPTINLPMSG, FNDWORDOPTINLPMSGMSG) 00317 { 00318 BEGINRECV(0, NULL, 0); 00319 00320 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 00321 CALLDATA(pwnd), 00322 CALLDATA(msg), 00323 CALLDATA(wParam), 00324 PCALLDATAOPT(msgstruct), 00325 CALLDATA(xParam)); 00326 00327 ENDRECV(); 00328 } 00329 #endif // RECVSIDE 00330 00331 /**************************************************************************\ 00332 * fnCOPYGLOBALDATA 00333 * 00334 * 6-20-92 Sanfords created 00335 \**************************************************************************/ 00336 00337 typedef struct _FNCOPYGLOBALDATAMSG { 00338 CAPTUREBUF CaptureBuf; 00339 DWORD cbSize; 00340 PBYTE pData; 00341 } FNCOPYGLOBALDATAMSG; 00342 00343 #ifdef SENDSIDE 00344 SMESSAGECALL(COPYGLOBALDATA) 00345 { 00346 PBYTE pData = (PBYTE)lParam; 00347 00348 SETUPPWND(FNCOPYGLOBALDATA) 00349 00350 UNREFERENCED_PARAMETER(msg); 00351 UNREFERENCED_PARAMETER(xParam); 00352 UNREFERENCED_PARAMETER(xpfnProc); 00353 UNREFERENCED_PARAMETER(dwSCMSFlags); 00354 UNREFERENCED_PARAMETER(psms); 00355 00356 BEGINSENDCAPTURE(FNCOPYGLOBALDATA, 1, wParam, TRUE) 00357 00358 if (pData == 0) { 00359 MSGERROR(); 00360 } 00361 00362 MSGDATA()->cbSize = (DWORD)wParam; 00363 LARGECOPYBYTES(pData, (DWORD)wParam); 00364 00365 LOCKPWND(); 00366 MAKECALLCAPTURE(FNCOPYGLOBALDATA); 00367 UNLOCKPWND(); 00368 CHECKRETURN(); 00369 00370 TRACECALLBACKMSG("SfnCOPYGLOBALDATA"); 00371 ENDSENDCAPTURE(DWORD,0); 00372 } 00373 #endif // SENDSIDE 00374 00375 #ifdef RECVSIDE 00376 RECVCALL(fnCOPYGLOBALDATA, FNCOPYGLOBALDATAMSG) 00377 { 00378 PBYTE p; 00379 00380 BEGINRECV(0, NULL, 0); 00381 FIXUPPOINTERS(); 00382 00383 retval = (ULONG_PTR)GlobalAlloc(GMEM_MOVEABLE, CALLDATA(cbSize)); 00384 if (p = GlobalLock((HANDLE)retval)) { 00385 00386 memcpy(p, (PVOID)CALLDATA(pData), CALLDATA(cbSize)); 00387 USERGLOBALUNLOCK((HANDLE)retval); 00388 00389 } 00390 00391 ENDRECV(); 00392 } 00393 #endif // RECVSIDE 00394 00395 /**************************************************************************\ 00396 * fnCOPYDATA 00397 * 00398 * 7-14-92 Sanfords created 00399 \**************************************************************************/ 00400 00401 typedef struct _FNCOPYDATAMSG { 00402 CAPTUREBUF CaptureBuf; 00403 PWND pwnd; 00404 UINT msg; 00405 HWND hwndFrom; 00406 BOOL fDataPresent; 00407 COPYDATASTRUCT cds; 00408 ULONG_PTR xParam; 00409 PROC xpfnProc; 00410 } FNCOPYDATAMSG; 00411 00412 #ifdef SENDSIDE 00413 SMESSAGECALL(COPYDATA) 00414 { 00415 HWND hwndFrom = (HWND)wParam; 00416 PCOPYDATASTRUCT pcds = (PCOPYDATASTRUCT)lParam; 00417 DWORD cCapture, cbCapture; 00418 00419 SETUPPWND(FNCOPYDATA) 00420 00421 UNREFERENCED_PARAMETER(dwSCMSFlags); 00422 UNREFERENCED_PARAMETER(psms); 00423 00424 if (pcds == NULL) { 00425 cCapture = cbCapture = 0; 00426 } else { 00427 cCapture = 1; 00428 cbCapture = pcds->cbData; 00429 } 00430 BEGINSENDCAPTURE(FNCOPYDATA, cCapture, cbCapture, TRUE); 00431 00432 MSGDATA()->pwnd = pwndClient; 00433 MSGDATA()->msg = msg; 00434 MSGDATA()->hwndFrom = hwndFrom; 00435 if (pcds != NULL) { 00436 MSGDATA()->fDataPresent = TRUE; 00437 MSGDATA()->cds = *pcds; 00438 LARGECOPYBYTES2(pcds->lpData, cbCapture, cds.lpData); 00439 } else { 00440 MSGDATA()->fDataPresent = FALSE; 00441 } 00442 MSGDATA()->xParam = xParam; 00443 MSGDATA()->xpfnProc = xpfnProc; 00444 00445 LOCKPWND(); 00446 MAKECALLCAPTURE(FNCOPYDATA); 00447 UNLOCKPWND(); 00448 CHECKRETURN(); 00449 00450 TRACECALLBACKMSG("SfnCOPYDATA"); 00451 ENDSENDCAPTURE(DWORD,0); 00452 } 00453 #endif // SENDSIDE 00454 00455 #ifdef RECVSIDE 00456 RECVCALL(fnCOPYDATA, FNCOPYDATAMSG) 00457 { 00458 BEGINRECV(0, NULL, 0); 00459 FIXUPPOINTERS(); 00460 00461 retval = CALLPROC(CALLDATA(xpfnProc))( 00462 CALLDATA(pwnd), 00463 CALLDATA(msg), 00464 CALLDATA(hwndFrom), 00465 CALLDATA(fDataPresent) ? PCALLDATA(cds) : NULL, 00466 CALLDATA(xParam)); 00467 00468 ENDRECV(); 00469 } 00470 #endif // RECVSIDE 00471 00472 00473 /**************************************************************************\ 00474 * fnSENTDDEMSG 00475 * 00476 * 11-5-92 Sanfords created 00477 * 00478 * This thunks DDE messages that SHOULD be posted. It will only work for 00479 * WOW apps. This thunking is strictly for WOW compatability. No 32 bit 00480 * app should be allowed to get away with this practice because it opens 00481 * the DDE protocol up to deadlocks. 00482 \**************************************************************************/ 00483 00484 typedef struct _FNSENTDDEMSGMSG { 00485 PWND pwnd; 00486 UINT msg; 00487 WPARAM wParam; 00488 LPARAM lParam; 00489 ULONG_PTR xParam; 00490 PROC xpfnProc; 00491 BOOL fIsUnicodeProc; 00492 } FNSENTDDEMSGMSG; 00493 00494 #ifdef SENDSIDE 00495 SMESSAGECALL(SENTDDEMSG) 00496 { 00497 MSG msgs; 00498 00499 SETUPPWND(FNSENTDDEMSG) 00500 00501 UNREFERENCED_PARAMETER(psms); 00502 00503 BEGINSEND(FNSENTDDEMSG) 00504 00505 msg &= ~MSGFLAG_DDE_SPECIAL_SEND; 00506 if (msg & MSGFLAG_DDE_MID_THUNK) { 00507 /* 00508 * complete the thunking here. 00509 */ 00510 msgs.hwnd = HW(pwnd); 00511 msgs.message = msg & ~MSGFLAG_DDE_MID_THUNK; 00512 msgs.wParam = wParam; 00513 msgs.lParam = lParam; 00514 xxxDDETrackGetMessageHook((PMSG)&msgs); 00515 00516 MSGDATA()->pwnd = (PWND)((PBYTE)PW(msgs.hwnd) - 00517 pci->ulClientDelta); 00518 MSGDATA()->msg = msgs.message; 00519 MSGDATA()->wParam = msgs.wParam; 00520 MSGDATA()->lParam = msgs.lParam; 00521 } else { 00522 MSGDATA()->pwnd = pwndClient; 00523 MSGDATA()->msg = msg; 00524 MSGDATA()->wParam = wParam; 00525 MSGDATA()->lParam = lParam; 00526 } 00527 MSGDATA()->xParam = xParam; 00528 MSGDATA()->xpfnProc = xpfnProc; 00529 MSGDATA()->fIsUnicodeProc = !(dwSCMSFlags & SCMS_FLAGS_ANSI); 00530 00531 LOCKPWND(); 00532 MAKECALL(FNSENTDDEMSG); 00533 UNLOCKPWND(); 00534 CHECKRETURN(); 00535 00536 TRACECALLBACKMSG("SfnSENTDDEMSG"); 00537 ENDSEND(DWORD,0); 00538 } 00539 #endif // SENDSIDE 00540 00541 #ifdef RECVSIDE 00542 RECVCALL(fnSENTDDEMSG, FNSENTDDEMSGMSG) 00543 { 00544 BEGINRECV(0, NULL, 0); 00545 00546 /* 00547 * A DDE message may have been sent via CallWindowProc due to subclassing. 00548 * Since IsWindowUnicode() cannot properly tell what proc a message will 00549 * ultimately reach, we make sure that the Ansi/Unicode form of any 00550 * WM_DDE_EXECUTE data is correct for the documented convention and 00551 * translate it as necessary. 00552 */ 00553 if (CALLDATA(msg) == WM_DDE_EXECUTE) { 00554 BOOL fHandleChanged; 00555 00556 fHandleChanged = FixupDdeExecuteIfNecessary((HGLOBAL *)PCALLDATA(lParam), 00557 CALLDATA(fIsUnicodeProc) && 00558 IsWindowUnicode((HWND)CALLDATA(wParam))); 00559 /* 00560 * BUGBUG: 00561 * If the app didn't allocate this DDE memory GMEM_MOVEABLE, 00562 * the fixup may require the handle value to change. 00563 * If this happens things will fall appart when the other side 00564 * or the tracking layer tries to free the old handle value. 00565 */ 00566 UserAssert(!fHandleChanged); 00567 } 00568 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 00569 CALLDATA(pwnd), 00570 CALLDATA(msg), 00571 CALLDATA(wParam), 00572 CALLDATA(lParam), 00573 CALLDATA(xParam)); 00574 00575 ENDRECV(); 00576 } 00577 #endif // RECVSIDE 00578 00579 /**************************************************************************\ 00580 * fnDWORD 00581 * 00582 * 22-Jul-1991 mikeke Created 00583 \**************************************************************************/ 00584 00585 typedef struct _FNDWORDMSG { 00586 PWND pwnd; 00587 UINT msg; 00588 WPARAM wParam; 00589 LPARAM lParam; 00590 ULONG_PTR xParam; 00591 PROC xpfnProc; 00592 } FNDWORDMSG; 00593 00594 #ifdef SENDSIDE 00595 SMESSAGECALL(DWORD) 00596 { 00597 SETUPPWND(FNDWORD) 00598 00599 UNREFERENCED_PARAMETER(dwSCMSFlags); 00600 UNREFERENCED_PARAMETER(psms); 00601 00602 BEGINSEND(FNDWORD) 00603 00604 MSGDATA()->pwnd = pwndClient; 00605 MSGDATA()->msg = msg; 00606 MSGDATA()->wParam = wParam; 00607 MSGDATA()->lParam = lParam; 00608 MSGDATA()->xParam = xParam; 00609 MSGDATA()->xpfnProc = xpfnProc; 00610 00611 LOCKPWND(); 00612 MAKECALL(FNDWORD); 00613 UNLOCKPWND(); 00614 CHECKRETURN(); 00615 00616 TRACECALLBACKMSG("SfnDWORD"); 00617 ENDSEND(DWORD,0); 00618 } 00619 #endif // SENDSIDE 00620 00621 #ifdef RECVSIDE 00622 RECVCALL(fnDWORD, FNDWORDMSG) 00623 { 00624 BEGINRECV(0, NULL, 0); 00625 00626 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 00627 CALLDATA(pwnd), 00628 CALLDATA(msg), 00629 CALLDATA(wParam), 00630 CALLDATA(lParam), 00631 CALLDATA(xParam)); 00632 00633 ENDRECV(); 00634 } 00635 #endif // RECVSIDE 00636 00637 /**************************************************************************\ 00638 * fnINWPARAMCHAR 00639 * 00640 * 22-Jul-1991 mikeke Created 00641 \**************************************************************************/ 00642 00643 typedef struct _FNINWPARAMCHARMSG { 00644 PWND pwnd; 00645 UINT msg; 00646 WPARAM wParam; 00647 LPARAM lParam; 00648 ULONG_PTR xParam; 00649 PROC xpfnProc; 00650 } FNINWPARAMCHARMSG; 00651 00652 #ifdef SENDSIDE 00653 SMESSAGECALL(INWPARAMCHAR) 00654 { 00655 SETUPPWND(FNINWPARAMCHAR) 00656 00657 UNREFERENCED_PARAMETER(psms); 00658 00659 BEGINSEND(FNINWPARAMCHAR) 00660 00661 MSGDATA()->pwnd = pwndClient; 00662 MSGDATA()->msg = msg; 00663 00664 /* 00665 * WM_CHARTOITEM has an index in the hi-word of wParam 00666 */ 00667 if (dwSCMSFlags & SCMS_FLAGS_ANSI) { 00668 if (msg == WM_CHARTOITEM || msg == WM_MENUCHAR) { 00669 WPARAM dwT = wParam & 0xFFFF; // mask of caret pos 00670 RtlWCSMessageWParamCharToMB(msg, &dwT); // convert key portion 00671 UserAssert(HIWORD(dwT) == 0); 00672 wParam = MAKELONG(LOWORD(dwT),HIWORD(wParam)); // rebuild pos & key wParam 00673 } else { 00674 RtlWCSMessageWParamCharToMB(msg, &wParam); 00675 } 00676 } 00677 00678 MSGDATA()->wParam = wParam; 00679 00680 MSGDATA()->lParam = lParam; 00681 MSGDATA()->xParam = xParam; 00682 MSGDATA()->xpfnProc = xpfnProc; 00683 00684 LOCKPWND(); 00685 MAKECALL(FNDWORD); 00686 UNLOCKPWND(); 00687 CHECKRETURN(); 00688 00689 TRACECALLBACKMSG("SfnINWPARAMCHAR"); 00690 ENDSEND(DWORD,0); 00691 } 00692 #endif // SENDSIDE 00693 00694 #ifdef RECVSIDE 00695 /* 00696 * The fnDWORD routine is used for this message 00697 */ 00698 #endif // RECVSIDE 00699 00700 /**************************************************************************\ 00701 * fnINWPARAMDBCSCHAR 00702 * 00703 * 12-Feb-1996 hideyukn Created 00704 \**************************************************************************/ 00705 00706 typedef struct _FNINWPARAMDBCSCHARMSG { 00707 PWND pwnd; 00708 UINT msg; 00709 WPARAM wParam; 00710 LPARAM lParam; 00711 ULONG_PTR xParam; 00712 PROC xpfnProc; 00713 BOOL bAnsi; 00714 } FNINWPARAMDBCSCHARMSG; 00715 00716 #ifdef SENDSIDE 00717 SMESSAGECALL(INWPARAMDBCSCHAR) 00718 { 00719 SETUPPWND(FNINWPARAMDBCSCHAR) 00720 00721 UNREFERENCED_PARAMETER(psms); 00722 00723 BEGINSEND(FNINWPARAMDBCSCHAR) 00724 00725 MSGDATA()->pwnd = pwndClient; 00726 MSGDATA()->msg = msg; 00727 MSGDATA()->bAnsi = dwSCMSFlags & SCMS_FLAGS_ANSI; 00728 00729 /* 00730 * wParam in WM_CHAR/EM_SETPASSWORDCHAR should be converted to ANSI 00731 * ,if target is ANSI. 00732 */ 00733 if (dwSCMSFlags & SCMS_FLAGS_ANSI) { 00734 RtlWCSMessageWParamCharToMB(msg, &wParam); 00735 } 00736 00737 MSGDATA()->wParam = wParam; 00738 MSGDATA()->lParam = lParam; 00739 MSGDATA()->xParam = xParam; 00740 MSGDATA()->xpfnProc = xpfnProc; 00741 00742 LOCKPWND(); 00743 MAKECALL(FNINWPARAMDBCSCHAR); 00744 UNLOCKPWND(); 00745 CHECKRETURN(); 00746 00747 TRACECALLBACKMSG("SfnINWPARAMDBCSCHAR"); 00748 ENDSEND(DWORD,0); 00749 } 00750 #endif // SENDSIDE 00751 00752 #ifdef RECVSIDE 00753 RECVCALL(fnINWPARAMDBCSCHAR, FNINWPARAMDBCSCHARMSG) 00754 { 00755 BOOL bAnsiWndProc; 00756 00757 BEGINRECV(0,NULL,0); 00758 00759 bAnsiWndProc = CALLDATA(bAnsi); 00760 00761 if (bAnsiWndProc) { 00762 00763 PKERNEL_MSG pmsgDbcsCB = GetCallBackDbcsInfo(); 00764 WPARAM wParam = pmsg->wParam; 00765 BOOL bDbcsMessaging = FALSE; 00766 00767 // 00768 // Check wParam has Dbcs character or not.. 00769 // 00770 if (IS_DBCS_MESSAGE(pmsg->wParam)) { 00771 00772 if (pmsg->wParam & WMCR_IR_DBCSCHAR) { 00773 00774 // 00775 // This is reply for WM_IME_REPORT:IR_DBCSCHAR, then 00776 // We send DBCS chararcter at one time... 00777 // (Do not need to send twice for DBCS LeadByte and TrailByte). 00778 // 00779 // Validation for wParam.. (mask off the secret bit). 00780 // 00781 wParam = (pmsg->wParam & 0x0000FFFF); 00782 00783 } else { 00784 00785 // 00786 // Mark the wParam keeps Dbcs character.. 00787 // 00788 bDbcsMessaging = TRUE; 00789 00790 // 00791 // Backup current message. this backupped message will be used 00792 // when Apps peek (or get) message from thier WndProc. 00793 // (see GetMessageA(), PeekMessageA()...) 00794 // 00795 // pmsgDbcsCB->hwnd = HW(pmsg->pwnd); 00796 // pmsgDbcsCB->message = pmsg->msg; 00797 // pmsgDbcsCB->wParam = pmsg->wParam; 00798 // pmsgDbcsCB->lParam = pmsg->lParam; 00799 // pmsgDbcsCB->time = pmsg->time; 00800 // pmsgDbcsCB->pt = pmsg->pt; 00801 // 00802 COPY_MSG_TO_KERNELMSG(pmsgDbcsCB,(PMSG)pmsg); 00803 00804 // 00805 // pwnd should be converted to hwnd. 00806 // 00807 pmsgDbcsCB->hwnd = HW(pmsg->pwnd); 00808 00809 // 00810 // DbcsLeadByte will be sent below soon, we just need DbcsTrailByte 00811 // for further usage.. 00812 // 00813 pmsgDbcsCB->wParam = (pmsg->wParam & 0x000000FF); 00814 00815 // 00816 // Pass the LeadingByte of the DBCS character to an ANSI WndProc. 00817 // 00818 wParam = (pmsg->wParam & 0x0000FF00) >> 8; 00819 } 00820 } 00821 00822 // 00823 // Forward Dbcs LeadingByte or Sbcs character to Apps WndProc. 00824 // 00825 retval = CALLPROC(CALLDATA(xpfnProc))( 00826 CALLDATA(pwnd), 00827 CALLDATA(msg), 00828 wParam, 00829 CALLDATA(lParam), 00830 CALLDATA(xParam) ); 00831 00832 // 00833 // Check we need to send trailing byte or not, if the wParam has Dbcs character. 00834 // 00835 if (bDbcsMessaging && pmsgDbcsCB->wParam) { 00836 00837 // 00838 // If an app didn't peek (or get) the trailing byte from within 00839 // WndProc, and then pass the DBCS TrailingByte to the ANSI WndProc here 00840 // pmsgDbcsCB->wParam has DBCS TrailingByte here.. see above.. 00841 // 00842 wParam = KERNEL_WPARAM_TO_WPARAM(pmsgDbcsCB->wParam); 00843 00844 // 00845 // Invalidate cached message. 00846 // 00847 pmsgDbcsCB->wParam = 0; 00848 00849 retval = CALLPROC(CALLDATA(xpfnProc))( 00850 CALLDATA(pwnd), 00851 CALLDATA(msg), 00852 wParam, 00853 CALLDATA(lParam), 00854 CALLDATA(xParam) ); 00855 } else { 00856 00857 // 00858 // If an app called Get/PeekMessageA from its 00859 // WndProc, do not do anything. 00860 // 00861 } 00862 00863 } else { 00864 00865 // 00866 // Only LOWORD of WPARAM is valid for WM_CHAR.... 00867 // (Mask off DBCS messaging information.) 00868 // 00869 pmsg->wParam &= 0x0000FFFF; 00870 00871 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 00872 pmsg->pwnd, 00873 pmsg->msg, 00874 pmsg->wParam, 00875 pmsg->lParam, 00876 pmsg->xParam); 00877 } 00878 00879 ENDRECV(); 00880 } 00881 #endif // RECVSIDE 00882 00883 /**************************************************************************\ 00884 * yyy 00885 * 00886 * 22-Jul-1991 mikeke Created 00887 \**************************************************************************/ 00888 00889 typedef struct _FNINOUTDRAGMSG { 00890 PWND pwnd; 00891 UINT msg; 00892 WPARAM wParam; 00893 ULONG_PTR xParam; 00894 PROC xpfnProc; 00895 DROPSTRUCT ds; 00896 } FNINOUTDRAGMSG; 00897 00898 #ifdef SENDSIDE 00899 SMESSAGECALL(INOUTDRAG) 00900 { 00901 SETUPPWND(FNINOUTDRAG) 00902 00903 UNREFERENCED_PARAMETER(dwSCMSFlags); 00904 00905 BEGINSEND(FNINOUTDRAG) 00906 00907 LPDROPSTRUCT pds = (LPDROPSTRUCT)lParam; 00908 00909 MSGDATA()->pwnd = pwndClient; 00910 MSGDATA()->msg = msg; 00911 MSGDATA()->wParam = wParam; 00912 MSGDATA()->ds = *pds; 00913 MSGDATA()->xParam = xParam; 00914 MSGDATA()->xpfnProc = xpfnProc; 00915 00916 LOCKPWND(); 00917 MAKECALL(FNINOUTDRAG); 00918 UNLOCKPWND(); 00919 CHECKRETURN(); 00920 00921 BEGINCOPYOUT() 00922 OUTSTRUCT(pds, DROPSTRUCT); 00923 ENDCOPYOUT() 00924 00925 TRACECALLBACKMSG("SfnINOUTDRAG"); 00926 ENDSEND(DWORD,0); 00927 } 00928 #endif // SENDSIDE 00929 00930 #ifdef RECVSIDE 00931 RECVCALL(fnINOUTDRAG, FNINOUTDRAGMSG) 00932 { 00933 BEGINRECV(0, &pmsg->ds, sizeof(pmsg->ds)); 00934 00935 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 00936 pmsg->pwnd, 00937 pmsg->msg, 00938 pmsg->wParam, 00939 &pmsg->ds, 00940 pmsg->xParam); 00941 00942 ENDRECV(); 00943 } 00944 #endif // RECVSIDE 00945 00946 /**************************************************************************\ 00947 * fnGETTEXTLENGTHS 00948 * 00949 * Gets the Unicode & ANSI lengths 00950 * Internally, lParam pints to the ANSI length in bytes and the return value 00951 * is the Unicode length in bytes. However, the public definition is maintained 00952 * on the client side, where lParam is not used and either ANSI or Unicode is 00953 * returned. 00954 * 00955 * 10-Feb-1992 IanJa Created 00956 \**************************************************************************/ 00957 00958 typedef struct _FNGETTEXTLENGTHSMSG { 00959 PWND pwnd; 00960 UINT msg; 00961 WPARAM wParam; 00962 ULONG_PTR xParam; 00963 PROC xpfnProc; 00964 } FNGETTEXTLENGTHSMSG; 00965 00966 #ifdef SENDSIDE 00967 SMESSAGECALL(GETTEXTLENGTHS) 00968 { 00969 SETUPPWND(FNGETTEXTLENGTHS) 00970 00971 UNREFERENCED_PARAMETER(lParam); 00972 UNREFERENCED_PARAMETER(dwSCMSFlags); 00973 UNREFERENCED_PARAMETER(psms); 00974 00975 BEGINSEND(FNGETTEXTLENGTHS) 00976 00977 MSGDATA()->pwnd = pwndClient; 00978 MSGDATA()->msg = msg; 00979 MSGDATA()->wParam = wParam; 00980 MSGDATA()->xParam = xParam; 00981 MSGDATA()->xpfnProc = xpfnProc; 00982 00983 LOCKPWND(); 00984 MAKECALL(FNGETTEXTLENGTHS); 00985 UNLOCKPWND(); 00986 CHECKRETURN(); 00987 00988 /* 00989 * ANSI client wndproc returns us cbANSI. We want cchUnicode, 00990 * so we guess cchUnicode = cbANSI. (It may be less if 00991 * multi-byte characters are involved, but it will never be more). 00992 * Save cbANSI in *lParam in case the server ultimately returns 00993 * the length to an ANSI caller. 00994 * 00995 * Unicode client wndproc returns us cchUnicode. If we want to know 00996 * cbANSI, we must guess how many 'ANSI' chars we would need. 00997 * We guess cbANSI = cchUnicode * 2. (It may be this much if all 00998 * 'ANSI' characters are multi-byte, but it will never be more). 00999 * 01000 * Return cchUnicode (server code is all Unicode internally). 01001 * Put cbANSI in *lParam to be passed along within the server in case 01002 * we ultimately need to return it to the client. 01003 * 01004 * NOTE: this will sometimes cause text lengths to be misreported 01005 * up to twice the real length, but that is expected to be harmless. 01006 * This will only * happen if an app sends WM_GETcode TEXTLENGTH to a 01007 * window with an ANSI client-side wndproc, or a ANSI WM_GETTEXTLENGTH 01008 * is sent to a Unicode client-side wndproc. 01009 */ 01010 01011 TRACECALLBACKMSG("SfnGETTEXTLENGTHS"); 01012 ENDSEND(DWORD,0); 01013 } 01014 #endif // SENDSIDE 01015 01016 #ifdef RECVSIDE 01017 RECVCALL(fnGETTEXTLENGTHS, FNGETTEXTLENGTHSMSG) 01018 { 01019 BEGINRECV(0, NULL, 0); 01020 01021 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01022 pmsg->pwnd, 01023 pmsg->msg, 01024 pmsg->wParam, 01025 0, // so we don't pass &cbAnsi to apps 01026 pmsg->xParam); 01027 01028 ENDRECV(); 01029 } 01030 #endif // RECVSIDE 01031 01032 /**************************************************************************\ 01033 * yyy 01034 * 01035 * 22-Jul-1991 mikeke Created 01036 \**************************************************************************/ 01037 01038 typedef struct _FNINLPCREATESTRUCTMSG { 01039 CAPTUREBUF CaptureBuf; 01040 PWND pwnd; 01041 UINT msg; 01042 WPARAM wParam; 01043 LPARAM lParam; 01044 CREATESTRUCT cs; 01045 ULONG_PTR xParam; 01046 PROC xpfnProc; 01047 } FNINLPCREATESTRUCTMSG; 01048 01049 #ifdef SENDSIDE 01050 SMESSAGECALL(INLPCREATESTRUCT) 01051 { 01052 PCREATESTRUCTEX pcreatestruct = (PCREATESTRUCTEX)lParam; 01053 DWORD cbName = 0, cbClass = 0; 01054 DWORD cCapture = 0; 01055 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 01056 01057 SETUPPWND(FNINLPCREATESTRUCT) 01058 01059 UNREFERENCED_PARAMETER(psms); 01060 01061 /* 01062 * Compute ANSI capture lengths. Don't capture if 01063 * the strings are in the client's address space. 01064 */ 01065 if (pcreatestruct) { 01066 if (pcreatestruct->cs.lpszName && 01067 ((BOOL)pcreatestruct->strName.bAnsi != fAnsiReceiver || 01068 IS_SYSTEM_ADDRESS((PVOID)pcreatestruct->cs.lpszName))) { 01069 CALC_SIZE_IN(cbName, &pcreatestruct->strName); 01070 cCapture++; 01071 } 01072 if (IS_PTR(pcreatestruct->cs.lpszClass) && 01073 ((BOOL)pcreatestruct->strClass.bAnsi != fAnsiReceiver || 01074 IS_SYSTEM_ADDRESS((PVOID)pcreatestruct->cs.lpszClass))) { 01075 CALC_SIZE_IN(cbClass, &pcreatestruct->strClass); 01076 cCapture++; 01077 } 01078 } 01079 01080 BEGINSENDCAPTURE(FNINLPCREATESTRUCT, cCapture, cbName + cbClass, TRUE) 01081 01082 MSGDATA()->pwnd = pwndClient; 01083 MSGDATA()->msg = msg; 01084 MSGDATA()->wParam = wParam; 01085 MSGDATA()->lParam = lParam; // this could be NULL in WOW apps! 01086 01087 if (pcreatestruct != NULL) { 01088 MSGDATA()->cs = pcreatestruct->cs; 01089 01090 // Make it a "Large" copy because it could be an Edit control 01091 if (cbName) { 01092 if (!pcreatestruct->strName.bAnsi) { 01093 if (*(PWORD)pcreatestruct->cs.lpszName == 0xffff) { 01094 01095 /* 01096 * Copy out an ordinal of the form 0xffff, ID. 01097 * If the receiver is ANSI, skip the first 0xff. 01098 */ 01099 if (fAnsiReceiver) { 01100 if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf, 01101 (PBYTE)pcreatestruct->cs.lpszName + 1, 01102 3, (PVOID *)&mp->cs.lpszName))) 01103 goto errorexit; 01104 } else { 01105 if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf, 01106 (PBYTE)pcreatestruct->cs.lpszName, 01107 4, (PVOID *)&mp->cs.lpszName))) 01108 goto errorexit; 01109 } 01110 } else if (fAnsiReceiver) { 01111 LARGECOPYSTRINGLPWSTRA(&pcreatestruct->strName, cs.lpszName); 01112 } else { 01113 LARGECOPYSTRINGLPWSTR(&pcreatestruct->strName, cs.lpszName); 01114 } 01115 } else { 01116 if (*(PBYTE)pcreatestruct->cs.lpszName == 0xff) { 01117 01118 /* 01119 * Copy out an ordinal of the form 0xff, ID. 01120 * If the receiver is UNICODE, expand the 0xff to 0xffff. 01121 */ 01122 if (fAnsiReceiver) { 01123 if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf, 01124 (PBYTE)pcreatestruct->cs.lpszName, 01125 3, (PVOID *)&mp->cs.lpszName))) 01126 goto errorexit; 01127 } else { 01128 DWORD dwOrdinal; 01129 01130 dwOrdinal = MAKELONG(0xffff, 01131 (*(DWORD UNALIGNED *)pcreatestruct->cs.lpszName >> 8)); 01132 if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf, 01133 &dwOrdinal, 01134 4, (PVOID *)&mp->cs.lpszName))) 01135 goto errorexit; 01136 } 01137 } else if (fAnsiReceiver) { 01138 LARGECOPYSTRINGLPSTR(&pcreatestruct->strName, cs.lpszName); 01139 } else { 01140 LARGECOPYSTRINGLPSTRW(&pcreatestruct->strName, cs.lpszName); 01141 } 01142 } 01143 } 01144 if (cbClass) { 01145 if (!pcreatestruct->strClass.bAnsi) { 01146 if (fAnsiReceiver) { 01147 LARGECOPYSTRINGLPWSTRA(&pcreatestruct->strClass, cs.lpszClass); 01148 } else { 01149 LARGECOPYSTRINGLPWSTR(&pcreatestruct->strClass, cs.lpszClass); 01150 } 01151 } else { 01152 if (fAnsiReceiver) { 01153 LARGECOPYSTRINGLPSTR(&pcreatestruct->strClass, cs.lpszClass); 01154 } else { 01155 LARGECOPYSTRINGLPSTRW(&pcreatestruct->strClass, cs.lpszClass); 01156 } 01157 } 01158 } 01159 } 01160 01161 MSGDATA()->xParam = xParam; 01162 MSGDATA()->xpfnProc = xpfnProc; 01163 01164 LOCKPWND(); 01165 MAKECALLCAPTURE(FNINLPCREATESTRUCT); 01166 UNLOCKPWND(); 01167 CHECKRETURN(); 01168 01169 TRACECALLBACKMSG("SfnINLPCREATESTRUCT"); 01170 ENDSENDCAPTURE(DWORD,0); 01171 } 01172 #endif // SENDSIDE 01173 01174 #ifdef RECVSIDE 01175 RECVCALL(fnINLPCREATESTRUCT, FNINLPCREATESTRUCTMSG) 01176 { 01177 LPARAM lParam; 01178 01179 BEGINRECV(0, NULL, 0); 01180 FIXUPPOINTERS(); 01181 01182 if (pmsg->lParam != 0) { 01183 if ((ULONG_PTR)pmsg->cs.lpszName > gHighestUserAddress) 01184 pmsg->cs.lpszName = REBASEPTR(pmsg->pwnd, pmsg->cs.lpszName); 01185 if ((ULONG_PTR)pmsg->cs.lpszClass > gHighestUserAddress) 01186 pmsg->cs.lpszClass = REBASEPTR(pmsg->pwnd, pmsg->cs.lpszClass); 01187 lParam = (LPARAM)&pmsg->cs; 01188 01189 if ((pmsg->cs.lpCreateParams != NULL) && 01190 (TestWF(pmsg->pwnd, WEFMDICHILD))) { 01191 // Note -- do not test the flag in cs.dwExStyle -- it gets zapped for Old UI apps, like Quicken 01192 ((LPMDICREATESTRUCT)(pmsg->cs.lpCreateParams))->szClass = pmsg->cs.lpszClass; 01193 ((LPMDICREATESTRUCT)(pmsg->cs.lpCreateParams))->szTitle = pmsg->cs.lpszName; 01194 } 01195 } else 01196 lParam = 0; 01197 01198 01199 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01200 pmsg->pwnd, 01201 pmsg->msg, 01202 pmsg->wParam, 01203 lParam, 01204 pmsg->xParam); 01205 01206 ENDRECV(); 01207 } 01208 #endif // RECVSIDE 01209 01210 /**************************************************************************\ 01211 * fnINLPMDICREATESTRUCT 01212 * 01213 * 22-Jul-1991 mikeke Created 01214 \**************************************************************************/ 01215 01216 typedef struct _FNINLPMDICREATESTRUCTMSG { 01217 CAPTUREBUF CaptureBuf; 01218 PWND pwnd; 01219 UINT msg; 01220 WPARAM wParam; 01221 MDICREATESTRUCT mdics; 01222 ULONG_PTR xParam; 01223 PROC xpfnProc; 01224 int szClass; 01225 int szTitle; 01226 } FNINLPMDICREATESTRUCTMSG; 01227 01228 #ifdef SENDSIDE 01229 SMESSAGECALL(INLPMDICREATESTRUCT) 01230 { 01231 PMDICREATESTRUCTEX pmdicreatestruct = (PMDICREATESTRUCTEX)lParam; 01232 DWORD cbTitle = 0, cbClass = 0; 01233 DWORD cCapture = 0; 01234 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 01235 01236 SETUPPWND(FNINLPMDICREATESTRUCT) 01237 01238 UNREFERENCED_PARAMETER(psms); 01239 01240 /* 01241 * Compute ANSI capture lengths. Don't capture if 01242 * the strings are in the client's address space and 01243 * are Unicode. 01244 */ 01245 if (pmdicreatestruct->mdics.szTitle && 01246 (IS_SYSTEM_ADDRESS((PVOID)pmdicreatestruct->mdics.szTitle) || 01247 ((BOOL)pmdicreatestruct->strTitle.bAnsi != fAnsiReceiver))) { 01248 CALC_SIZE_IN(cbTitle, &pmdicreatestruct->strTitle); 01249 cCapture = 1; 01250 } 01251 if (IS_PTR(pmdicreatestruct->mdics.szClass) && 01252 (IS_SYSTEM_ADDRESS((PVOID)pmdicreatestruct->mdics.szClass) || 01253 ((BOOL)pmdicreatestruct->strClass.bAnsi != fAnsiReceiver))) { 01254 CALC_SIZE_IN(cbClass, &pmdicreatestruct->strClass); 01255 cCapture++; 01256 } 01257 01258 BEGINSENDCAPTURE(FNINLPMDICREATESTRUCT, cCapture, cbTitle + cbClass, TRUE) 01259 01260 MSGDATA()->pwnd = pwndClient; 01261 MSGDATA()->msg = msg; 01262 MSGDATA()->wParam = wParam; 01263 MSGDATA()->mdics = pmdicreatestruct->mdics; 01264 01265 if (cbTitle) { 01266 if (!pmdicreatestruct->strTitle.bAnsi) { 01267 if (fAnsiReceiver) { 01268 LARGECOPYSTRINGLPWSTRA(&pmdicreatestruct->strTitle, mdics.szTitle); 01269 } else { 01270 LARGECOPYSTRINGLPWSTR(&pmdicreatestruct->strTitle, mdics.szTitle); 01271 } 01272 } else { 01273 if (fAnsiReceiver) { 01274 LARGECOPYSTRINGLPSTR(&pmdicreatestruct->strTitle, mdics.szTitle); 01275 } else { 01276 LARGECOPYSTRINGLPSTRW(&pmdicreatestruct->strTitle, mdics.szTitle); 01277 } 01278 } 01279 } 01280 if (cbClass) { 01281 if (!pmdicreatestruct->strClass.bAnsi) { 01282 if (fAnsiReceiver) { 01283 LARGECOPYSTRINGLPWSTRA(&pmdicreatestruct->strClass, mdics.szClass); 01284 } else { 01285 LARGECOPYSTRINGLPWSTR(&pmdicreatestruct->strClass, mdics.szClass); 01286 } 01287 } else { 01288 if (fAnsiReceiver) { 01289 LARGECOPYSTRINGLPSTR(&pmdicreatestruct->strClass, mdics.szClass); 01290 } else { 01291 LARGECOPYSTRINGLPSTRW(&pmdicreatestruct->strClass, mdics.szClass); 01292 } 01293 } 01294 } 01295 MSGDATA()->xParam = xParam; 01296 MSGDATA()->xpfnProc = xpfnProc; 01297 01298 LOCKPWND(); 01299 MAKECALLCAPTURE(FNINLPMDICREATESTRUCT); 01300 UNLOCKPWND(); 01301 CHECKRETURN(); 01302 01303 TRACECALLBACKMSG("SfnINLPMDICREATESTRUCT"); 01304 ENDSENDCAPTURE(DWORD,0); 01305 DBG_UNREFERENCED_PARAMETER(wParam); 01306 } 01307 #endif // SENDSIDE 01308 01309 #ifdef RECVSIDE 01310 RECVCALL(fnINLPMDICREATESTRUCT, FNINLPMDICREATESTRUCTMSG) 01311 { 01312 BEGINRECV(0, NULL, 0); 01313 FIXUPPOINTERS(); 01314 01315 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01316 pmsg->pwnd, 01317 pmsg->msg, 01318 pmsg->wParam, 01319 &pmsg->mdics, 01320 pmsg->xParam); 01321 01322 ENDRECV(); 01323 } 01324 #endif // RECVSIDE 01325 01326 /**************************************************************************\ 01327 * fnINPAINTCLIPBRD 01328 * 01329 * lParam is a supposed to be a Global Handle to DDESHARE memory. 01330 * 01331 * 22-Jul-1991 johnc Created 01332 \**************************************************************************/ 01333 01334 typedef struct _FNINPAINTCLIPBRDMSG { 01335 PWND pwnd; 01336 UINT msg; 01337 WPARAM wParam; 01338 PAINTSTRUCT ps; 01339 ULONG_PTR xParam; 01340 PROC xpfnProc; 01341 } FNINPAINTCLIPBRDMSG; 01342 01343 #ifdef SENDSIDE 01344 SMESSAGECALL(INPAINTCLIPBRD) 01345 { 01346 PWND pwndDCOwner; 01347 01348 /* 01349 * We need to check clipboard access rights because the app could 01350 * get the clipboard owner's window handle by enumeration etc and 01351 * send this message 01352 */ 01353 01354 SETUPPWND(FNINPAINTCLIPBRD) 01355 01356 UNREFERENCED_PARAMETER(dwSCMSFlags); 01357 UNREFERENCED_PARAMETER(psms); 01358 01359 BEGINSEND(FNINPAINTCLIPBRD) 01360 01361 LPPAINTSTRUCT pps = (LPPAINTSTRUCT)lParam; 01362 01363 if (RtlAreAllAccessesGranted(PpiCurrent()->amwinsta, 01364 WINSTA_ACCESSCLIPBOARD)) { 01365 01366 MSGDATA()->pwnd = pwndClient; 01367 MSGDATA()->msg = msg; 01368 MSGDATA()->wParam = wParam; 01369 MSGDATA()->ps = *pps; 01370 MSGDATA()->xParam = xParam; 01371 MSGDATA()->xpfnProc = xpfnProc; 01372 01373 /* 01374 * We can't just set the owner of the DC and pass the original DC 01375 * because currently GDI won't let you query the current owner 01376 * and we don't know if it is a public or privately owned DC 01377 */ 01378 pwndDCOwner = _WindowFromDC(pps->hdc); 01379 MSGDATA()->ps.hdc = _GetDC(pwndDCOwner); 01380 01381 LOCKPWND(); 01382 MAKECALL(FNINPAINTCLIPBRD); 01383 UNLOCKPWND(); 01384 CHECKRETURN(); 01385 01386 _ReleaseDC(MSGDATA()->ps.hdc); 01387 } 01388 01389 TRACECALLBACKMSG("SfnINPAINTCLIPBRD"); 01390 ENDSEND(DWORD,0); 01391 } 01392 #endif // SENDSIDE 01393 01394 #ifdef RECVSIDE 01395 RECVCALL(fnINPAINTCLIPBRD, FNINPAINTCLIPBRDMSG) 01396 { 01397 LPPAINTSTRUCT lpps; 01398 01399 BEGINRECV(0, NULL, 0); 01400 01401 lpps = (LPPAINTSTRUCT)GlobalAlloc(GMEM_FIXED | GMEM_DDESHARE, sizeof(PAINTSTRUCT)); 01402 UserAssert(lpps); 01403 01404 if (lpps) { 01405 *lpps = pmsg->ps; 01406 01407 UserAssert(lpps->hdc); 01408 01409 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01410 pmsg->pwnd, 01411 pmsg->msg, 01412 pmsg->wParam, 01413 lpps, 01414 pmsg->xParam); 01415 01416 GlobalFree((HGLOBAL)lpps); 01417 } 01418 01419 ENDRECV(); 01420 } 01421 #endif // RECVSIDE 01422 01423 /**************************************************************************\ 01424 * fnINSIZECLIPBRD 01425 * 01426 * lParam is a supposed to be a Global Handle to DDESHARE memory. 01427 * 01428 * 11-Jun-1992 sanfords Created 01429 \**************************************************************************/ 01430 01431 typedef struct _FNINSIZECLIPBRDMSG { 01432 PWND pwnd; 01433 UINT msg; 01434 WPARAM wParam; 01435 RECT rc; 01436 ULONG_PTR xParam; 01437 PROC xpfnProc; 01438 } FNINSIZECLIPBRDMSG; 01439 01440 #ifdef SENDSIDE 01441 SMESSAGECALL(INSIZECLIPBRD) 01442 { 01443 /* 01444 * We need to check clipboard access rights because the app could 01445 * get the clipboard owner's window handle by enumeration etc and 01446 * send this message 01447 */ 01448 01449 SETUPPWND(FNINSIZECLIPBRD) 01450 01451 UNREFERENCED_PARAMETER(dwSCMSFlags); 01452 UNREFERENCED_PARAMETER(psms); 01453 01454 BEGINSEND(FNINSIZECLIPBRD) 01455 01456 LPRECT prc = (LPRECT)lParam; 01457 01458 if (RtlAreAllAccessesGranted(PpiCurrent()->amwinsta, 01459 WINSTA_ACCESSCLIPBOARD)) { 01460 01461 MSGDATA()->pwnd = pwndClient; 01462 MSGDATA()->msg = msg; 01463 MSGDATA()->wParam = wParam; 01464 MSGDATA()->rc = *prc; 01465 MSGDATA()->xParam = xParam; 01466 MSGDATA()->xpfnProc = xpfnProc; 01467 01468 LOCKPWND(); 01469 MAKECALL(FNINSIZECLIPBRD); 01470 UNLOCKPWND(); 01471 CHECKRETURN(); 01472 } 01473 01474 TRACECALLBACKMSG("SfnINSIZECLIPBRD"); 01475 ENDSEND(DWORD,0); 01476 } 01477 #endif // SENDSIDE 01478 01479 #ifdef RECVSIDE 01480 RECVCALL(fnINSIZECLIPBRD, FNINSIZECLIPBRDMSG) 01481 { 01482 LPRECT lprc; 01483 01484 BEGINRECV(0, NULL, 0); 01485 01486 lprc = (LPRECT)GlobalAlloc(GMEM_FIXED | GMEM_DDESHARE, sizeof(RECT)); 01487 UserAssert(lprc); 01488 01489 if (lprc) { 01490 *lprc = pmsg->rc; 01491 01492 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01493 pmsg->pwnd, 01494 pmsg->msg, 01495 pmsg->wParam, 01496 lprc, 01497 pmsg->xParam); 01498 01499 GlobalFree((HGLOBAL)lprc); 01500 } 01501 01502 ENDRECV(); 01503 } 01504 #endif // RECVSIDE 01505 01506 01507 /**************************************************************************\ 01508 * fnINDESTROYCLIPBRD 01509 * 01510 * Special handler so we can call ClientEmptyClipboard on client 01511 * 01512 * 01-16-93 scottlu Created 01513 \**************************************************************************/ 01514 01515 typedef struct _FNINDESTROYCLIPBRDMSG { 01516 PWND pwnd; 01517 UINT msg; 01518 WPARAM wParam; 01519 LPARAM lParam; 01520 ULONG_PTR xParam; 01521 PROC xpfnProc; 01522 } FNINDESTROYCLIPBRDMSG; 01523 01524 #ifdef SENDSIDE 01525 SMESSAGECALL(INDESTROYCLIPBRD) 01526 { 01527 SETUPPWND(FNINDESTROYCLIPBRD) 01528 01529 UNREFERENCED_PARAMETER(dwSCMSFlags); 01530 UNREFERENCED_PARAMETER(psms); 01531 01532 BEGINSEND(FNINDESTROYCLIPBRD) 01533 01534 MSGDATA()->pwnd = pwndClient; 01535 MSGDATA()->msg = msg; 01536 MSGDATA()->wParam = wParam; 01537 MSGDATA()->lParam = lParam; 01538 MSGDATA()->xParam = xParam; 01539 MSGDATA()->xpfnProc = xpfnProc; 01540 01541 LOCKPWND(); 01542 MAKECALL(FNINDESTROYCLIPBRD); 01543 UNLOCKPWND(); 01544 CHECKRETURN(); 01545 01546 TRACECALLBACKMSG("SfnINDESTROYCLIPBRD"); 01547 ENDSEND(DWORD,0); 01548 } 01549 #endif // SENDSIDE 01550 01551 #ifdef RECVSIDE 01552 RECVCALL(fnINDESTROYCLIPBRD, FNINDESTROYCLIPBRDMSG) 01553 { 01554 void ClientEmptyClipboard(void); 01555 01556 BEGINRECV(0, NULL, 0); 01557 01558 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01559 pmsg->pwnd, 01560 pmsg->msg, 01561 pmsg->wParam, 01562 pmsg->lParam, 01563 pmsg->xParam); 01564 01565 /* 01566 * Now empty the client side clipboard cache. 01567 * Don't do this if this is a 16bit app. We don't want to clear out the 01568 * clipboard just because one app is going away. All of the 16bit apps 01569 * share one clipboard. 01570 */ 01571 if ((GetClientInfo()->CI_flags & CI_16BIT) == 0) { 01572 ClientEmptyClipboard(); 01573 } 01574 01575 ENDRECV(); 01576 } 01577 #endif // RECVSIDE 01578 01579 /**************************************************************************\ 01580 * yyy 01581 * 01582 * 22-Jul-1991 mikeke Created 01583 \**************************************************************************/ 01584 01585 typedef struct _FNINOUTLPSCROLLINFOMSG { 01586 PWND pwnd; 01587 UINT msg; 01588 WPARAM wParam; 01589 SCROLLINFO info; 01590 ULONG_PTR xParam; 01591 PROC xpfnProc; 01592 } FNINOUTLPSCROLLINFOMSG; 01593 01594 #ifdef SENDSIDE 01595 SMESSAGECALL(INOUTLPSCROLLINFO) 01596 { 01597 SETUPPWND(FNINOUTLPSCROLLINFO) 01598 01599 UNREFERENCED_PARAMETER(dwSCMSFlags); 01600 01601 BEGINSEND(FNINOUTLPSCROLLINFO) 01602 01603 LPSCROLLINFO pinfo = (LPSCROLLINFO)lParam; 01604 01605 MSGDATA()->pwnd = pwndClient; 01606 MSGDATA()->msg = msg; 01607 MSGDATA()->wParam = wParam; 01608 MSGDATA()->info = *pinfo; 01609 MSGDATA()->xParam = xParam; 01610 MSGDATA()->xpfnProc = xpfnProc; 01611 01612 LOCKPWND(); 01613 MAKECALL(FNINOUTLPSCROLLINFO); 01614 UNLOCKPWND(); 01615 CHECKRETURN(); 01616 01617 BEGINCOPYOUT() 01618 OUTSTRUCT(pinfo, SCROLLINFO); 01619 ENDCOPYOUT() 01620 01621 TRACECALLBACKMSG("SfnINOUTLPSCROLLINFO"); 01622 ENDSEND(DWORD,0); 01623 } 01624 #endif // SENDSIDE 01625 01626 #ifdef RECVSIDE 01627 RECVCALL(fnINOUTLPSCROLLINFO, FNINOUTLPSCROLLINFOMSG) 01628 { 01629 BEGINRECV(0, &pmsg->info, sizeof(pmsg->info)); 01630 01631 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01632 pmsg->pwnd, 01633 pmsg->msg, 01634 pmsg->wParam, 01635 &pmsg->info, 01636 pmsg->xParam); 01637 01638 ENDRECV(); 01639 } 01640 #endif // RECVSIDE 01641 01642 /**************************************************************************\ 01643 * yyy 01644 * 01645 * 22-Jul-1991 mikeke Created 01646 \**************************************************************************/ 01647 01648 typedef struct _FNINOUTLPPOINT5MSG { 01649 PWND pwnd; 01650 UINT msg; 01651 WPARAM wParam; 01652 POINT5 point5; 01653 ULONG_PTR xParam; 01654 PROC xpfnProc; 01655 } FNINOUTLPPOINT5MSG; 01656 01657 #ifdef SENDSIDE 01658 SMESSAGECALL(INOUTLPPOINT5) 01659 { 01660 SETUPPWND(FNINOUTLPPOINT5) 01661 01662 UNREFERENCED_PARAMETER(dwSCMSFlags); 01663 01664 BEGINSEND(FNINOUTLPPOINT5) 01665 01666 LPPOINT5 ppoint5 = (LPPOINT5)lParam; 01667 01668 MSGDATA()->pwnd = pwndClient; 01669 MSGDATA()->msg = msg; 01670 MSGDATA()->wParam = wParam; 01671 MSGDATA()->point5 = *ppoint5; 01672 MSGDATA()->xParam = xParam; 01673 MSGDATA()->xpfnProc = xpfnProc; 01674 01675 LOCKPWND(); 01676 MAKECALL(FNINOUTLPPOINT5); 01677 UNLOCKPWND(); 01678 CHECKRETURN(); 01679 01680 BEGINCOPYOUT() 01681 OUTSTRUCT(ppoint5, POINT5); 01682 ENDCOPYOUT() 01683 01684 TRACECALLBACKMSG("SfnINOUTLPPOINT5"); 01685 ENDSEND(DWORD,0); 01686 } 01687 #endif // SENDSIDE 01688 01689 #ifdef RECVSIDE 01690 RECVCALL(fnINOUTLPPOINT5, FNINOUTLPPOINT5MSG) 01691 { 01692 BEGINRECV(0, &pmsg->point5, sizeof(POINT5)); 01693 01694 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01695 pmsg->pwnd, 01696 pmsg->msg, 01697 pmsg->wParam, 01698 &pmsg->point5, 01699 pmsg->xParam); 01700 01701 ENDRECV(); 01702 } 01703 #endif // RECVSIDE 01704 01705 /**************************************************************************\ 01706 * yyy 01707 * 01708 * 22-Jul-1991 mikeke Created 01709 \**************************************************************************/ 01710 01711 typedef struct _FNINOUTLPRECTMSG { 01712 PWND pwnd; 01713 UINT msg; 01714 WPARAM wParam; 01715 RECT rect; 01716 ULONG_PTR xParam; 01717 PROC xpfnProc; 01718 } FNINOUTLPRECTMSG; 01719 01720 #ifdef SENDSIDE 01721 SMESSAGECALL(INOUTLPRECT) 01722 { 01723 SETUPPWND(FNINOUTLPRECT) 01724 01725 UNREFERENCED_PARAMETER(dwSCMSFlags); 01726 01727 BEGINSEND(FNINOUTLPRECT) 01728 01729 LPRECT prect = (LPRECT)lParam; 01730 01731 MSGDATA()->pwnd = pwndClient; 01732 MSGDATA()->msg = msg; 01733 MSGDATA()->wParam = wParam; 01734 MSGDATA()->rect = *prect; 01735 MSGDATA()->xParam = xParam; 01736 MSGDATA()->xpfnProc = xpfnProc; 01737 01738 LOCKPWND(); 01739 MAKECALL(FNINOUTLPRECT); 01740 UNLOCKPWND(); 01741 CHECKRETURN(); 01742 01743 BEGINCOPYOUT() 01744 OUTSTRUCT(prect, RECT); 01745 ENDCOPYOUT() 01746 01747 TRACECALLBACKMSG("SfnINOUTLPRECT"); 01748 ENDSEND(DWORD,0); 01749 } 01750 #endif // SENDSIDE 01751 01752 #ifdef RECVSIDE 01753 RECVCALL(fnINOUTLPRECT, FNINOUTLPRECTMSG) 01754 { 01755 BEGINRECV(0, &pmsg->rect, sizeof(pmsg->rect)); 01756 01757 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01758 pmsg->pwnd, 01759 pmsg->msg, 01760 pmsg->wParam, 01761 &pmsg->rect, 01762 pmsg->xParam); 01763 01764 ENDRECV(); 01765 } 01766 #endif // RECVSIDE 01767 01768 /**************************************************************************\ 01769 * yyy 01770 * 01771 * 11-25-92 ScottLu Created. 01772 \**************************************************************************/ 01773 01774 typedef struct _FNINOUTNCCALCSIZEMSG { 01775 PWND pwnd; 01776 UINT msg; 01777 WPARAM wParam; 01778 ULONG_PTR xParam; 01779 PROC xpfnProc; 01780 union { 01781 RECT rc; 01782 struct { 01783 NCCALCSIZE_PARAMS params; 01784 WINDOWPOS pos; 01785 } p; 01786 } u; 01787 } FNINOUTNCCALCSIZEMSG; 01788 01789 typedef struct _OUTNCCALCSIZE { 01790 NCCALCSIZE_PARAMS params; 01791 WINDOWPOS pos; 01792 } OUTNCCALCSIZE, *POUTNCCALCSIZE; 01793 01794 #ifdef SENDSIDE 01795 SMESSAGECALL(INOUTNCCALCSIZE) 01796 { 01797 SETUPPWND(FNINOUTNCCALCSIZE) 01798 01799 UNREFERENCED_PARAMETER(dwSCMSFlags); 01800 01801 BEGINSEND(FNINOUTNCCALCSIZE) 01802 01803 LPWINDOWPOS lppos; 01804 UINT cbCallback; 01805 01806 MSGDATA()->pwnd = pwndClient; 01807 MSGDATA()->msg = msg; 01808 MSGDATA()->wParam = wParam; 01809 MSGDATA()->xParam = xParam; 01810 MSGDATA()->xpfnProc = xpfnProc; 01811 01812 /* 01813 * If wParam != 0, lParam points to a NCCALCSIZE_PARAMS structure, 01814 * otherwise it points to a rectangle. 01815 */ 01816 if (wParam != 0) { 01817 MSGDATA()->u.p.params = *((LPNCCALCSIZE_PARAMS)lParam); 01818 MSGDATA()->u.p.pos = *(MSGDATA()->u.p.params.lppos); 01819 cbCallback = sizeof(FNINOUTNCCALCSIZEMSG); 01820 } else { 01821 MSGDATA()->u.rc = *((LPRECT)lParam); 01822 cbCallback = FIELD_OFFSET(FNINOUTNCCALCSIZEMSG, u) + 01823 sizeof(RECT); 01824 } 01825 01826 /* 01827 * Don't use the MAKECALL macro so we can 01828 * select the callback data size 01829 */ 01830 LOCKPWND(); 01831 LeaveCrit(); 01832 Status = (DWORD)KeUserModeCallback( 01833 FI_FNINOUTNCCALCSIZE, 01834 mp, 01835 cbCallback, 01836 &pcbs, 01837 &cbCBStatus); 01838 EnterCrit(); 01839 UNLOCKPWND(); 01840 CHECKRETURN(); 01841 01842 BEGINCOPYOUT() 01843 try { 01844 ProbeForRead(pcbs->pOutput, pcbs->cbOutput, sizeof(DWORD)); 01845 if (wParam != 0) { 01846 lppos = ((LPNCCALCSIZE_PARAMS)lParam)->lppos; 01847 *((LPNCCALCSIZE_PARAMS)lParam) = 01848 ((POUTNCCALCSIZE)pcbs->pOutput)->params; 01849 *lppos = ((POUTNCCALCSIZE)pcbs->pOutput)->pos; 01850 ((LPNCCALCSIZE_PARAMS)lParam)->lppos = lppos; 01851 } else { 01852 *((LPRECT)lParam) = *(PRECT)pcbs->pOutput; 01853 } 01854 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 01855 MSGERROR(); 01856 } 01857 ENDCOPYOUT() 01858 01859 TRACECALLBACKMSG("SfnINOUTNCCALCSIZE"); 01860 ENDSEND(DWORD,0); 01861 } 01862 #endif // SENDSIDE 01863 01864 #ifdef RECVSIDE 01865 RECVCALL(fnINOUTNCCALCSIZE, FNINOUTNCCALCSIZEMSG) 01866 { 01867 BEGINRECV(0, &pmsg->u, sizeof(pmsg->u)); 01868 01869 if (CALLDATA(wParam) != 0) 01870 CALLDATA(u.p.params).lppos = PCALLDATA(u.p.pos); 01871 01872 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01873 pmsg->pwnd, 01874 pmsg->msg, 01875 pmsg->wParam, 01876 (LPARAM)&pmsg->u, 01877 pmsg->xParam); 01878 01879 ENDRECV(); 01880 } 01881 #endif // RECVSIDE 01882 01883 /**************************************************************************\ 01884 * yyy 01885 * 01886 * 9/30/94 Sanfords created 01887 \**************************************************************************/ 01888 01889 typedef struct _FNINOUTSTYLECHANGEMSG { 01890 PWND pwnd; 01891 UINT msg; 01892 WPARAM wParam; 01893 STYLESTRUCT ss; 01894 ULONG_PTR xParam; 01895 PROC xpfnProc; 01896 } FNINOUTSTYLECHANGEMSG; 01897 01898 #ifdef SENDSIDE 01899 SMESSAGECALL(INOUTSTYLECHANGE) 01900 { 01901 SETUPPWND(FNINOUTSTYLECHANGE) 01902 01903 UNREFERENCED_PARAMETER(dwSCMSFlags); 01904 UNREFERENCED_PARAMETER(psms); 01905 01906 BEGINSEND(FNINOUTSTYLECHANGE) 01907 01908 MSGDATA()->pwnd = pwndClient; 01909 MSGDATA()->msg = msg; 01910 MSGDATA()->wParam = wParam; 01911 MSGDATA()->xParam = xParam; 01912 MSGDATA()->xpfnProc = xpfnProc; 01913 MSGDATA()->ss = *((LPSTYLESTRUCT)lParam); 01914 01915 LOCKPWND(); 01916 MAKECALL(FNINOUTSTYLECHANGE); 01917 UNLOCKPWND(); 01918 CHECKRETURN(); 01919 01920 if (msg == WM_STYLECHANGING) 01921 OUTSTRUCT(((LPSTYLESTRUCT)lParam), STYLESTRUCT); 01922 01923 TRACECALLBACKMSG("SfnINOUTSTYLECHANGE"); 01924 ENDSEND(DWORD,0); 01925 } 01926 #endif // SENDSIDE 01927 01928 #ifdef RECVSIDE 01929 RECVCALL(fnINOUTSTYLECHANGE, FNINOUTSTYLECHANGEMSG) 01930 { 01931 BEGINRECV(0, &pmsg->ss, sizeof(pmsg->ss)); 01932 01933 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 01934 CALLDATA(pwnd), 01935 CALLDATA(msg), 01936 CALLDATA(wParam), 01937 (LPARAM)&pmsg->ss, 01938 pmsg->xParam); 01939 01940 ENDRECV(); 01941 } 01942 #endif // RECVSIDE 01943 01944 /**************************************************************************\ 01945 * yyy 01946 * 01947 * 22-Jul-1991 mikeke Created 01948 \**************************************************************************/ 01949 01950 typedef struct _FNOUTLPRECTMSG { 01951 PWND pwnd; 01952 UINT msg; 01953 WPARAM wParam; 01954 ULONG_PTR xParam; 01955 PROC xpfnProc; 01956 } FNOUTLPRECTMSG; 01957 01958 #ifdef SENDSIDE 01959 SMESSAGECALL(OUTLPRECT) 01960 { 01961 SETUPPWND(FNOUTLPRECT) 01962 01963 UNREFERENCED_PARAMETER(dwSCMSFlags); 01964 01965 BEGINSEND(FNOUTLPRECT) 01966 01967 LPRECT prect = (LPRECT)lParam; 01968 01969 MSGDATA()->pwnd = pwndClient; 01970 MSGDATA()->msg = msg; 01971 MSGDATA()->wParam = wParam; 01972 MSGDATA()->xParam = xParam; 01973 MSGDATA()->xpfnProc = xpfnProc; 01974 01975 LOCKPWND(); 01976 MAKECALL(FNOUTLPRECT); 01977 UNLOCKPWND(); 01978 CHECKRETURN(); 01979 01980 BEGINCOPYOUT() 01981 OUTSTRUCT(prect, RECT); 01982 ENDCOPYOUT() 01983 01984 TRACECALLBACKMSG("SfnOUTLPRECT"); 01985 ENDSEND(DWORD,0); 01986 } 01987 #endif // SENDSIDE 01988 01989 #ifdef RECVSIDE 01990 RECVCALL(fnOUTLPRECT, FNOUTLPRECTMSG) 01991 { 01992 RECT rc; 01993 01994 BEGINRECV(0, &rc, sizeof(rc)); 01995 01996 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 01997 pmsg->pwnd, 01998 pmsg->msg, 01999 pmsg->wParam, 02000 &rc, 02001 pmsg->xParam); 02002 02003 ENDRECV(); 02004 } 02005 #endif // RECVSIDE 02006 02007 /**************************************************************************\ 02008 * yyy 02009 * 02010 * 22-Jul-1991 mikeke Created 02011 \**************************************************************************/ 02012 02013 typedef struct _FNINLPCOMPAREITEMSTRUCTMSG { 02014 PWND pwnd; 02015 UINT msg; 02016 WPARAM wParam; 02017 COMPAREITEMSTRUCT compareitemstruct; 02018 ULONG_PTR xParam; 02019 PROC xpfnProc; 02020 } FNINLPCOMPAREITEMSTRUCTMSG; 02021 02022 #ifdef SENDSIDE 02023 SMESSAGECALL(INLPCOMPAREITEMSTRUCT) 02024 { 02025 SETUPPWND(FNINLPCOMPAREITEMSTRUCT) 02026 02027 UNREFERENCED_PARAMETER(dwSCMSFlags); 02028 UNREFERENCED_PARAMETER(psms); 02029 02030 BEGINSEND(FNINLPCOMPAREITEMSTRUCT) 02031 02032 LPCOMPAREITEMSTRUCT pcompareitemstruct = (LPCOMPAREITEMSTRUCT)lParam; 02033 02034 MSGDATA()->pwnd = pwndClient; 02035 MSGDATA()->msg = msg; 02036 MSGDATA()->wParam = wParam; 02037 MSGDATA()->compareitemstruct = *pcompareitemstruct; 02038 MSGDATA()->xParam = xParam; 02039 MSGDATA()->xpfnProc = xpfnProc; 02040 02041 LOCKPWND(); 02042 MAKECALL(FNINLPCOMPAREITEMSTRUCT); 02043 UNLOCKPWND(); 02044 CHECKRETURN(); 02045 02046 TRACECALLBACKMSG("SfnINLPCOMPAREITEMSTRUCT"); 02047 ENDSEND(DWORD,0); 02048 } 02049 #endif // SENDSIDE 02050 02051 #ifdef RECVSIDE 02052 RECVCALL(fnINLPCOMPAREITEMSTRUCT, FNINLPCOMPAREITEMSTRUCTMSG) 02053 { 02054 BEGINRECV(0, NULL, 0); 02055 02056 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02057 pmsg->pwnd, 02058 pmsg->msg, 02059 pmsg->wParam, 02060 &(pmsg->compareitemstruct), 02061 pmsg->xParam); 02062 02063 ENDRECV(); 02064 } 02065 #endif // RECVSIDE 02066 02067 /**************************************************************************\ 02068 * yyy 02069 * 02070 * 22-Jul-1991 mikeke Created 02071 \**************************************************************************/ 02072 02073 typedef struct _FNINLPDELETEITEMSTRUCTMSG { 02074 PWND pwnd; 02075 UINT msg; 02076 WPARAM wParam; 02077 DELETEITEMSTRUCT deleteitemstruct; 02078 ULONG_PTR xParam; 02079 PROC xpfnProc; 02080 } FNINLPDELETEITEMSTRUCTMSG; 02081 02082 #ifdef SENDSIDE 02083 SMESSAGECALL(INLPDELETEITEMSTRUCT) 02084 { 02085 SETUPPWND(FNINLPDELETEITEMSTRUCT) 02086 02087 UNREFERENCED_PARAMETER(dwSCMSFlags); 02088 UNREFERENCED_PARAMETER(psms); 02089 02090 BEGINSEND(FNINLPDELETEITEMSTRUCT) 02091 02092 LPDELETEITEMSTRUCT pdeleteitemstruct = (LPDELETEITEMSTRUCT)lParam; 02093 02094 MSGDATA()->pwnd = pwndClient; 02095 MSGDATA()->msg = msg; 02096 MSGDATA()->wParam = wParam; 02097 MSGDATA()->deleteitemstruct = *pdeleteitemstruct; 02098 MSGDATA()->xParam = xParam; 02099 MSGDATA()->xpfnProc = xpfnProc; 02100 02101 LOCKPWND(); 02102 MAKECALL(FNINLPDELETEITEMSTRUCT); 02103 UNLOCKPWND(); 02104 CHECKRETURN(); 02105 02106 TRACECALLBACKMSG("SfnINLPDELETEITEMSTRUCT"); 02107 ENDSEND(DWORD,0); 02108 } 02109 #endif // SENDSIDE 02110 02111 #ifdef RECVSIDE 02112 RECVCALL(fnINLPDELETEITEMSTRUCT, FNINLPDELETEITEMSTRUCTMSG) 02113 { 02114 BEGINRECV(0, NULL, 0); 02115 02116 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02117 pmsg->pwnd, 02118 pmsg->msg, 02119 pmsg->wParam, 02120 &(pmsg->deleteitemstruct), 02121 pmsg->xParam); 02122 02123 ENDRECV(); 02124 } 02125 #endif // RECVSIDE 02126 02127 /**************************************************************************\ 02128 * FNINHLPSTRUCT 02129 * 02130 * 06-08-92 SanfordS Created 02131 \**************************************************************************/ 02132 02133 typedef struct _FNINLPHLPSTRUCTMSG { 02134 CAPTUREBUF CaptureBuf; 02135 PWND pwnd; 02136 UINT msg; 02137 WPARAM wParam; 02138 LPHLP lphlp; 02139 ULONG_PTR xParam; 02140 PROC xpfnProc; 02141 } FNINLPHLPSTRUCTMSG; 02142 02143 #ifdef SENDSIDE 02144 SMESSAGECALL(INLPHLPSTRUCT) 02145 { 02146 LPHLP lphlp = (LPHLP)lParam; 02147 02148 SETUPPWND(FNINLPHLPSTRUCT) 02149 02150 UNREFERENCED_PARAMETER(dwSCMSFlags); 02151 UNREFERENCED_PARAMETER(psms); 02152 02153 BEGINSENDCAPTURE(FNINLPHLPSTRUCT, 1, lphlp->cbData, TRUE) 02154 02155 MSGDATA()->pwnd = pwndClient; 02156 MSGDATA()->msg = msg; 02157 MSGDATA()->wParam = wParam; 02158 COPYBYTES(lphlp, lphlp->cbData); 02159 MSGDATA()->xParam = xParam; 02160 MSGDATA()->xpfnProc = xpfnProc; 02161 02162 LOCKPWND(); 02163 MAKECALLCAPTURE(FNINLPHLPSTRUCT); 02164 UNLOCKPWND(); 02165 CHECKRETURN(); 02166 02167 TRACECALLBACKMSG("SfnINLPHLPSTRUCT"); 02168 ENDSENDCAPTURE(DWORD,0); 02169 } 02170 #endif // SENDSIDE 02171 02172 #ifdef RECVSIDE 02173 RECVCALL(fnINLPHLPSTRUCT, FNINLPHLPSTRUCTMSG) 02174 { 02175 BEGINRECV(0, NULL, 0); 02176 FIXUPPOINTERS(); 02177 02178 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02179 pmsg->pwnd, 02180 pmsg->msg, 02181 pmsg->wParam, 02182 FIXUP(lphlp), 02183 pmsg->xParam); 02184 02185 ENDRECV(); 02186 } 02187 #endif // RECVSIDE 02188 02189 #ifndef WINHELP4 02190 02191 /**************************************************************************\ 02192 * FNINHELPINFOSTRUCT 02193 * 02194 * 06-08-92 SanfordS Created 02195 \**************************************************************************/ 02196 02197 typedef struct _FNINLPHELPFINFOSTRUCTMSG { 02198 CAPTUREBUF CaptureBuf; 02199 PWND pwnd; 02200 UINT msg; 02201 WPARAM wParam; 02202 LPHELPINFO lphlp; 02203 ULONG_PTR xParam; 02204 PROC xpfnProc; 02205 } FNINLPHELPINFOSTRUCTMSG; 02206 02207 #ifdef SENDSIDE 02208 SMESSAGECALL(INLPHELPINFOSTRUCT) 02209 { 02210 LPHELPINFO lphlp = (LPHELPINFO)lParam; 02211 02212 SETUPPWND(FNINLPHELPINFOSTRUCT) 02213 02214 UNREFERENCED_PARAMETER(dwSCMSFlags); 02215 UNREFERENCED_PARAMETER(psms); 02216 02217 BEGINSENDCAPTURE(FNINLPHELPINFOSTRUCT, 1, lphlp->cbSize, TRUE) 02218 02219 MSGDATA()->pwnd = pwndClient; 02220 MSGDATA()->msg = msg; 02221 MSGDATA()->wParam = wParam; 02222 COPYBYTES(lphlp, lphlp->cbSize); 02223 MSGDATA()->xParam = xParam; 02224 MSGDATA()->xpfnProc = xpfnProc; 02225 02226 LOCKPWND(); 02227 MAKECALLCAPTURE(FNINLPHELPINFOSTRUCT); 02228 UNLOCKPWND(); 02229 CHECKRETURN(); 02230 02231 TRACECALLBACKMSG("SfnINLPHELPINFOSTRUCT"); 02232 ENDSENDCAPTURE(DWORD,0); 02233 } 02234 #endif // SENDSIDE 02235 02236 #ifdef RECVSIDE 02237 RECVCALL(fnINLPHELPINFOSTRUCT, FNINLPHELPINFOSTRUCTMSG) 02238 { 02239 BEGINRECV(0, NULL, 0); 02240 FIXUPPOINTERS(); 02241 02242 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02243 pmsg->pwnd, 02244 pmsg->msg, 02245 pmsg->wParam, 02246 FIXUP(lphlp), 02247 pmsg->xParam); 02248 02249 ENDRECV(); 02250 } 02251 #endif // RECVSIDE 02252 #endif // WINHELP4 02253 02254 /**************************************************************************\ 02255 * yyy 02256 * 02257 * 22-Jul-1991 mikeke Created 02258 \**************************************************************************/ 02259 02260 typedef struct _FNINLPDRAWITEMSTRUCTMSG { 02261 PWND pwnd; 02262 UINT msg; 02263 WPARAM wParam; 02264 DRAWITEMSTRUCT drawitemstruct; 02265 ULONG_PTR xParam; 02266 PROC xpfnProc; 02267 } FNINLPDRAWITEMSTRUCTMSG; 02268 02269 #ifdef SENDSIDE 02270 SMESSAGECALL(INLPDRAWITEMSTRUCT) 02271 { 02272 SETUPPWND(FNINLPDRAWITEMSTRUCT) 02273 02274 UNREFERENCED_PARAMETER(dwSCMSFlags); 02275 UNREFERENCED_PARAMETER(psms); 02276 02277 BEGINSEND(FNINLPDRAWITEMSTRUCT) 02278 02279 LPDRAWITEMSTRUCT pdrawitemstruct = (LPDRAWITEMSTRUCT)lParam; 02280 HDC hdcOriginal = (HDC)NULL; 02281 02282 /* 02283 * Make sure that this is not an OLE inter-process DrawItem 02284 */ 02285 if (GreGetObjectOwner((HOBJ)pdrawitemstruct->hDC, DC_TYPE) != 02286 W32GetCurrentPID()) { 02287 if (pdrawitemstruct->hDC) { 02288 PWND pwndItem; 02289 02290 pwndItem = _WindowFromDC(pdrawitemstruct->hDC); 02291 02292 if (pwndItem) { 02293 hdcOriginal = pdrawitemstruct->hDC; 02294 pdrawitemstruct->hDC = _GetDC(pwndItem); 02295 } 02296 } 02297 } 02298 02299 02300 MSGDATA()->pwnd = pwndClient; 02301 MSGDATA()->msg = msg; 02302 MSGDATA()->wParam = wParam; 02303 MSGDATA()->drawitemstruct = *pdrawitemstruct; 02304 MSGDATA()->xParam = xParam; 02305 MSGDATA()->xpfnProc = xpfnProc; 02306 02307 LOCKPWND(); 02308 MAKECALL(FNINLPDRAWITEMSTRUCT); 02309 UNLOCKPWND(); 02310 CHECKRETURN(); 02311 02312 if (hdcOriginal) { 02313 _ReleaseDC(pdrawitemstruct->hDC); 02314 pdrawitemstruct->hDC = hdcOriginal; 02315 } 02316 TRACECALLBACKMSG("SfnINLPDRAWITEMSTRUCT"); 02317 ENDSEND(DWORD,0); 02318 } 02319 #endif // SENDSIDE 02320 02321 #ifdef RECVSIDE 02322 RECVCALL(fnINLPDRAWITEMSTRUCT, FNINLPDRAWITEMSTRUCTMSG) 02323 { 02324 BEGINRECV(0, NULL, 0); 02325 02326 if (pmsg->drawitemstruct.hDC == NULL) 02327 MSGERRORCODE(ERROR_INVALID_HANDLE); 02328 02329 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02330 pmsg->pwnd, 02331 pmsg->msg, 02332 pmsg->wParam, 02333 &(pmsg->drawitemstruct), 02334 pmsg->xParam); 02335 02336 ENDRECV(); 02337 } 02338 #endif // RECVSIDE 02339 02340 /**************************************************************************\ 02341 * fnINOUTLPMEASUREITEMSTRUCT 02342 * 02343 * 22-Jul-1991 mikeke Created 02344 \**************************************************************************/ 02345 02346 typedef struct _FNINOUTLPMEASUREITEMSTRUCTMSG { 02347 PWND pwnd; 02348 UINT msg; 02349 WPARAM wParam; 02350 MEASUREITEMSTRUCT measureitemstruct; 02351 ULONG_PTR xParam; 02352 PROC xpfnProc; 02353 } FNINOUTLPMEASUREITEMSTRUCTMSG; 02354 02355 #ifdef SENDSIDE 02356 SMESSAGECALL(INOUTLPMEASUREITEMSTRUCT) 02357 { 02358 SETUPPWND(FNINOUTLPMEASUREITEMSTRUCT) 02359 02360 BEGINSEND(FNINOUTLPMEASUREITEMSTRUCT) 02361 02362 PMEASUREITEMSTRUCT pmeasureitemstruct = (PMEASUREITEMSTRUCT)lParam; 02363 02364 MSGDATA()->pwnd = pwndClient; 02365 MSGDATA()->msg = msg & ~MSGFLAG_MASK; 02366 MSGDATA()->wParam = wParam; 02367 MSGDATA()->measureitemstruct = *pmeasureitemstruct; 02368 MSGDATA()->xParam = xParam; 02369 MSGDATA()->xpfnProc = xpfnProc; 02370 02371 LOCKPWND(); 02372 MAKECALL(FNINOUTLPMEASUREITEMSTRUCT); 02373 UNLOCKPWND(); 02374 CHECKRETURN(); 02375 02376 BEGINCOPYOUT() 02377 OUTSTRUCT(pmeasureitemstruct, MEASUREITEMSTRUCT); 02378 ENDCOPYOUT() 02379 02380 TRACECALLBACKMSG("SfnINOUTLPMEASUREITEMSTRUCT"); 02381 ENDSEND(DWORD,0); 02382 } 02383 #endif // SENDSIDE 02384 02385 #ifdef RECVSIDE 02386 RECVCALL(fnINOUTLPMEASUREITEMSTRUCT, FNINOUTLPMEASUREITEMSTRUCTMSG) 02387 { 02388 BEGINRECV(0, &pmsg->measureitemstruct, sizeof(pmsg->measureitemstruct)); 02389 02390 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02391 pmsg->pwnd, 02392 pmsg->msg, 02393 pmsg->wParam, 02394 &pmsg->measureitemstruct, 02395 pmsg->xParam); 02396 02397 ENDRECV(); 02398 } 02399 #endif // RECVSIDE 02400 02401 /**************************************************************************\ 02402 * fnINSTRING 02403 * 02404 * 22-Jul-1991 mikeke Created 02405 * 27-Jan-1992 IanJa Unicode/ANSI 02406 \**************************************************************************/ 02407 02408 typedef struct _FNINSTRINGMSG { 02409 CAPTUREBUF CaptureBuf; 02410 PWND pwnd; 02411 UINT msg; 02412 WPARAM wParam; 02413 ULONG_PTR xParam; 02414 PROC xpfnProc; 02415 LPTSTR pwsz; 02416 } FNINSTRINGMSG; 02417 02418 #ifdef SENDSIDE 02419 SMESSAGECALL(INSTRING) 02420 { 02421 PLARGE_STRING pstr = (PLARGE_STRING)lParam; 02422 DWORD cbCapture; 02423 DWORD cCapture; 02424 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 02425 02426 SETUPPWND(FNINSTRING) 02427 02428 UNREFERENCED_PARAMETER(psms); 02429 02430 /* 02431 * Compute ANSI capture lengths. Don't capture if 02432 * the strings are in the client's address space and 02433 * of the correct type. 02434 */ 02435 if (pstr && 02436 (IS_SYSTEM_ADDRESS((PVOID)pstr->Buffer) || 02437 ((BOOL)pstr->bAnsi != fAnsiReceiver))) { 02438 02439 cCapture = 1; 02440 CALC_SIZE_IN(cbCapture, pstr); 02441 02442 } else { 02443 02444 cbCapture = 0; 02445 cCapture = 0; 02446 } 02447 02448 BEGINSENDCAPTURE(FNINSTRING, cCapture, cbCapture, TRUE) 02449 02450 MSGDATA()->pwnd = pwndClient; 02451 MSGDATA()->msg = msg; 02452 MSGDATA()->wParam = wParam; 02453 02454 if (cCapture) { 02455 02456 if (!pstr->bAnsi) { 02457 02458 if (fAnsiReceiver) { 02459 LARGECOPYSTRINGLPWSTRA(pstr, pwsz); 02460 } else { 02461 LARGECOPYSTRINGLPWSTR(pstr, pwsz); 02462 } 02463 02464 } else { 02465 02466 if (fAnsiReceiver) { 02467 LARGECOPYSTRINGLPSTR(pstr, pwsz); 02468 } else { 02469 LARGECOPYSTRINGLPSTRW(pstr, pwsz); 02470 } 02471 } 02472 02473 } else { 02474 02475 MSGDATA()->pwsz = (pstr ? pstr->Buffer : NULL); 02476 } 02477 02478 MSGDATA()->xParam = xParam; 02479 MSGDATA()->xpfnProc = xpfnProc; 02480 02481 LOCKPWND(); 02482 MAKECALLCAPTURE(FNINSTRING); 02483 UNLOCKPWND(); 02484 CHECKRETURN(); 02485 02486 TRACECALLBACKMSG("SfnINSTRING"); 02487 ENDSENDCAPTURE(DWORD,0); 02488 } 02489 #endif // SENDSIDE 02490 02491 #ifdef RECVSIDE 02492 RECVCALL(fnINSTRING, FNINSTRINGMSG) 02493 { 02494 BEGINRECV(0, NULL, 0); 02495 FIXUPPOINTERS(); 02496 02497 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02498 pmsg->pwnd, 02499 pmsg->msg, 02500 pmsg->wParam, 02501 pmsg->pwsz, 02502 pmsg->xParam); 02503 02504 ENDRECV(); 02505 } 02506 #endif // RECVSIDE 02507 02508 /**************************************************************************\ 02509 * fnINSTRINGNULL 02510 * 02511 * Server-side stub translates Unicode to ANSI if required. 02512 * 02513 * 22-Jul-1991 mikeke Created 02514 * 28-Jan-1992 IanJa Unicode/ANSI (Server translate to ANSI if rquired) 02515 \**************************************************************************/ 02516 02517 typedef struct _FNINSTRINGNULLMSG { 02518 CAPTUREBUF CaptureBuf; 02519 PWND pwnd; 02520 UINT msg; 02521 WPARAM wParam; 02522 ULONG_PTR xParam; 02523 PROC xpfnProc; 02524 LPTSTR pwsz; 02525 } FNINSTRINGNULLMSG; 02526 02527 #ifdef SENDSIDE 02528 SMESSAGECALL(INSTRINGNULL) 02529 { 02530 PLARGE_STRING pstr = (PLARGE_STRING)lParam; 02531 DWORD cbCapture; 02532 DWORD cCapture; 02533 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 02534 02535 SETUPPWND(FNINSTRINGNULL) 02536 02537 UNREFERENCED_PARAMETER(psms); 02538 02539 cCapture = 0; 02540 cbCapture = 0; 02541 if (pstr) { 02542 02543 /* 02544 * Compute ANSI capture lengths. Don't capture if 02545 * the strings are in the client's address space and 02546 * of the correct type. 02547 */ 02548 if (IS_SYSTEM_ADDRESS((PVOID)pstr->Buffer) || 02549 (BOOL)pstr->bAnsi != fAnsiReceiver) { 02550 cCapture = 1; 02551 CALC_SIZE_IN(cbCapture, pstr); 02552 } 02553 } 02554 02555 BEGINSENDCAPTURE(FNINSTRINGNULL, cCapture, cbCapture, TRUE) 02556 02557 02558 MSGDATA()->pwnd = pwndClient; 02559 MSGDATA()->msg = msg; 02560 MSGDATA()->wParam = wParam; 02561 if (cCapture) { 02562 if (!pstr->bAnsi) { 02563 if (fAnsiReceiver) { 02564 LARGECOPYSTRINGLPWSTRA(pstr, pwsz); 02565 } else { 02566 LARGECOPYSTRINGLPWSTR(pstr, pwsz); 02567 } 02568 } else { 02569 if (fAnsiReceiver) { 02570 LARGECOPYSTRINGLPSTR(pstr, pwsz); 02571 } else { 02572 LARGECOPYSTRINGLPSTRW(pstr, pwsz); 02573 } 02574 } 02575 } else 02576 MSGDATA()->pwsz = pstr ? pstr->Buffer : NULL; 02577 MSGDATA()->xParam = xParam; 02578 MSGDATA()->xpfnProc = xpfnProc; 02579 02580 LOCKPWND(); 02581 MAKECALLCAPTURE(FNINSTRINGNULL); 02582 UNLOCKPWND(); 02583 CHECKRETURN(); 02584 02585 TRACECALLBACKMSG("SfnINSTRINGNULL"); 02586 ENDSENDCAPTURE(DWORD,0); 02587 } 02588 #endif // SENDSIDE 02589 02590 #ifdef RECVSIDE 02591 RECVCALL(fnINSTRINGNULL, FNINSTRINGNULLMSG) 02592 { 02593 BEGINRECV(0, NULL, 0); 02594 FIXUPPOINTERS(); 02595 02596 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02597 pmsg->pwnd, 02598 pmsg->msg, 02599 pmsg->wParam, 02600 pmsg->pwsz, 02601 pmsg->xParam); 02602 02603 ENDRECV(); 02604 } 02605 #endif // RECVSIDE 02606 02607 /**************************************************************************\ 02608 * yyy 02609 * 02610 * 27-May-1997 GregoryW Created 02611 \**************************************************************************/ 02612 02613 typedef struct _FNINLPKDRAWSWITCHWNDMSG { 02614 CAPTUREBUF CaptureBuf; 02615 PWND pwnd; 02616 UINT msg; 02617 WPARAM wParam; 02618 ULONG_PTR xParam; 02619 PROC xpfnProc; 02620 LPWSTR pwsz; 02621 RECT rcRect; 02622 } FNINLPKDRAWSWITCHWNDMSG; 02623 02624 #ifdef SENDSIDE 02625 SMESSAGECALL(INLPKDRAWSWITCHWND) 02626 { 02627 PLARGE_UNICODE_STRING pstr = &((LPKDRAWSWITCHWND *)lParam)->strName; 02628 DWORD cbCapture; 02629 DWORD cCapture = 1; // Always capture the string 02630 PWND pwndDCOwner; 02631 HDC hdcSwitch; 02632 COLORREF clrOldText, clrOldBk; 02633 HFONT hOldFont; 02634 BOOL fAnsiReceiver = FALSE; // The string is always Unicode 02635 02636 SETUPPWND(FNINLPKDRAWSWITCHWND) 02637 02638 UNREFERENCED_PARAMETER(psms); 02639 UNREFERENCED_PARAMETER(dwSCMSFlags); 02640 02641 CALC_SIZE_IN(cbCapture, pstr); 02642 02643 BEGINSENDCAPTURE(FNINLPKDRAWSWITCHWND, cCapture, cbCapture, TRUE) 02644 02645 LARGECOPYSTRINGLPWSTR(pstr, pwsz); 02646 02647 pwndDCOwner = _WindowFromDC((HDC)wParam); 02648 hdcSwitch = _GetDC(pwndDCOwner); 02649 clrOldText = GreSetTextColor(hdcSwitch, SYSRGB(BTNTEXT)); 02650 clrOldBk = GreSetBkColor(hdcSwitch, SYSRGB(3DFACE)); 02651 hOldFont = GreSelectFont(hdcSwitch, gpsi->hCaptionFont); 02652 02653 MSGDATA()->pwnd = pwndClient; 02654 MSGDATA()->msg = msg; 02655 MSGDATA()->wParam = (WPARAM)hdcSwitch; 02656 MSGDATA()->rcRect = ((LPKDRAWSWITCHWND *)lParam)->rcRect; 02657 MSGDATA()->xParam = xParam; 02658 MSGDATA()->xpfnProc = xpfnProc; 02659 02660 LOCKPWND(); 02661 MAKECALLCAPTURE(FNINLPKDRAWSWITCHWND); 02662 UNLOCKPWND(); 02663 02664 GreSelectFont(hdcSwitch, hOldFont); 02665 GreSetBkColor(hdcSwitch, clrOldBk); 02666 GreSetTextColor(hdcSwitch, clrOldText); 02667 _ReleaseDC(hdcSwitch); 02668 02669 CHECKRETURN(); 02670 02671 TRACECALLBACKMSG("SfnINLPKDRAWSWITCHWND"); 02672 ENDSENDCAPTURE(DWORD,0); 02673 } 02674 #endif // SENDSIDE 02675 02676 #ifdef RECVSIDE 02677 RECVCALL(fnINLPKDRAWSWITCHWND, FNINLPKDRAWSWITCHWNDMSG) 02678 { 02679 DRAWTEXTPARAMS dtp; 02680 02681 BEGINRECV(0, NULL, 0); 02682 FIXUPPOINTERS(); 02683 02684 dtp.cbSize = sizeof(dtp); 02685 dtp.iLeftMargin = 0; 02686 dtp.iRightMargin = 0; 02687 retval = DrawTextExW( 02688 (HDC)pmsg->wParam, 02689 pmsg->pwsz, 02690 -1, 02691 &(pmsg->rcRect), 02692 DT_NOPREFIX | DT_END_ELLIPSIS | DT_SINGLELINE, 02693 &dtp 02694 ); 02695 ENDRECV(); 02696 } 02697 #endif // RECVSIDE 02698 02699 typedef struct _FNINDEVICECHANGEMSG { 02700 CAPTUREBUF CaptureBuf; 02701 PWND pwnd; 02702 UINT msg; 02703 WPARAM wParam; 02704 ULONG_PTR xParam; 02705 PROC xpfnProc; 02706 LPTSTR pwsz; 02707 BOOL fAnsi; 02708 } FNINDEVICECHANGEMSG; 02709 02710 #ifdef SENDSIDE 02711 SMESSAGECALL(INDEVICECHANGE) 02712 { 02713 PVOID pstr = (PVOID)lParam; 02714 DWORD cbCapture; 02715 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 02716 BOOL fPtr = (BOOL)((wParam & 0x8000) == 0x8000); 02717 02718 SETUPPWND(FNINDEVICECHANGE) 02719 02720 UNREFERENCED_PARAMETER(psms); 02721 02722 cbCapture = 0; 02723 if (fPtr && (pstr != NULL)) { 02724 02725 /* 02726 * Compute ANSI capture lengths. Don't capture if 02727 * the strings are in the client's address space and 02728 * of the correct type. 02729 */ 02730 if (IS_SYSTEM_ADDRESS((PVOID)pstr)) { 02731 cbCapture = *((DWORD *)pstr); 02732 } 02733 } 02734 02735 BEGINSENDCAPTURE(FNINDEVICECHANGE, 1, cbCapture, TRUE) 02736 02737 MSGDATA()->pwnd = pwndClient; 02738 MSGDATA()->msg = msg; 02739 MSGDATA()->wParam = wParam; 02740 if (cbCapture) { 02741 LARGECOPYBYTES2(pstr, *((DWORD *)pstr), pwsz); 02742 } else { 02743 MSGDATA()->pwsz = (LPTSTR)pstr; 02744 } 02745 02746 MSGDATA()->fAnsi = fAnsiReceiver; 02747 MSGDATA()->xParam = xParam; 02748 MSGDATA()->xpfnProc = xpfnProc; 02749 02750 LOCKPWND(); 02751 MAKECALLCAPTURE(FNINDEVICECHANGE); 02752 UNLOCKPWND(); 02753 CHECKRETURN(); 02754 02755 TRACECALLBACKMSG("SfnINDEVICECHANGE"); 02756 ENDSENDCAPTURE(DWORD,0); 02757 } 02758 #endif // SENDSIDE 02759 02760 #ifdef RECVSIDE 02761 RECVCALL(fnINDEVICECHANGE, FNINDEVICECHANGEMSG) 02762 { 02763 02764 struct _DEV_BROADCAST_HEADER *pHdr; 02765 PDEV_BROADCAST_PORT_A pPortA = NULL; 02766 PDEV_BROADCAST_PORT_W pPortW; 02767 PDEV_BROADCAST_DEVICEINTERFACE_A pInterfaceA = NULL; 02768 PDEV_BROADCAST_DEVICEINTERFACE_W pInterfaceW; 02769 PDEV_BROADCAST_HANDLE pHandleA = NULL; 02770 PDEV_BROADCAST_HANDLE pHandleW; 02771 02772 int iStr, iSize; 02773 LPSTR lpStr; 02774 LPARAM lParam; 02775 02776 BEGINRECV(0, NULL, 0); 02777 FIXUPPOINTERS(); 02778 02779 if (!(lParam = (LPARAM)pmsg->pwsz) || !(pmsg->wParam & 0x8000) || !pmsg->fAnsi) { 02780 goto shipit; 02781 } 02782 02783 pHdr = (struct _DEV_BROADCAST_HEADER *)lParam; 02784 switch (pHdr->dbcd_devicetype) { 02785 case DBT_DEVTYP_PORT: 02786 pPortW = (PDEV_BROADCAST_PORT_W)lParam; 02787 iStr = wcslen(pPortW->dbcp_name); 02788 iSize = FIELD_OFFSET(DEV_BROADCAST_PORT_A, dbcp_name) + DBCS_CHARSIZE*(iStr+1); 02789 pPortA = UserLocalAlloc(0, iSize); 02790 if (pPortA == NULL) 02791 MSGERROR(); 02792 RtlCopyMemory(pPortA, pPortW, FIELD_OFFSET(DEV_BROADCAST_PORT_A, dbcp_name)); 02793 lpStr = pPortA->dbcp_name; 02794 if (iStr) { 02795 WCSToMB(pPortW->dbcp_name, -1, &lpStr, iStr, FALSE); 02796 } 02797 lpStr[iStr] = 0; 02798 pPortA->dbcp_size = iSize; 02799 lParam = (LPARAM)pPortA; 02800 break; 02801 case DBT_DEVTYP_DEVICEINTERFACE: 02802 pInterfaceW = (PDEV_BROADCAST_DEVICEINTERFACE_W)lParam; 02803 iStr = wcslen(pInterfaceW->dbcc_name); 02804 iSize = FIELD_OFFSET(DEV_BROADCAST_DEVICEINTERFACE_A, dbcc_name) + DBCS_CHARSIZE*(iStr+1); 02805 pInterfaceA = UserLocalAlloc(0, iSize); 02806 if (pInterfaceA == NULL) 02807 MSGERROR(); 02808 RtlCopyMemory(pInterfaceA, pInterfaceW, FIELD_OFFSET(DEV_BROADCAST_DEVICEINTERFACE_A, dbcc_name)); 02809 lpStr = pInterfaceA->dbcc_name; 02810 if (iStr) { 02811 WCSToMB(pInterfaceW->dbcc_name, -1, &lpStr, iStr, FALSE); 02812 } 02813 lpStr[iStr] = 0; 02814 pInterfaceA->dbcc_size = iSize; 02815 lParam = (LPARAM)pInterfaceA; 02816 break; 02817 case DBT_DEVTYP_HANDLE: 02818 pHandleW = (PDEV_BROADCAST_HANDLE)lParam; 02819 if ((pmsg->wParam != DBT_CUSTOMEVENT) || (pHandleW->dbch_nameoffset < 0)) break; 02820 iStr = wcslen((LPWSTR)(pHandleW->dbch_data+pHandleW->dbch_nameoffset)); 02821 iSize = pHandleW->dbch_size; 02822 /* 02823 * MB size can't be bigger than UNICODE size 02824 */ 02825 pHandleA = UserLocalAlloc(0, iSize); 02826 if (pHandleA == NULL) 02827 MSGERROR(); 02828 RtlCopyMemory(pHandleA, pHandleW, FIELD_OFFSET(DEV_BROADCAST_HANDLE, dbch_data)+ pHandleW->dbch_nameoffset); 02829 lpStr = pHandleA->dbch_data+pHandleA->dbch_nameoffset; 02830 if (iStr) { 02831 WCSToMB((LPWSTR)(pHandleW->dbch_data+pHandleW->dbch_nameoffset), -1, &lpStr, iStr, FALSE); 02832 } 02833 lpStr[iStr] = 0; 02834 pHandleA->dbch_size = iSize; 02835 lParam = (LPARAM)pHandleA; 02836 02837 02838 break; 02839 } 02840 shipit: 02841 retval = (ULONG_PTR)CALLPROC(pmsg->xpfnProc)( 02842 pmsg->pwnd, 02843 pmsg->msg, 02844 pmsg->wParam, 02845 lParam, 02846 pmsg->xParam); 02847 02848 if (pInterfaceA) UserLocalFree(pInterfaceA); 02849 if (pPortA) UserLocalFree(pPortA); 02850 if (pHandleA) UserLocalFree(pHandleA); 02851 02852 ENDRECV(); 02853 } 02854 #endif // RECVSIDE 02855 02856 02857 /**************************************************************************\ 02858 * fnOUTSTRING 02859 * 02860 * Warning this message copies but does not count the NULL in retval 02861 * as in WM_GETTEXT 02862 * 02863 * 22-Jul-1991 mikeke Created 02864 \**************************************************************************/ 02865 02866 typedef struct _FNOUTSTRINGMSG { 02867 CAPTUREBUF CaptureBuf; 02868 PWND pwnd; 02869 UINT msg; 02870 WPARAM wParam; 02871 ULONG_PTR xParam; 02872 PROC xpfnProc; 02873 PBYTE pOutput; 02874 DWORD cbOutput; 02875 } FNOUTSTRINGMSG; 02876 02877 #ifdef SENDSIDE 02878 SMESSAGECALL(OUTSTRING) 02879 { 02880 PLARGE_STRING pstr = (PLARGE_STRING)lParam; 02881 DWORD cbCapture; 02882 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 02883 BOOL bInflateWParam = FALSE; 02884 02885 SETUPPWND(FNOUTSTRING) 02886 02887 CALC_SIZE_OUT_STRING(cbCapture, pstr); 02888 02889 BEGINSENDCAPTURE(FNOUTSTRING, 1, cbCapture, FALSE) 02890 02891 MSGDATA()->pwnd = pwndClient; 02892 MSGDATA()->msg = msg; 02893 02894 /* 02895 * Need to wParam MBCS bytes may be required to form wParam Unicode bytes 02896 */ 02897 if (fAnsiReceiver && !(pstr->bAnsi)) { 02898 /* 02899 * Unicode -> Ansi 02900 */ 02901 MSGDATA()->wParam = (wParam * sizeof(WCHAR)); 02902 PtiCurrent()->TIF_flags |= TIF_ANSILENGTH; 02903 bInflateWParam = TRUE; 02904 } else { 02905 /* 02906 * if wParam is already adjusted for ANSI, we need to re-adjust for Unicode... 02907 * 02908 * This logic is for following cases... 02909 * 02910 * +========+===============+=============+================+=============+ 02911 * |WndProc |Unicode WndProc->Ansi WndProc->Unicode WndProc->Ansi WndProc| 02912 * +--------+---------------+-------------+----------------+-------------+ 02913 * |Length | X -> (X * 2) -> X -> (X * 2) | 02914 * +--------+---------------+-------------+----------------+-------------+ 02915 */ 02916 if (!fAnsiReceiver && (PtiCurrent()->TIF_flags & TIF_ANSILENGTH)) { 02917 /* adjust limit also... */ 02918 MSGDATA()->wParam = wParam = (wParam / sizeof(WCHAR)); 02919 PtiCurrent()->TIF_flags &= ~TIF_ANSILENGTH; 02920 } else { 02921 MSGDATA()->wParam = wParam; 02922 } 02923 } 02924 MSGDATA()->xParam = xParam; 02925 MSGDATA()->xpfnProc = xpfnProc; 02926 02927 RESERVEBYTES(cbCapture, pOutput, cbOutput); 02928 02929 LOCKPWND(); 02930 MAKECALLCAPTURE(FNOUTSTRING); 02931 UNLOCKPWND(); 02932 CHECKRETURN(); 02933 02934 BEGINCOPYOUT() 02935 if (retval) { 02936 /* 02937 * Non-zero retval means some text to copy out. Do not copy out 02938 * more than the requested byte count 'wParam'. 02939 */ 02940 COPYOUTLPWSTRLIMIT(pstr, (int)wParam); 02941 } else { 02942 /* 02943 * A dialog function returning FALSE means no text to copy out, 02944 * but an empty string also has retval == 0: put a null char in 02945 * pstr for the latter case. 02946 */ 02947 if (wParam != 0) { 02948 if (pstr->bAnsi) { 02949 *(PCHAR)pstr->Buffer = 0; 02950 } else { 02951 *(PWCHAR)pstr->Buffer = 0; 02952 } 02953 } 02954 } 02955 ENDCOPYOUT() 02956 02957 TRACECALLBACKMSG("SfnOUTSTRING"); 02958 ENDSENDCAPTUREOUTSTRING(DWORD,0); 02959 } 02960 #endif // SENDSIDE 02961 02962 #ifdef RECVSIDE 02963 RECVCALL(fnOUTSTRING, FNOUTSTRINGMSG) 02964 { 02965 BYTE abOutput[CALLBACKSTACKLIMIT]; 02966 02967 BEGINRECV(0, NULL, pmsg->cbOutput); 02968 FIXUPPOINTERS(); 02969 if (pmsg->cbOutput <= CALLBACKSTACKLIMIT) 02970 CallbackStatus.pOutput = abOutput; 02971 else 02972 CallbackStatus.pOutput = pmsg->pOutput; 02973 02974 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 02975 CALLDATA(pwnd), 02976 CALLDATA(msg), 02977 CALLDATA(wParam), 02978 (LPARAM)CallbackStatus.pOutput, 02979 CALLDATA(xParam)); 02980 02981 ENDRECV(); 02982 } 02983 #endif // RECVSIDE 02984 02985 /**************************************************************************\ 02986 * fnINCNTOUTSTRING 02987 * 02988 * Does NOT NULL terminate string 02989 * 02990 * 22-Jul-1991 mikeke Created 02991 \**************************************************************************/ 02992 02993 typedef struct _FNINCNTOUTSTRING { 02994 CAPTUREBUF CaptureBuf; 02995 PWND pwnd; 02996 UINT msg; 02997 WPARAM wParam; 02998 ULONG_PTR xParam; 02999 PROC xpfnProc; 03000 WORD cchMax; 03001 PBYTE pOutput; 03002 DWORD cbOutput; 03003 } FNINCNTOUTSTRINGMSG; 03004 03005 #ifdef SENDSIDE 03006 SMESSAGECALL(INCNTOUTSTRING) 03007 { 03008 PLARGE_STRING pstr = (PLARGE_STRING)lParam; 03009 DWORD cbCapture; 03010 WORD cchOriginal; 03011 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 03012 03013 SETUPPWND(FNINCNTOUTSTRING) 03014 03015 CALC_SIZE_OUT(cbCapture, pstr); 03016 03017 BEGINSENDCAPTURE(FNINCNTOUTSTRING, 1, cbCapture, FALSE) 03018 03019 MSGDATA()->pwnd = pwndClient; 03020 MSGDATA()->msg = msg; 03021 MSGDATA()->wParam = wParam; 03022 cchOriginal = (WORD)pstr->MaximumLength; 03023 if (!pstr->bAnsi) 03024 cchOriginal /= sizeof(WCHAR); 03025 03026 MSGDATA()->cchMax = (WORD)min(cchOriginal, 0xffff); 03027 MSGDATA()->xParam = xParam; 03028 MSGDATA()->xpfnProc = xpfnProc; 03029 03030 RESERVEBYTES(cbCapture, pOutput, cbOutput); 03031 03032 LOCKPWND(); 03033 MAKECALLCAPTURE(FNINCNTOUTSTRING) 03034 UNLOCKPWND(); 03035 CHECKRETURN(); 03036 03037 /* 03038 * We don't want to do the copy out of the sender died or if 03039 * this message was just sent as part of a CALLWNDPROC hook processing 03040 */ 03041 BEGINCOPYOUT() 03042 if (retval) { 03043 /* 03044 * Non-zero retval means some text to copy out. Do not copy out 03045 * more than the requested char count 'wParam'. 03046 */ 03047 COPYOUTLPWSTRLIMIT(pstr, (int)cchOriginal); 03048 } else { 03049 /* 03050 * A dialog function returning FALSE means no text to copy out, 03051 * but an empty string also has retval == 0: put a null char in 03052 * pstr for the latter case. 03053 */ 03054 if (pstr->bAnsi) { 03055 *(PCHAR)pstr->Buffer = 0; 03056 } else { 03057 *(PWCHAR)pstr->Buffer = 0; 03058 } 03059 } 03060 ENDCOPYOUT() 03061 03062 TRACECALLBACKMSG("SfnINCNTOUTSTRING"); 03063 ENDSENDCAPTURE(DWORD,0); 03064 } 03065 #endif // SENDSIDE 03066 03067 #ifdef RECVSIDE 03068 RECVCALL(fnINCNTOUTSTRING, FNINCNTOUTSTRINGMSG) 03069 { 03070 BYTE abOutput[CALLBACKSTACKLIMIT]; 03071 03072 BEGINRECV(0, NULL, pmsg->cbOutput); 03073 FIXUPPOINTERS(); 03074 if (pmsg->cbOutput <= CALLBACKSTACKLIMIT) 03075 CallbackStatus.pOutput = abOutput; 03076 else 03077 CallbackStatus.pOutput = pmsg->pOutput; 03078 03079 *(LPWORD)CallbackStatus.pOutput = CALLDATA(cchMax); 03080 03081 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 03082 CALLDATA(pwnd), 03083 CALLDATA(msg), 03084 CALLDATA(wParam), 03085 (LPSTR)CallbackStatus.pOutput, 03086 CALLDATA(xParam)); 03087 03088 ENDRECV(); 03089 } 03090 #endif // RECVSIDE 03091 03092 /**************************************************************************\ 03093 * fnINCNTOUTSTRINGNULL 03094 * 03095 * wParam specifies the maximum number of bytes to copy 03096 * the string is NULL terminated 03097 * 03098 * 22-Jul-1991 mikeke Created 03099 \**************************************************************************/ 03100 03101 typedef struct _FNINCNTOUTSTRINGNULL { 03102 CAPTUREBUF CaptureBuf; 03103 PWND pwnd; 03104 UINT msg; 03105 WPARAM wParam; 03106 ULONG_PTR xParam; 03107 PROC xpfnProc; 03108 PBYTE pOutput; 03109 DWORD cbOutput; 03110 } FNINCNTOUTSTRINGNULLMSG; 03111 03112 #ifdef SENDSIDE 03113 SMESSAGECALL(INCNTOUTSTRINGNULL) 03114 { 03115 PLARGE_STRING pstr = (PLARGE_STRING)lParam; 03116 DWORD cbCapture; 03117 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 03118 03119 SETUPPWND(FNINCNTOUTSTRINGNULL) 03120 03121 CALC_SIZE_OUT(cbCapture, pstr); 03122 03123 BEGINSENDCAPTURE(FNINCNTOUTSTRINGNULL, 1, cbCapture, FALSE) 03124 03125 if (wParam < 2) { // However unlikely, this prevents a possible GP 03126 MSGERROR(); // on the server side. 03127 } 03128 03129 MSGDATA()->pwnd = pwndClient; 03130 MSGDATA()->msg = msg; 03131 MSGDATA()->wParam = wParam; 03132 MSGDATA()->xParam = xParam; 03133 MSGDATA()->xpfnProc = xpfnProc; 03134 03135 RESERVEBYTES(cbCapture, pOutput, cbOutput); 03136 03137 LOCKPWND(); 03138 MAKECALLCAPTURE(FNINCNTOUTSTRINGNULL) 03139 UNLOCKPWND(); 03140 CHECKRETURN(); 03141 03142 /* 03143 * We don't want to do the copy out of the sender died or if 03144 * this message was just sent as part of a CALLWNDPROC hook processing 03145 */ 03146 BEGINCOPYOUT() 03147 if (pcbs->cbOutput != 0) { 03148 03149 /* 03150 * Buffer changed means some text to copy out. Do not copy out 03151 * more than the requested byte count 'wParam'. 03152 */ 03153 COPYOUTLPWSTRLIMIT(pstr, (int)wParam); 03154 } 03155 ENDCOPYOUT() 03156 03157 TRACECALLBACKMSG("SfnINCNTOUTSTRINGNULL"); 03158 ENDSENDCAPTURE(DWORD,0); 03159 } 03160 #endif // SENDSIDE 03161 03162 #ifdef RECVSIDE 03163 RECVCALL(fnINCNTOUTSTRINGNULL, FNINCNTOUTSTRINGNULLMSG) 03164 { 03165 BYTE abOutput[CALLBACKSTACKLIMIT]; 03166 03167 BEGINRECV(0, NULL, pmsg->cbOutput); 03168 FIXUPPOINTERS(); 03169 if (pmsg->cbOutput <= CALLBACKSTACKLIMIT) 03170 CallbackStatus.pOutput = abOutput; 03171 else 03172 CallbackStatus.pOutput = pmsg->pOutput; 03173 03174 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 03175 CALLDATA(pwnd), 03176 CALLDATA(msg), 03177 CALLDATA(wParam), 03178 (LPSTR)CallbackStatus.pOutput, 03179 CALLDATA(xParam)); 03180 03181 ENDRECV(); 03182 } 03183 #endif // RECVSIDE 03184 03185 /**************************************************************************\ 03186 * fnPOUTLPINT 03187 * 03188 * 22-Jul-1991 mikeke Created 03189 \**************************************************************************/ 03190 03191 typedef struct _FNPOUTLPINTMSG { 03192 CAPTUREBUF CaptureBuf; 03193 PWND pwnd; 03194 UINT msg; 03195 WPARAM wParam; 03196 ULONG_PTR xParam; 03197 PROC xpfnProc; 03198 PBYTE pOutput; 03199 DWORD cbOutput; 03200 } FNPOUTLPINTMSG; 03201 03202 #ifdef SENDSIDE 03203 SMESSAGECALL(POUTLPINT) 03204 { 03205 DWORD cbCapture; 03206 LPINT pint = (LPINT)lParam; 03207 03208 SETUPPWND(FNPOUTLPINT) 03209 03210 cbCapture = (UINT)wParam * sizeof(INT); 03211 03212 BEGINSENDCAPTURE(FNPOUTLPINT, 1, cbCapture, FALSE) 03213 03214 MSGDATA()->pwnd = pwndClient; 03215 MSGDATA()->msg = msg; 03216 MSGDATA()->wParam = wParam; 03217 MSGDATA()->xParam = xParam; 03218 MSGDATA()->xpfnProc = xpfnProc; 03219 03220 /* 03221 * Hooks should see the buffer content 03222 */ 03223 if (dwSCMSFlags & SCMS_FLAGS_INONLY) { 03224 MSGDATA()->cbOutput = cbCapture; 03225 LARGECOPYBYTES2(pint, cbCapture, pOutput); 03226 } else { 03227 RESERVEBYTES(cbCapture, pOutput, cbOutput); 03228 } 03229 03230 LOCKPWND(); 03231 MAKECALLCAPTURE(FNPOUTLPINT); 03232 UNLOCKPWND(); 03233 CHECKRETURN(); 03234 03235 BEGINCOPYOUT() 03236 try { 03237 ProbeForRead(pcbs->pOutput, pcbs->cbOutput, sizeof(DWORD)); 03238 memcpy(pint, pcbs->pOutput, cbCapture); 03239 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 03240 MSGERROR(); 03241 } 03242 ENDCOPYOUT() 03243 03244 TRACECALLBACKMSG("SfnPOUTLPINT"); 03245 ENDSENDCAPTURE(DWORD,0); 03246 } 03247 #endif // SENDSIDE 03248 03249 #ifdef RECVSIDE 03250 RECVCALL(fnPOUTLPINT, FNPOUTLPINTMSG) 03251 { 03252 BYTE abOutput[CALLBACKSTACKLIMIT]; 03253 03254 BEGINRECV(0, NULL, pmsg->cbOutput); 03255 FIXUPPOINTERS(); 03256 if (pmsg->cbOutput <= CALLBACKSTACKLIMIT) 03257 CallbackStatus.pOutput = abOutput; 03258 else 03259 CallbackStatus.pOutput = pmsg->pOutput; 03260 03261 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 03262 CALLDATA(pwnd), 03263 CALLDATA(msg), 03264 CALLDATA(wParam), 03265 (LPINT)CallbackStatus.pOutput, 03266 CALLDATA(xParam)); 03267 03268 ENDRECV(); 03269 } 03270 #endif // RECVSIDE 03271 03272 /**************************************************************************\ 03273 * fnPOPTINLPUINT 03274 * 03275 * NOTE!!! -- This function actually thunks arrays of INTs (32bit) and not 03276 * WORDs (16bit). The name was left the same to prevent a global rebuild 03277 * of client and server. The name should be changed to fnPOPTINLPINT as 03278 * soon as we ship the beta! The corresponding callforward function in 03279 * cf2.h should also have its name changed. 03280 * 03281 * 22-Jul-1991 mikeke Created 03282 * 07-Jan-1993 JonPa Changed to pass INTs instead of WORDs 03283 \**************************************************************************/ 03284 03285 typedef struct _FNPOPTINLPUINTMSG { 03286 CAPTUREBUF CaptureBuf; 03287 PWND pwnd; 03288 UINT msg; 03289 WPARAM wParam; 03290 LPWORD pw; 03291 ULONG_PTR xParam; 03292 PROC xpfnProc; 03293 } FNPOPTINLPUINTMSG; 03294 03295 #ifdef SENDSIDE 03296 SMESSAGECALL(POPTINLPUINT) 03297 { 03298 LPWORD pw = (LPWORD)lParam; 03299 DWORD cCapture, cbCapture; 03300 03301 SETUPPWND(FNPOPTINLPUINT); 03302 03303 UNREFERENCED_PARAMETER(dwSCMSFlags); 03304 UNREFERENCED_PARAMETER(psms); 03305 03306 if (lParam) { 03307 cCapture = 1; 03308 cbCapture = (UINT)wParam * sizeof(UINT); 03309 } else { 03310 cCapture = cbCapture = 0; 03311 } 03312 03313 BEGINSENDCAPTURE(FNPOPTINLPUINT, cCapture, cbCapture, TRUE) 03314 03315 MSGDATA()->pwnd = pwndClient; 03316 MSGDATA()->msg = msg; 03317 MSGDATA()->wParam = wParam; 03318 COPYBYTESOPT(pw, cbCapture); 03319 MSGDATA()->xParam = xParam; 03320 MSGDATA()->xpfnProc = xpfnProc; 03321 03322 LOCKPWND(); 03323 MAKECALLCAPTURE(FNPOPTINLPUINT); 03324 UNLOCKPWND(); 03325 CHECKRETURN(); 03326 03327 TRACECALLBACKMSG("SfnPOPTINLPUINT"); 03328 ENDSENDCAPTURE(DWORD,0); 03329 } 03330 #endif // SENDSIDE 03331 03332 #ifdef RECVSIDE 03333 RECVCALL(fnPOPTINLPUINT, FNPOPTINLPUINTMSG) 03334 { 03335 BEGINRECV(0, NULL, 0); 03336 FIXUPPOINTERS(); 03337 03338 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 03339 CALLDATA(pwnd), 03340 CALLDATA(msg), 03341 CALLDATA(wParam), 03342 (LPDWORD)FIRSTFIXUPOPT(pw), 03343 CALLDATA(xParam)); 03344 03345 ENDRECV(); 03346 } 03347 #endif // RECVSIDE 03348 03349 /**************************************************************************\ 03350 * fnINOUTLPWINDOWPOS (for WM_WINDOWPOSCHANGING message) 03351 * 03352 * 08-11-91 darrinm Created. 03353 \**************************************************************************/ 03354 03355 typedef struct _FNINOUTLPWINDOWPOSMSG { 03356 PWND pwnd; 03357 UINT msg; 03358 WPARAM wParam; 03359 WINDOWPOS wp; 03360 ULONG_PTR xParam; 03361 PROC xpfnProc; 03362 } FNINOUTLPWINDOWPOSMSG; 03363 03364 #ifdef SENDSIDE 03365 SMESSAGECALL(INOUTLPWINDOWPOS) 03366 { 03367 SETUPPWND(FNINOUTLPWINDOWPOS) 03368 03369 UNREFERENCED_PARAMETER(dwSCMSFlags); 03370 03371 BEGINSEND(FNINOUTLPWINDOWPOS) 03372 03373 LPWINDOWPOS pwp = (LPWINDOWPOS)lParam; 03374 03375 MSGDATA()->pwnd = pwndClient; 03376 MSGDATA()->msg = msg; 03377 MSGDATA()->wParam = wParam; 03378 MSGDATA()->wp = *pwp; 03379 MSGDATA()->xParam = xParam; 03380 MSGDATA()->xpfnProc = xpfnProc; 03381 03382 LOCKPWND(); 03383 MAKECALL(FNINOUTLPWINDOWPOS); 03384 UNLOCKPWND(); 03385 CHECKRETURN(); 03386 03387 BEGINCOPYOUT() 03388 OUTSTRUCT(pwp, WINDOWPOS); 03389 ENDCOPYOUT() 03390 03391 TRACECALLBACKMSG("SfnINOUTLPWINDOWPOS"); 03392 ENDSEND(DWORD,0); 03393 } 03394 #endif // SENDSIDE 03395 03396 #ifdef RECVSIDE 03397 RECVCALL(fnINOUTLPWINDOWPOS, FNINOUTLPWINDOWPOSMSG) 03398 { 03399 BEGINRECV(0, &pmsg->wp, sizeof(pmsg->wp)); 03400 03401 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 03402 pmsg->pwnd, 03403 pmsg->msg, 03404 pmsg->wParam, 03405 PCALLDATA(wp), 03406 pmsg->xParam); 03407 03408 ENDRECV(); 03409 } 03410 #endif // RECVSIDE 03411 03412 03413 /**************************************************************************\ 03414 * fnINLPWINDOWPOS (for WM_WINDOWPOSCHANGED message) 03415 * 03416 * 08-11-91 darrinm Created. 03417 \**************************************************************************/ 03418 03419 typedef struct _FNINLPWINDOWPOSMSG { 03420 PWND pwnd; 03421 UINT msg; 03422 WPARAM wParam; 03423 WINDOWPOS wp; 03424 ULONG_PTR xParam; 03425 PROC xpfnProc; 03426 } FNINLPWINDOWPOSMSG; 03427 03428 #ifdef SENDSIDE 03429 SMESSAGECALL(INLPWINDOWPOS) 03430 { 03431 SETUPPWND(FNINLPWINDOWPOS) 03432 03433 UNREFERENCED_PARAMETER(dwSCMSFlags); 03434 UNREFERENCED_PARAMETER(psms); 03435 03436 BEGINSEND(FNINLPWINDOWPOS) 03437 03438 LPWINDOWPOS pwp = (LPWINDOWPOS)lParam; 03439 03440 MSGDATA()->pwnd = pwndClient; 03441 MSGDATA()->msg = msg; 03442 MSGDATA()->wParam = wParam; 03443 MSGDATA()->wp = *pwp; 03444 MSGDATA()->xParam = xParam; 03445 MSGDATA()->xpfnProc = xpfnProc; 03446 03447 LOCKPWND(); 03448 MAKECALL(FNINLPWINDOWPOS); 03449 UNLOCKPWND(); 03450 CHECKRETURN(); 03451 03452 TRACECALLBACKMSG("SfnINLPWINDOWPOS"); 03453 ENDSEND(DWORD,0); 03454 } 03455 #endif // SENDSIDE 03456 03457 #ifdef RECVSIDE 03458 RECVCALL(fnINLPWINDOWPOS, FNINLPWINDOWPOSMSG) 03459 { 03460 BEGINRECV(0, NULL, 0); 03461 03462 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 03463 CALLDATA(pwnd), 03464 CALLDATA(msg), 03465 CALLDATA(wParam), 03466 PCALLDATA(wp), 03467 CALLDATA(xParam)); 03468 03469 ENDRECV(); 03470 } 03471 #endif // RECVSIDE 03472 03473 03474 03475 03476 /**************************************************************************\ 03477 * fnINOUTNEXTMENU 03478 * 03479 * 22-Jul-1991 mikeke Created 03480 \**************************************************************************/ 03481 03482 typedef struct _FNINOUTNEXTMENUMSG { 03483 PWND pwnd; 03484 UINT msg; 03485 WPARAM wParam; 03486 MDINEXTMENU mnm; 03487 ULONG_PTR xParam; 03488 PROC xpfnProc; 03489 } FNINOUTNEXTMENUMSG; 03490 03491 #ifdef SENDSIDE 03492 SMESSAGECALL(INOUTNEXTMENU) 03493 { 03494 SETUPPWND(FNINOUTNEXTMENU) 03495 03496 UNREFERENCED_PARAMETER(dwSCMSFlags); 03497 03498 BEGINSEND(FNINOUTNEXTMENU) 03499 03500 MSGDATA()->pwnd = pwndClient; 03501 MSGDATA()->msg = msg; 03502 MSGDATA()->wParam = wParam; 03503 MSGDATA()->xParam = xParam; 03504 MSGDATA()->xpfnProc = xpfnProc; 03505 MSGDATA()->mnm = *((PMDINEXTMENU)lParam); 03506 03507 LOCKPWND(); 03508 MAKECALL(FNINOUTNEXTMENU); 03509 UNLOCKPWND(); 03510 CHECKRETURN(); 03511 03512 BEGINCOPYOUT() 03513 OUTSTRUCT(((PMDINEXTMENU)lParam), MDINEXTMENU); 03514 ENDCOPYOUT() 03515 03516 TRACECALLBACKMSG("SfnINOUTNEXTMENU"); 03517 ENDSEND(DWORD,0); 03518 } 03519 #endif // SENDSIDE 03520 03521 #ifdef RECVSIDE 03522 RECVCALL(fnINOUTNEXTMENU, FNINOUTNEXTMENUMSG) 03523 { 03524 BEGINRECV(0, &pmsg->mnm, sizeof(pmsg->mnm)); 03525 03526 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 03527 CALLDATA(pwnd), 03528 CALLDATA(msg), 03529 CALLDATA(wParam), 03530 &CALLDATA(mnm), 03531 CALLDATA(xParam)); 03532 03533 ENDRECV(); 03534 } 03535 #endif // RECVSIDE 03536 03537 /**************************************************************************\ 03538 * fnHkINLPCBTCREATESTRUCT 03539 * 03540 * 22-Jul-1991 mikeke Created 03541 \**************************************************************************/ 03542 03543 typedef struct _CREATESTRUCTDATA { 03544 CREATESTRUCT cs; 03545 HWND hwndInsertAfter; 03546 } CREATESTRUCTDATA; 03547 03548 typedef struct _FNHKINLPCBTCREATESTRUCTMSG { 03549 CAPTUREBUF CaptureBuf; 03550 PWND pwnd; 03551 UINT msg; 03552 WPARAM wParam; 03553 CREATESTRUCTDATA d; 03554 PROC xpfnProc; 03555 BOOL bAnsi; 03556 } FNHKINLPCBTCREATESTRUCTMSG; 03557 03558 #ifdef SENDSIDE 03559 LRESULT fnHkINLPCBTCREATESTRUCT( 03560 UINT msg, 03561 WPARAM wParam, 03562 LPCBT_CREATEWND pcbt, 03563 PROC xpfnProc, 03564 BOOL fAnsiReceiver) 03565 { 03566 DWORD cbTitle = 0, cbClass = 0; 03567 DWORD cCapture = 0; 03568 CREATESTRUCTDATA csdOut; 03569 PCREATESTRUCTEX pcreatestruct; 03570 PWND pwnd = _GetDesktopWindow(); 03571 03572 SETUPPWND(FNHKINLPCBTCREATESTRUCT) 03573 03574 /* 03575 * Compute ANSI capture lengths. Don't capture if 03576 * the strings are in the client's address space. 03577 */ 03578 pcreatestruct = (PCREATESTRUCTEX)pcbt->lpcs; 03579 if (pcreatestruct->cs.lpszName && 03580 ((BOOL)pcreatestruct->strName.bAnsi != fAnsiReceiver || 03581 IS_SYSTEM_ADDRESS((PVOID)pcreatestruct->cs.lpszName))) { 03582 CALC_SIZE_IN(cbTitle, &pcreatestruct->strName); 03583 cCapture++; 03584 } 03585 if (IS_PTR(pcreatestruct->cs.lpszClass) && 03586 ((BOOL)pcreatestruct->strClass.bAnsi != fAnsiReceiver || 03587 IS_SYSTEM_ADDRESS((PVOID)pcreatestruct->cs.lpszClass))) { 03588 CALC_SIZE_IN(cbClass, &pcreatestruct->strClass); 03589 cCapture++; 03590 } 03591 03592 BEGINSENDCAPTURE(FNHKINLPCBTCREATESTRUCT, cCapture, cbTitle + cbClass, TRUE) 03593 03594 MSGDATA()->pwnd = pwndClient; 03595 MSGDATA()->msg = msg; 03596 MSGDATA()->wParam = wParam; 03597 03598 MSGDATA()->d.cs = *(pcbt->lpcs); 03599 03600 if (cbTitle) { 03601 if (!pcreatestruct->strName.bAnsi) { 03602 if (*(PWORD)pcreatestruct->cs.lpszName == 0xffff) { 03603 03604 /* 03605 * Copy out an ordinal of the form 0xffff, ID. 03606 * If the receiver is ANSI, skip the first 0xff. 03607 */ 03608 if (fAnsiReceiver) { 03609 if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf, 03610 (PBYTE)pcreatestruct->cs.lpszName + 1, 03611 3, (PVOID *)&mp->d.cs.lpszName))) 03612 goto errorexit; 03613 } else { 03614 if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf, 03615 (PBYTE)pcreatestruct->cs.lpszName, 03616 4, (PVOID *)&mp->d.cs.lpszName))) 03617 goto errorexit; 03618 } 03619 } else if (fAnsiReceiver) { 03620 LARGECOPYSTRINGLPWSTRA(&pcreatestruct->strName, d.cs.lpszName); 03621 } else { 03622 LARGECOPYSTRINGLPWSTR(&pcreatestruct->strName, d.cs.lpszName); 03623 } 03624 } else { 03625 if (*(PBYTE)pcreatestruct->cs.lpszName == 0xff) { 03626 03627 /* 03628 * Copy out an ordinal of the form 0xff, ID. 03629 * If the receiver is UNICODE, expand the 0xff to 0xffff. 03630 */ 03631 if (fAnsiReceiver) { 03632 if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf, 03633 (PBYTE)pcreatestruct->cs.lpszName, 03634 3, (PVOID *)&mp->d.cs.lpszName))) 03635 goto errorexit; 03636 } else { 03637 DWORD dwOrdinal; 03638 03639 dwOrdinal = MAKELONG(0xffff, 03640 (*(DWORD UNALIGNED *)pcreatestruct->cs.lpszName >> 8)); 03641 if (!NT_SUCCESS(CaptureCallbackData(&mp->CaptureBuf, 03642 &dwOrdinal, 03643 4, (PVOID *)&mp->d.cs.lpszName))) 03644 goto errorexit; 03645 } 03646 } else if (fAnsiReceiver) { 03647 LARGECOPYSTRINGLPSTR(&pcreatestruct->strName, d.cs.lpszName); 03648 } else { 03649 LARGECOPYSTRINGLPSTRW(&pcreatestruct->strName, d.cs.lpszName); 03650 } 03651 } 03652 } 03653 if (cbClass) { 03654 if (!pcreatestruct->strClass.bAnsi) { 03655 if (fAnsiReceiver) { 03656 LARGECOPYSTRINGLPWSTRA(&pcreatestruct->strClass, d.cs.lpszClass); 03657 } else { 03658 LARGECOPYSTRINGLPWSTR(&pcreatestruct->strClass, d.cs.lpszClass); 03659 } 03660 } else { 03661 if (fAnsiReceiver) { 03662 LARGECOPYSTRINGLPSTR(&pcreatestruct->strClass, d.cs.lpszClass); 03663 } else { 03664 LARGECOPYSTRINGLPSTRW(&pcreatestruct->strClass, d.cs.lpszClass); 03665 } 03666 } 03667 } 03668 03669 MSGDATA()->d.hwndInsertAfter = pcbt->hwndInsertAfter; 03670 MSGDATA()->xpfnProc = xpfnProc; 03671 MSGDATA()->bAnsi = fAnsiReceiver; 03672 03673 LOCKPWND(); 03674 MAKECALLCAPTURE(FNHKINLPCBTCREATESTRUCT); 03675 UNLOCKPWND(); 03676 CHECKRETURN(); 03677 03678 /* 03679 * Probe output data 03680 */ 03681 OUTSTRUCT(&csdOut, CREATESTRUCTDATA); 03682 03683 // MS Visual C centers its dialogs with the CBT_CREATEHOOK 03684 pcbt->hwndInsertAfter = csdOut.hwndInsertAfter; 03685 pcbt->lpcs->x = csdOut.cs.x; 03686 pcbt->lpcs->y = csdOut.cs.y; 03687 pcbt->lpcs->cx = csdOut.cs.cx; 03688 pcbt->lpcs->cy = csdOut.cs.cy; 03689 03690 TRACECALLBACK("SfnHkINLPCBTCREATESTRUCT"); 03691 ENDSENDCAPTURE(DWORD,0); 03692 } 03693 #endif // SENDSIDE 03694 03695 #ifdef RECVSIDE 03696 RECVCALL(fnHkINLPCBTCREATESTRUCT, FNHKINLPCBTCREATESTRUCTMSG) 03697 { 03698 CBT_CREATEWND cbt; 03699 03700 BEGINRECV(0, &pmsg->d, sizeof(pmsg->d)); 03701 FIXUPPOINTERS(); 03702 03703 cbt.lpcs = &pmsg->d.cs; 03704 cbt.hwndInsertAfter = pmsg->d.hwndInsertAfter; 03705 if ((ULONG_PTR)pmsg->d.cs.lpszName > gHighestUserAddress) 03706 pmsg->d.cs.lpszName = REBASEPTR(pmsg->pwnd, pmsg->d.cs.lpszName); 03707 if ((ULONG_PTR)pmsg->d.cs.lpszClass > gHighestUserAddress) 03708 pmsg->d.cs.lpszClass = REBASEPTR(pmsg->pwnd, pmsg->d.cs.lpszClass); 03709 03710 if (pmsg->bAnsi) { 03711 retval = DispatchHookA( 03712 pmsg->msg, 03713 pmsg->wParam, 03714 (LPARAM)&cbt, 03715 (HOOKPROC)pmsg->xpfnProc); 03716 } else { 03717 retval = DispatchHookW( 03718 pmsg->msg, 03719 pmsg->wParam, 03720 (LPARAM)&cbt, 03721 (HOOKPROC)pmsg->xpfnProc); 03722 } 03723 03724 pmsg->d.hwndInsertAfter = cbt.hwndInsertAfter; 03725 pmsg->d.cs.x = cbt.lpcs->x; 03726 pmsg->d.cs.y = cbt.lpcs->y; 03727 pmsg->d.cs.cx = cbt.lpcs->cx; 03728 pmsg->d.cs.cy = cbt.lpcs->cy; 03729 03730 ENDRECV(); 03731 } 03732 #endif // RECVSIDE 03733 03734 #ifdef REDIRECTION 03735 03736 /**************************************************************************\ 03737 * fnHkINLPPOINT 03738 * 03739 * 29-Jan-1999 clupu Created 03740 \**************************************************************************/ 03741 03742 typedef struct _FNHKINLPPOINTMSG { 03743 DWORD nCode; 03744 WPARAM wParam; 03745 POINT pt; 03746 ULONG_PTR xParam; 03747 PROC xpfnProc; 03748 } FNHKINLPPOINTMSG; 03749 03750 #ifdef SENDSIDE 03751 LRESULT fnHkINLPPOINT( 03752 IN DWORD nCode, 03753 IN WPARAM wParam, 03754 IN OUT LPPOINT ppt, 03755 IN ULONG_PTR xParam, 03756 IN PROC xpfnProc) 03757 { 03758 SETUP(FNHKINLPPOINT) 03759 03760 BEGINSEND(FNHKINLPPOINT) 03761 03762 MSGDATA()->nCode = nCode; 03763 MSGDATA()->wParam = wParam; 03764 MSGDATA()->pt = *ppt; 03765 MSGDATA()->xParam = xParam; 03766 MSGDATA()->xpfnProc = xpfnProc; 03767 03768 MAKECALL(FNHKINLPPOINT); 03769 CHECKRETURN(); 03770 03771 /* 03772 * Probe output data 03773 */ 03774 OUTSTRUCT(ppt, POINT); 03775 03776 TRACECALLBACK("SfnHkINLPPOINT"); 03777 ENDSEND(DWORD,0); 03778 } 03779 #endif // SENDSIDE 03780 03781 #ifdef RECVSIDE 03782 RECVCALL(fnHkINLPPOINT, FNHKINLPPOINTMSG) 03783 { 03784 BEGINRECV(0, &pmsg->pt, sizeof(POINT)); 03785 03786 retval = (DWORD)CALLPROC(pmsg->xpfnProc)( 03787 pmsg->nCode, 03788 pmsg->wParam, 03789 PCALLDATA(pt), 03790 pmsg->xParam); 03791 03792 ENDRECV(); 03793 } 03794 #endif // RECVSIDE 03795 03796 #endif // REDIRECTION 03797 03798 03799 /**************************************************************************\ 03800 * fnHkINLPRECT 03801 * 03802 * 22-Jul-1991 mikeke Created 03803 \**************************************************************************/ 03804 03805 typedef struct _FNHKINLPRECTMSG { 03806 DWORD nCode; 03807 WPARAM wParam; 03808 RECT rect; 03809 ULONG_PTR xParam; 03810 PROC xpfnProc; 03811 } FNHKINLPRECTMSG; 03812 03813 #ifdef SENDSIDE 03814 LRESULT fnHkINLPRECT( 03815 IN DWORD nCode, 03816 IN WPARAM wParam, 03817 IN OUT LPRECT prect, 03818 IN ULONG_PTR xParam, 03819 IN PROC xpfnProc) 03820 { 03821 SETUP(FNHKINLPRECT) 03822 03823 BEGINSEND(FNHKINLPRECT) 03824 03825 MSGDATA()->nCode = nCode; 03826 MSGDATA()->wParam = wParam; 03827 MSGDATA()->rect = *prect; 03828 MSGDATA()->xParam = xParam; 03829 MSGDATA()->xpfnProc = xpfnProc; 03830 03831 MAKECALL(FNHKINLPRECT); 03832 CHECKRETURN(); 03833 03834 /* 03835 * Probe output data 03836 */ 03837 OUTSTRUCT(prect, RECT); 03838 03839 TRACECALLBACK("SfnHkINLPRECT"); 03840 ENDSEND(DWORD,0); 03841 } 03842 #endif // SENDSIDE 03843 03844 #ifdef RECVSIDE 03845 RECVCALL(fnHkINLPRECT, FNHKINLPRECTMSG) 03846 { 03847 BEGINRECV(0, &pmsg->rect, sizeof(RECT)); 03848 03849 retval = (DWORD)CALLPROC(pmsg->xpfnProc)( 03850 pmsg->nCode, 03851 pmsg->wParam, 03852 PCALLDATA(rect), 03853 pmsg->xParam); 03854 03855 ENDRECV(); 03856 } 03857 #endif // RECVSIDE 03858 03859 /**************************************************************************\ 03860 * yyy 03861 * 03862 * 22-Jul-1991 mikeke Created 03863 \**************************************************************************/ 03864 03865 typedef struct _FNHKINDWORDMSG { 03866 GENERICHOOKHEADER ghh; 03867 DWORD flags; 03868 LPARAM lParam; 03869 } FNHKINDWORDMSG; 03870 03871 #ifdef SENDSIDE 03872 LRESULT fnHkINDWORD( 03873 IN DWORD nCode, 03874 IN WPARAM wParam, 03875 IN LPARAM lParam, 03876 IN ULONG_PTR xParam, 03877 IN PROC xpfnProc, 03878 IN OUT LPDWORD lpFlags) 03879 { 03880 SETUP(FNHKINDWORD) 03881 03882 BEGINSEND(FNHKINDWORD) 03883 03884 MSGDATA()->ghh.nCode = nCode; 03885 MSGDATA()->ghh.wParam = wParam; 03886 MSGDATA()->lParam = lParam; 03887 MSGDATA()->ghh.xParam = xParam; 03888 MSGDATA()->ghh.xpfnProc = xpfnProc; 03889 MSGDATA()->flags = *lpFlags; 03890 03891 MAKECALL(FNHKINDWORD); 03892 CHECKRETURN(); 03893 03894 /* 03895 * Probe output data 03896 */ 03897 OUTBITMASK(lpFlags, DWORD, HF_HOOKFAULTED); 03898 03899 TRACECALLBACK("SfnHkINDWORD"); 03900 ENDSEND(DWORD,0); 03901 } 03902 #endif // SENDSIDE 03903 03904 #ifdef RECVSIDE 03905 RECVCALL(fnHkINDWORD, FNHKINDWORDMSG) 03906 { 03907 BEGINRECV(0, &pmsg->flags, sizeof(pmsg->flags)); 03908 03909 retval = CallHookWithSEH((LPGENERICHOOKHEADER)pmsg, (LPVOID)pmsg->lParam, &pmsg->flags, retval); 03910 03911 ENDRECV(); 03912 } 03913 #endif // RECVSIDE 03914 03915 /**************************************************************************\ 03916 * yyy 03917 * 03918 * 22-Jul-1991 mikeke Created 03919 \**************************************************************************/ 03920 03921 typedef struct _FNHKINLPMSGDATA { 03922 MSG msg; 03923 DWORD flags; 03924 } FNHKINLPMSGDATA; 03925 03926 typedef struct _FNHKINLPMSGMSG { 03927 GENERICHOOKHEADER ghh; 03928 FNHKINLPMSGDATA d; 03929 } FNHKINLPMSGMSG; 03930 03931 #ifdef SENDSIDE 03932 LRESULT fnHkINLPMSG( 03933 DWORD nCode, 03934 WPARAM wParam, 03935 LPMSG pmsg, 03936 ULONG_PTR xParam, 03937 PROC xpfnProc, 03938 BOOL bAnsi, 03939 LPDWORD lpFlags) 03940 { 03941 SETUP(FNHKINLPMSG) 03942 WPARAM wParamOriginal; 03943 03944 BEGINSEND(FNHKINLPMSG) 03945 03946 MSGDATA()->ghh.nCode = nCode; 03947 MSGDATA()->ghh.wParam = wParam; 03948 03949 MSGDATA()->d.msg = *pmsg; 03950 if (((WM_CHAR == pmsg->message) || (WM_SYSCHAR == pmsg->message)) && bAnsi) { 03951 wParamOriginal = pmsg->wParam; 03952 RtlWCSMessageWParamCharToMB(pmsg->message, &(MSGDATA()->d.msg.wParam)); 03953 } 03954 03955 MSGDATA()->ghh.xParam = xParam; 03956 MSGDATA()->ghh.xpfnProc = xpfnProc; 03957 MSGDATA()->d.flags = *lpFlags; 03958 03959 MAKECALL(FNHKINLPMSG); 03960 CHECKRETURN(); 03961 03962 /* 03963 * Probe output data 03964 */ 03965 try { 03966 ProbeForRead(pcbs->pOutput, sizeof(FNHKINLPMSGDATA), sizeof(DWORD)); 03967 *pmsg = ((FNHKINLPMSGDATA *)pcbs->pOutput)->msg; 03968 COPY_FLAG(*lpFlags, ((FNHKINLPMSGDATA *)pcbs->pOutput)->flags, HF_HOOKFAULTED); 03969 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 03970 MSGERROR(); 03971 } 03972 03973 if (((WM_CHAR == pmsg->message) || (WM_SYSCHAR == pmsg->message)) && bAnsi) { 03974 /* 03975 * LATER, DBCS should be handled correctly. 03976 */ 03977 /* 03978 * If the ANSI hook didn't change the wParam we sent it, restore 03979 * the Unicode value we started with, otherwise we just collapse 03980 * Unicode chars to an ANSI codepage (best visual fit or ?) 03981 * The rotten "Intellitype" point32.exe does this. 03982 */ 03983 if (MSGDATA()->d.msg.wParam == pmsg->wParam) { 03984 pmsg->wParam = wParamOriginal; 03985 } else { 03986 RtlMBMessageWParamCharToWCS(pmsg->message, &pmsg->wParam); 03987 } 03988 } 03989 03990 TRACECALLBACK("SfnHkINLPMSG"); 03991 ENDSEND(DWORD,0); 03992 } 03993 #endif // SENDSIDE 03994 03995 #ifdef RECVSIDE 03996 RECVCALL(fnHkINLPMSG, FNHKINLPMSGMSG) 03997 { 03998 BEGINRECV(0, &pmsg->d, sizeof(pmsg->d)); 03999 04000 /* 04001 * LATER, DBCS should be handled correctly. 04002 */ 04003 04004 retval = CallHookWithSEH((LPGENERICHOOKHEADER)pmsg, &pmsg->d.msg, &pmsg->d.flags, retval); 04005 04006 ENDRECV(); 04007 } 04008 #endif // RECVSIDE 04009 04010 /**************************************************************************\ 04011 * yyy 04012 * 04013 * 22-Jul-1991 mikeke Created 04014 \**************************************************************************/ 04015 04016 typedef struct _FNHKINLPMOUSEHOOKSTRUCTEXMSG { 04017 GENERICHOOKHEADER ghh; 04018 DWORD flags; 04019 MOUSEHOOKSTRUCTEX mousehookstructex; 04020 } FNHKINLPMOUSEHOOKSTRUCTEXMSG; 04021 04022 #ifdef SENDSIDE 04023 LRESULT fnHkINLPMOUSEHOOKSTRUCTEX( 04024 IN DWORD nCode, 04025 IN WPARAM wParam, 04026 IN LPMOUSEHOOKSTRUCTEX pmousehookstructex, 04027 IN ULONG_PTR xParam, 04028 IN PROC xpfnProc, 04029 IN OUT LPDWORD lpFlags) 04030 { 04031 SETUP(FNHKINLPMOUSEHOOKSTRUCTEX) 04032 04033 BEGINSEND(FNHKINLPMOUSEHOOKSTRUCTEX) 04034 04035 MSGDATA()->ghh.nCode = nCode; 04036 MSGDATA()->ghh.wParam = wParam; 04037 MSGDATA()->mousehookstructex = *pmousehookstructex; 04038 MSGDATA()->ghh.xParam = xParam; 04039 MSGDATA()->ghh.xpfnProc = xpfnProc; 04040 MSGDATA()->flags = *lpFlags; 04041 04042 MAKECALL(FNHKINLPMOUSEHOOKSTRUCTEX); 04043 CHECKRETURN(); 04044 04045 /* 04046 * Probe output data 04047 */ 04048 OUTBITMASK(lpFlags, DWORD, HF_HOOKFAULTED); 04049 04050 TRACECALLBACK("SfnHkINLPMOUSEHOOKSTRUCTEX"); 04051 ENDSEND(DWORD,0); 04052 } 04053 #endif // SENDSIDE 04054 04055 #ifdef RECVSIDE 04056 RECVCALL(fnHkINLPMOUSEHOOKSTRUCTEX, FNHKINLPMOUSEHOOKSTRUCTEXMSG) 04057 { 04058 BEGINRECV(0, &pmsg->flags, sizeof(pmsg->flags)); 04059 04060 retval = CallHookWithSEH((LPGENERICHOOKHEADER)pmsg, &pmsg->mousehookstructex, &pmsg->flags, retval); 04061 04062 ENDRECV(); 04063 } 04064 #endif // RECVSIDE 04065 04066 /**************************************************************************\ 04067 * kbdll 04068 * 04069 * 06-Jun-1996 clupu Created 04070 \**************************************************************************/ 04071 04072 typedef struct _FNHKINLPKBDLLHOOKSTRUCTMSG { 04073 GENERICHOOKHEADER ghh; 04074 KBDLLHOOKSTRUCT kbdllhookstruct; 04075 } FNHKINLPKBDLLHOOKSTRUCTMSG; 04076 04077 #ifdef SENDSIDE 04078 LRESULT fnHkINLPKBDLLHOOKSTRUCT( 04079 IN DWORD nCode, 04080 IN WPARAM wParam, 04081 IN LPKBDLLHOOKSTRUCT pkbdllhookstruct, 04082 IN ULONG_PTR xParam, 04083 IN PROC xpfnProc) 04084 { 04085 SETUP(FNHKINLPKBDLLHOOKSTRUCT) 04086 04087 BEGINSEND(FNHKINLPKBDLLHOOKSTRUCT) 04088 04089 MSGDATA()->ghh.nCode = nCode; 04090 MSGDATA()->ghh.wParam = wParam; 04091 MSGDATA()->kbdllhookstruct = *pkbdllhookstruct; 04092 MSGDATA()->ghh.xParam = xParam; 04093 MSGDATA()->ghh.xpfnProc = xpfnProc; 04094 04095 MAKECALL(FNHKINLPKBDLLHOOKSTRUCT); 04096 CHECKRETURN(); 04097 04098 TRACECALLBACK("SfnHkINLPKBDLLHOOKSTRUCT"); 04099 ENDSEND(DWORD,0); 04100 } 04101 #endif // SENDSIDE 04102 04103 #ifdef RECVSIDE 04104 RECVCALL(fnHkINLPKBDLLHOOKSTRUCT, FNHKINLPKBDLLHOOKSTRUCTMSG) 04105 { 04106 BEGINRECV(0, &pmsg->kbdllhookstruct, sizeof(pmsg->kbdllhookstruct)); 04107 04108 retval = (DWORD)CALLPROC(pmsg->ghh.xpfnProc)( 04109 pmsg->ghh.nCode, 04110 pmsg->ghh.wParam, 04111 &pmsg->kbdllhookstruct, 04112 pmsg->ghh.xParam); 04113 04114 ENDRECV(); 04115 } 04116 #endif // RECVSIDE 04117 04118 04119 /**************************************************************************\ 04120 * msll 04121 * 04122 * 06-Jun-1996 clupu Created 04123 \**************************************************************************/ 04124 04125 typedef struct _FNHKINLPMSLLHOOKSTRUCTMSG { 04126 GENERICHOOKHEADER ghh; 04127 MSLLHOOKSTRUCT msllhookstruct; 04128 } FNHKINLPMSLLHOOKSTRUCTMSG; 04129 04130 #ifdef SENDSIDE 04131 LRESULT fnHkINLPMSLLHOOKSTRUCT( 04132 IN DWORD nCode, 04133 IN WPARAM wParam, 04134 IN LPMSLLHOOKSTRUCT pmsllhookstruct, 04135 IN ULONG_PTR xParam, 04136 IN PROC xpfnProc) 04137 { 04138 SETUP(FNHKINLPMSLLHOOKSTRUCT) 04139 04140 BEGINSEND(FNHKINLPMSLLHOOKSTRUCT) 04141 04142 MSGDATA()->ghh.nCode = nCode; 04143 MSGDATA()->ghh.wParam = wParam; 04144 MSGDATA()->msllhookstruct = *pmsllhookstruct; 04145 MSGDATA()->ghh.xParam = xParam; 04146 MSGDATA()->ghh.xpfnProc = xpfnProc; 04147 04148 MAKECALL(FNHKINLPMSLLHOOKSTRUCT); 04149 CHECKRETURN(); 04150 04151 TRACECALLBACK("SfnHkINLPMSLLHOOKSTRUCT"); 04152 ENDSEND(DWORD,0); 04153 } 04154 #endif // SENDSIDE 04155 04156 #ifdef RECVSIDE 04157 RECVCALL(fnHkINLPMSLLHOOKSTRUCT, FNHKINLPMSLLHOOKSTRUCTMSG) 04158 { 04159 BEGINRECV(0, &pmsg->msllhookstruct, sizeof(pmsg->msllhookstruct)); 04160 04161 retval = (DWORD)CALLPROC(pmsg->ghh.xpfnProc)( 04162 pmsg->ghh.nCode, 04163 pmsg->ghh.wParam, 04164 &pmsg->msllhookstruct, 04165 pmsg->ghh.xParam); 04166 04167 ENDRECV(); 04168 } 04169 #endif // RECVSIDE 04170 04171 #ifdef REDIRECTION 04172 /**************************************************************************\ 04173 * ht 04174 * 04175 * 21-Jan-1999 clupu Created 04176 \**************************************************************************/ 04177 04178 typedef struct _FNHKINLPHTHOOKSTRUCTMSG { 04179 GENERICHOOKHEADER ghh; 04180 HTHOOKSTRUCT hthookstruct; 04181 } FNHKINLPHTHOOKSTRUCTMSG; 04182 04183 #ifdef SENDSIDE 04184 LRESULT fnHkINLPHTHOOKSTRUCT( 04185 IN DWORD nCode, 04186 IN WPARAM wParam, 04187 IN OUT LPHTHOOKSTRUCT phthookstruct, 04188 IN ULONG_PTR xParam, 04189 IN PROC xpfnProc) 04190 { 04191 SETUP(FNHKINLPHTHOOKSTRUCT) 04192 04193 BEGINSEND(FNHKINLPHTHOOKSTRUCT) 04194 04195 MSGDATA()->ghh.nCode = nCode; 04196 MSGDATA()->ghh.wParam = wParam; 04197 MSGDATA()->hthookstruct = *phthookstruct; 04198 MSGDATA()->ghh.xParam = xParam; 04199 MSGDATA()->ghh.xpfnProc = xpfnProc; 04200 04201 MAKECALL(FNHKINLPHTHOOKSTRUCT); 04202 CHECKRETURN(); 04203 04204 /* 04205 * Probe output data 04206 */ 04207 if (phthookstruct != NULL) 04208 OUTSTRUCT(phthookstruct, HTHOOKSTRUCT); 04209 04210 TRACECALLBACK("SfnHkINLPHTHOOKSTRUCT"); 04211 ENDSEND(DWORD,0); 04212 } 04213 #endif // SENDSIDE 04214 04215 #ifdef RECVSIDE 04216 RECVCALL(fnHkINLPHTHOOKSTRUCT, FNHKINLPHTHOOKSTRUCTMSG) 04217 { 04218 BEGINRECV(0, &pmsg->hthookstruct, sizeof(pmsg->hthookstruct)); 04219 04220 retval = (DWORD)CALLPROC(pmsg->ghh.xpfnProc)( 04221 pmsg->ghh.nCode, 04222 pmsg->ghh.wParam, 04223 &pmsg->hthookstruct, 04224 pmsg->ghh.xParam); 04225 04226 ENDRECV(); 04227 } 04228 #endif // RECVSIDE 04229 04230 #endif // REDIRECTION 04231 04232 /**************************************************************************\ 04233 * yyy 04234 * 04235 * 22-Jul-1991 mikeke Created 04236 \**************************************************************************/ 04237 04238 typedef struct _FNHKOPTINLPEVENTMSGMSG { 04239 DWORD nCode; 04240 WPARAM wParam; 04241 LPEVENTMSGMSG peventmsgmsg; 04242 ULONG_PTR xParam; 04243 PROC xpfnProc; 04244 EVENTMSG eventmsgmsg; 04245 } FNHKOPTINLPEVENTMSGMSG; 04246 04247 #ifdef SENDSIDE 04248 LRESULT fnHkOPTINLPEVENTMSG( 04249 IN DWORD nCode, 04250 IN WPARAM wParam, 04251 IN OUT LPEVENTMSGMSG peventmsgmsg, 04252 IN ULONG_PTR xParam, 04253 IN PROC xpfnProc) 04254 { 04255 SETUP(FNHKOPTINLPEVENTMSG) 04256 04257 BEGINSEND(FNHKOPTINLPEVENTMSG) 04258 04259 MSGDATA()->nCode = nCode; 04260 MSGDATA()->wParam = wParam; 04261 COPYSTRUCTOPT(eventmsgmsg); 04262 MSGDATA()->xParam = xParam; 04263 MSGDATA()->xpfnProc = xpfnProc; 04264 04265 MAKECALL(FNHKOPTINLPEVENTMSG); 04266 CHECKRETURN(); 04267 04268 /* 04269 * Probe output data 04270 */ 04271 if (peventmsgmsg != NULL) 04272 OUTSTRUCT(peventmsgmsg, EVENTMSG); 04273 04274 TRACECALLBACK("SfnHkOPTINLPEVENTMSG"); 04275 ENDSEND(DWORD,-1); 04276 } 04277 #endif // SENDSIDE 04278 04279 #ifdef RECVSIDE 04280 RECVCALL(fnHkOPTINLPEVENTMSG, FNHKOPTINLPEVENTMSGMSG) 04281 { 04282 PHOOK phk; 04283 04284 BEGINRECV(-1, &pmsg->eventmsgmsg, sizeof(pmsg->eventmsgmsg)); 04285 04286 if (pmsg->wParam) { 04287 phk = (PHOOK)HMValidateHandle((HANDLE)pmsg->wParam, TYPE_HOOK); 04288 04289 if (phk != NULL) { 04290 /* 04291 * The HF_NEEDHC_SKIP bit is passed on from the pti when we need to 04292 * pass on a HC_SKIP 04293 */ 04294 if ((phk->flags & HF_NEEDHC_SKIP) && 04295 (HIWORD(pmsg->nCode) == WH_JOURNALPLAYBACK)) { 04296 UserAssert(LOWORD(pmsg->nCode) == HC_GETNEXT); 04297 CALLPROC(pmsg->xpfnProc)( 04298 MAKELONG(HC_SKIP, HIWORD(pmsg->nCode)), 04299 0, 04300 0, 04301 pmsg->xParam); 04302 } 04303 04304 /* 04305 * Make sure the hook wasn't free'd during the last call to the app 04306 */ 04307 if (HMIsMarkDestroy(phk)) { 04308 retval = (DWORD)-1; 04309 goto AllDoneHere; 04310 } 04311 } 04312 } 04313 04314 pmsg->wParam = 0; 04315 04316 retval = (DWORD)CALLPROC(pmsg->xpfnProc)( 04317 pmsg->nCode, 04318 pmsg->wParam, 04319 PCALLDATAOPT(eventmsgmsg), 04320 pmsg->xParam); 04321 04322 AllDoneHere: 04323 ENDRECV(); 04324 } 04325 #endif // RECVSIDE 04326 04327 /**************************************************************************\ 04328 * yyy 04329 * 04330 * 22-Jul-1991 mikeke Created 04331 \**************************************************************************/ 04332 04333 /* 04334 * Create a structure big enough to hold the larges item LPARAM points to. 04335 */ 04336 typedef union _DEBUGLPARAM { 04337 MSG msg; // WH_GETMESSAGE, WH_MSGFILTER, WH_SYSMSGFILTER 04338 CWPSTRUCT cwp; // WH_CALLWNDPROC 04339 CWPRETSTRUCT cwpret; // WH_CALLWNDPROCRET 04340 MOUSEHOOKSTRUCTEX mhs; // WH_MOUSE, HCBT_CLICKSKIPPED 04341 EVENTMSG em; // WH_JOURNALRECORD, WH_JOURNALPLAYBACK 04342 CBTACTIVATESTRUCT as; // HCBT_ACTIVATE 04343 CBT_CREATEWND cw; // HCBT_CREATEWND 04344 RECT rc; // HCBT_MOVESIZE 04345 } DEBUGLPARAM; 04346 04347 04348 typedef struct _FNHKINLPDEBUGHOOKSTRUCTMSG { 04349 DWORD nCode; 04350 WPARAM wParam; 04351 DEBUGHOOKINFO debughookstruct; 04352 DEBUGLPARAM dbgLParam; 04353 DWORD cbDbgLParam; 04354 ULONG_PTR xParam; 04355 PROC xpfnProc; 04356 } FNHKINLPDEBUGHOOKSTRUCTMSG; 04357 04358 #ifdef SENDSIDE 04359 LRESULT fnHkINLPDEBUGHOOKSTRUCT( 04360 IN DWORD nCode, 04361 IN WPARAM wParam, 04362 IN LPDEBUGHOOKINFO pdebughookstruct, 04363 IN ULONG_PTR xParam, 04364 IN PROC xpfnProc) 04365 { 04366 SETUP(FNHKINLPDEBUGHOOKSTRUCT) 04367 04368 BEGINSEND(FNHKINLPDEBUGHOOKSTRUCT) 04369 04370 MSGDATA()->nCode = nCode; 04371 MSGDATA()->wParam = wParam; 04372 MSGDATA()->debughookstruct = *pdebughookstruct; 04373 MSGDATA()->xParam = xParam; 04374 MSGDATA()->xpfnProc = xpfnProc; 04375 MSGDATA()->cbDbgLParam = GetDebugHookLParamSize(wParam, pdebughookstruct); 04376 04377 switch(wParam) { 04378 case WH_MOUSE_LL: 04379 case WH_KEYBOARD_LL: 04380 return 0; 04381 } 04382 04383 /* 04384 * if LPARAM in the debug hook points to struct then copy it over 04385 */ 04386 if (MSGDATA()->cbDbgLParam) { 04387 try { 04388 RtlCopyMemory(&MSGDATA()->dbgLParam, (BYTE *)pdebughookstruct->lParam, 04389 MSGDATA()->cbDbgLParam); 04390 } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { 04391 MSGERROR(); 04392 } 04393 } 04394 04395 MAKECALL(FNHKINLPDEBUGHOOKSTRUCT); 04396 CHECKRETURN(); 04397 04398 TRACECALLBACK("SfnHkINLPDEBUGHOOKSTRUCT"); 04399 ENDSEND(DWORD,0); 04400 } 04401 #endif // SENDSIDE 04402 04403 #ifdef RECVSIDE 04404 RECVCALL(fnHkINLPDEBUGHOOKSTRUCT, FNHKINLPDEBUGHOOKSTRUCTMSG) 04405 { 04406 BEGINRECV(0, NULL, 0); 04407 04408 if (pmsg->cbDbgLParam) { 04409 pmsg->debughookstruct.lParam = (LPARAM)&(pmsg->dbgLParam); 04410 } 04411 04412 retval = (DWORD)CALLPROC(pmsg->xpfnProc)( 04413 pmsg->nCode, 04414 pmsg->wParam, 04415 &(pmsg->debughookstruct), 04416 pmsg->xParam); 04417 04418 ENDRECV(); 04419 } 04420 #endif // RECVSIDE 04421 04422 DWORD GetDebugHookLParamSize( 04423 IN WPARAM wParam, 04424 IN PDEBUGHOOKINFO pdebughookstruct) 04425 { 04426 DWORD cbDbgLParam = 0; 04427 04428 switch(wParam) { 04429 case WH_MSGFILTER: 04430 case WH_SYSMSGFILTER: 04431 case WH_GETMESSAGE: 04432 cbDbgLParam = sizeof(MSG); 04433 break; 04434 04435 case WH_CALLWNDPROC: 04436 cbDbgLParam = sizeof(CWPSTRUCT); 04437 break; 04438 04439 case WH_CALLWNDPROCRET: 04440 cbDbgLParam = sizeof(CWPRETSTRUCT); 04441 break; 04442 04443 case WH_MOUSE: 04444 cbDbgLParam = sizeof(MOUSEHOOKSTRUCTEX); 04445 break; 04446 04447 case WH_JOURNALRECORD: 04448 case WH_JOURNALPLAYBACK: 04449 cbDbgLParam = sizeof(EVENTMSG); 04450 break; 04451 04452 case WH_CBT: 04453 switch (pdebughookstruct->code) { 04454 case HCBT_ACTIVATE: 04455 cbDbgLParam = sizeof(CBTACTIVATESTRUCT); 04456 break; 04457 case HCBT_CLICKSKIPPED: 04458 cbDbgLParam = sizeof(MOUSEHOOKSTRUCTEX); 04459 break; 04460 case HCBT_CREATEWND: 04461 cbDbgLParam = sizeof(CBT_CREATEWND); 04462 break; 04463 case HCBT_MOVESIZE: 04464 cbDbgLParam = sizeof(RECT); 04465 break; 04466 } 04467 break; 04468 04469 case WH_SHELL: 04470 if (pdebughookstruct->code == HSHELL_GETMINRECT) { 04471 cbDbgLParam = sizeof(RECT); 04472 } 04473 break; 04474 } 04475 return cbDbgLParam; 04476 } 04477 04478 /**************************************************************************\ 04479 * fnHkINLPCBTACTIVATESTRUCT 04480 * 04481 * 17-Mar-1992 jonpa Created 04482 \**************************************************************************/ 04483 04484 typedef struct _FNHKINLPCBTACTIVATESTRUCTMSG { 04485 DWORD nCode; 04486 WPARAM wParam; 04487 CBTACTIVATESTRUCT cbtactivatestruct; 04488 ULONG_PTR xParam; 04489 PROC xpfnProc; 04490 } FNHKINLPCBTACTIVATESTRUCTMSG; 04491 04492 #ifdef SENDSIDE 04493 LRESULT fnHkINLPCBTACTIVATESTRUCT( 04494 IN DWORD nCode, 04495 IN WPARAM wParam, 04496 IN LPCBTACTIVATESTRUCT pcbtactivatestruct, 04497 IN ULONG_PTR xParam, 04498 IN PROC xpfnProc) 04499 { 04500 SETUP(FNHKINLPCBTACTIVATESTRUCT) 04501 04502 BEGINSEND(FNHKINLPCBTACTIVATESTRUCT) 04503 04504 MSGDATA()->nCode = nCode; 04505 MSGDATA()->wParam = wParam; 04506 MSGDATA()->cbtactivatestruct = *pcbtactivatestruct; 04507 MSGDATA()->xParam = xParam; 04508 MSGDATA()->xpfnProc = xpfnProc; 04509 04510 MAKECALL(FNHKINLPCBTACTIVATESTRUCT); 04511 CHECKRETURN(); 04512 04513 TRACECALLBACK("SfnHkINLPCBTACTIVATESTRUCT"); 04514 ENDSEND(DWORD,0); 04515 } 04516 #endif // SENDSIDE 04517 04518 #ifdef RECVSIDE 04519 RECVCALL(fnHkINLPCBTACTIVATESTRUCT, FNHKINLPCBTACTIVATESTRUCTMSG) 04520 { 04521 BEGINRECV(0, NULL, 0); 04522 04523 retval = (DWORD)CALLPROC(pmsg->xpfnProc)( 04524 pmsg->nCode, 04525 pmsg->wParam, 04526 &(pmsg->cbtactivatestruct), 04527 pmsg->xParam); 04528 04529 ENDRECV(); 04530 } 04531 #endif // RECVSIDE 04532 04533 04534 /**************************************************************************\ 04535 * ClientLoadMenu 04536 * 04537 * 22-Jul-1991 mikeke Created 04538 \**************************************************************************/ 04539 04540 typedef struct _CLIENTLOADMENUMSG { 04541 CAPTUREBUF CaptureBuf; 04542 HANDLE hmod; 04543 UNICODE_STRING strName; 04544 } CLIENTLOADMENUMSG; 04545 04546 #ifdef SENDSIDE 04547 PMENU xxxClientLoadMenu( 04548 IN HANDLE hmod, 04549 IN PUNICODE_STRING pstrName) 04550 { 04551 DWORD cCapture, cbCapture; 04552 04553 SETUP(CLIENTLOADMENU) 04554 04555 if (pstrName->MaximumLength) { 04556 cCapture = 1; 04557 cbCapture = pstrName->MaximumLength; 04558 } else 04559 cCapture = cbCapture = 0; 04560 04561 BEGINSENDCAPTURE(CLIENTLOADMENU, cCapture, cbCapture, TRUE) 04562 04563 MSGDATA()->hmod = hmod; 04564 COPYSTRINGID(strName); 04565 04566 MAKECALLCAPTURE(CLIENTLOADMENU); 04567 CHECKRETURN(); 04568 04569 retval = (ULONG_PTR)HtoP((HMENU)retval); 04570 04571 TRACECALLBACK("ClientLoadMenu"); 04572 ENDSENDCAPTURE(PMENU,0); 04573 } 04574 #endif // SENDSIDE 04575 04576 #ifdef RECVSIDE 04577 RECVCALL(ClientLoadMenu, CLIENTLOADMENUMSG) 04578 { 04579 BEGINRECV(0, NULL, 0); 04580 FIXUPPOINTERS(); 04581 04582 retval = (ULONG_PTR)LoadMenu( 04583 CALLDATA(hmod) ? CALLDATA(hmod) : hmodUser, 04584 (LPTSTR)FIXUPSTRINGID(strName)); 04585 04586 ENDRECV(); 04587 } 04588 #endif // RECVSIDE 04589 04590 /**************************************************************************\ 04591 * xxxClientLoadImage 04592 * 04593 * 28-Aug-1995 ChrisWil Created 04594 \**************************************************************************/ 04595 04596 typedef struct _CLIENTLOADIMAGEMSG { 04597 CAPTUREBUF CaptureBuf; 04598 UNICODE_STRING strModName; 04599 UNICODE_STRING strName; 04600 UINT uImageType; 04601 int cxDesired; 04602 int cyDesired; 04603 UINT LR_flags; 04604 BOOL fWallpaper; 04605 } CLIENTLOADIMAGEMSG; 04606 04607 #ifdef SENDSIDE 04608 HANDLE xxxClientLoadImage( 04609 IN PUNICODE_STRING pstrName, 04610 IN ATOM atomModName, 04611 IN WORD wImageType, 04612 IN int cxDesired, 04613 IN int cyDesired, 04614 IN UINT LR_flags, 04615 IN BOOL fWallpaper) 04616 { 04617 DWORD cCapture; 04618 DWORD cbCapture; 04619 WCHAR awszModName[MAX_PATH]; 04620 UNICODE_STRING strModName; 04621 PUNICODE_STRING pstrModName = &strModName; 04622 04623 SETUP(CLIENTLOADIMAGE) 04624 04625 if (pstrName->MaximumLength) { 04626 cCapture = 1; 04627 cbCapture = pstrName->MaximumLength; 04628 } else { 04629 cCapture = 04630 cbCapture = 0; 04631 } 04632 if (atomModName && atomModName != atomUSER32) { 04633 UserGetAtomName(atomModName, awszModName, MAX_PATH); 04634 RtlInitUnicodeString(&strModName, awszModName); 04635 } else { 04636 strModName.Length = strModName.MaximumLength = 0; 04637 strModName.Buffer = NULL; 04638 } 04639 if (pstrModName->MaximumLength) { 04640 cCapture++; 04641 cbCapture += pstrModName->MaximumLength; 04642 } 04643 04644 BEGINSENDCAPTURE(CLIENTLOADIMAGE, cCapture, cbCapture, TRUE) 04645 04646 COPYSTRINGOPT(strModName); 04647 COPYSTRINGID(strName); 04648 MSGDATA()->uImageType = (UINT)wImageType; 04649 MSGDATA()->cxDesired = cxDesired; 04650 MSGDATA()->cyDesired = cyDesired; 04651 MSGDATA()->LR_flags = LR_flags; 04652 MSGDATA()->fWallpaper = fWallpaper; 04653 04654 MAKECALLCAPTURE(CLIENTLOADIMAGE); 04655 CHECKRETURN(); 04656 04657 if (retval && (wImageType != IMAGE_BITMAP)) { 04658 retval = (ULONG_PTR)HMRevalidateHandle((HANDLE)retval); 04659 } 04660 04661 TRACECALLBACK("ClientLoadImage"); 04662 ENDSENDCAPTURE(PCURSOR,0); 04663 } 04664 #endif // SENDSIDE 04665 04666 #ifdef RECVSIDE 04667 RECVCALL(ClientLoadImage, CLIENTLOADIMAGEMSG) 04668 { 04669 HMODULE hmod; 04670 LPTSTR filepart; 04671 LPTSTR lpszName; 04672 TCHAR szFullPath[MAX_PATH]; 04673 04674 BEGINRECV(0, NULL, 0); 04675 FIXUPPOINTERS(); 04676 04677 if (hmod = (HMODULE)FIXUPSTRINGIDOPT(strModName)) { 04678 04679 if ((hmod = GetModuleHandle((LPTSTR)hmod)) == NULL) { 04680 MSGERROR(); 04681 } 04682 } 04683 04684 /* 04685 * Find the file. This normalizes the filename. 04686 */ 04687 lpszName = (LPTSTR)FIXUPSTRINGID(strName); 04688 04689 if (CALLDATA(fWallpaper)) { 04690 04691 if (!SearchPath(NULL, 04692 lpszName, 04693 TEXT(".bmp"), 04694 ARRAY_SIZE(szFullPath), 04695 szFullPath, 04696 &filepart)) { 04697 04698 MSGERROR(); 04699 } 04700 04701 lpszName = szFullPath; 04702 } 04703 04704 retval = (ULONG_PTR)LoadImage(hmod, 04705 lpszName, 04706 CALLDATA(uImageType), 04707 CALLDATA(cxDesired), 04708 CALLDATA(cyDesired), 04709 CALLDATA(LR_flags)); 04710 04711 ENDRECV(); 04712 } 04713 #endif // RECVSIDE 04714 04715 /***********************************************************************\ 04716 * xxxClientCopyImage 04717 * 04718 * Returns: hIconCopy - note LR_flags could cause this to be the same as 04719 * what came in. 04720 * 04721 * 11/3/1995 Created SanfordS 04722 \***********************************************************************/ 04723 04724 typedef struct _CLIENTCOPYIMAGEMSG { 04725 HANDLE hImage; 04726 UINT uImageType; 04727 int cxDesired; 04728 int cyDesired; 04729 UINT LR_flags; 04730 } CLIENTCOPYIMAGEMSG; 04731 04732 #ifdef SENDSIDE 04733 HANDLE xxxClientCopyImage( 04734 IN HANDLE hImage, 04735 IN UINT uImageType, 04736 IN int cxDesired, 04737 IN int cyDesired, 04738 IN UINT LR_flags) 04739 { 04740 SETUP(CLIENTCOPYIMAGE) 04741 04742 BEGINSEND(CLIENTCOPYIMAGE) 04743 04744 MSGDATA()->hImage = hImage; 04745 MSGDATA()->uImageType = uImageType; 04746 MSGDATA()->cxDesired = cxDesired; 04747 MSGDATA()->cyDesired = cyDesired; 04748 MSGDATA()->LR_flags = LR_flags; 04749 04750 MAKECALL(CLIENTCOPYIMAGE); 04751 CHECKRETURN(); 04752 04753 if (retval && (uImageType != IMAGE_BITMAP)) { 04754 retval = (ULONG_PTR)HMRevalidateHandle((HANDLE)retval); 04755 } 04756 04757 TRACECALLBACK("ClientCopyImage"); 04758 ENDSEND(HANDLE,0); 04759 } 04760 #endif // SENDSIDE 04761 04762 #ifdef RECVSIDE 04763 RECVCALL(ClientCopyImage, CLIENTCOPYIMAGEMSG) 04764 { 04765 BEGINRECV(0, NULL, 0); 04766 04767 retval = (ULONG_PTR)InternalCopyImage(CALLDATA(hImage), 04768 CALLDATA(uImageType), 04769 CALLDATA(cxDesired), 04770 CALLDATA(cyDesired), 04771 CALLDATA(LR_flags)); 04772 04773 ENDRECV(); 04774 } 04775 #endif // RECVSIDE 04776 04777 /**************************************************************************\ 04778 * yyy 04779 * 04780 * 22-Jul-1991 mikeke Created 04781 \**************************************************************************/ 04782 04783 typedef struct _CLIENTGETLISTBOXSTRINGMSG { 04784 CAPTUREBUF CaptureBuf; 04785 PWND pwnd; 04786 UINT msg; 04787 WPARAM wParam; 04788 ULONG_PTR xParam; 04789 PROC xpfn; 04790 PBYTE pOutput; 04791 DWORD cbOutput; 04792 } CLIENTGETLISTBOXSTRINGMSG; 04793 04794 #ifdef SENDSIDE 04795 DWORD ClientGetListboxString( 04796 IN PWND pwnd, 04797 IN UINT msg, 04798 IN WPARAM wParam, 04799 OUT PVOID pdata, 04800 IN ULONG_PTR xParam, 04801 IN PROC xpfn, 04802 IN DWORD dwSCMSFlags, 04803 IN BOOL bNotString, 04804 IN PSMS psms) 04805 { 04806 DWORD cbCapture; 04807 DWORD cchRet; 04808 PLARGE_STRING pstr; 04809 BOOL fAnsiReceiver = (dwSCMSFlags & SCMS_FLAGS_ANSI); 04810 04811 SETUPPWND(CLIENTGETLISTBOXSTRING) 04812 04813 CheckLock(pwnd); 04814 04815 pstr = (PLARGE_STRING)pdata; 04816 cbCapture = pstr->MaximumLength; 04817 04818 BEGINSENDCAPTURE(CLIENTGETLISTBOXSTRING, 1, cbCapture, FALSE) 04819 04820 MSGDATA()->pwnd = pwndClient; 04821 MSGDATA()->msg = msg; 04822 MSGDATA()->wParam = wParam; 04823 MSGDATA()->xParam = xParam; 04824 MSGDATA()->xpfn = xpfn; 04825 04826 RESERVEBYTES(cbCapture, pOutput, cbOutput); 04827 04828 LOCKPWND(); 04829 MAKECALLCAPTURE(CLIENTGETLISTBOXSTRING); 04830 UNLOCKPWND(); 04831 CHECKRETURN(); 04832 04833 BEGINCOPYOUT() 04834 if (bNotString) { 04835 /* 04836 * This is a 4-byte "object" for ownerdraw listboxes without 04837 * the LBS_HASSTRINGS style. 04838 */ 04839 OUTSTRUCT((PULONG_PTR)pstr->Buffer, ULONG_PTR); 04840 } else { 04841 COPYOUTLPWSTRLIMIT(pstr, 04842 pstr->bAnsi ? (int)pstr->MaximumLength : 04843 (int)pstr->MaximumLength / sizeof(WCHAR)); 04844 } 04845 04846 cchRet = pstr->Length; 04847 if (!pstr->bAnsi) 04848 cchRet *= sizeof(WCHAR); 04849 if (!bNotString && retval != LB_ERR && retval > cchRet) { 04850 RIPMSG2(RIP_WARNING, "GetListBoxString: limit %lX chars to %lX\n", 04851 retval, cchRet); 04852 retval = cchRet; 04853 } 04854 ENDCOPYOUT() 04855 04856 TRACECALLBACK("ClientGetListboxString"); 04857 ENDSENDCAPTURE(DWORD,0); 04858 } 04859 #endif // SENDSIDE 04860 04861 #ifdef RECVSIDE 04862 RECVCALL(ClientGetListboxString, CLIENTGETLISTBOXSTRINGMSG) 04863 { 04864 BYTE abOutput[CALLBACKSTACKLIMIT]; 04865 04866 BEGINRECV(0, NULL, pmsg->cbOutput); 04867 FIXUPPOINTERS(); 04868 if (pmsg->cbOutput <= CALLBACKSTACKLIMIT) 04869 CallbackStatus.pOutput = abOutput; 04870 else 04871 CallbackStatus.pOutput = pmsg->pOutput; 04872 04873 retval = (DWORD)_ClientGetListboxString( 04874 CALLDATA(pwnd), 04875 CALLDATA(msg), 04876 CALLDATA(wParam), 04877 (LPSTR)CallbackStatus.pOutput, 04878 CALLDATA(xParam), 04879 CALLDATA(xpfn)); 04880 04881 ENDRECV(); 04882 } 04883 #endif // RECVSIDE 04884 04885 /**************************************************************************\ 04886 * yyy 04887 * 04888 * 22-Jul-1991 mikeke Created 04889 \**************************************************************************/ 04890 04891 typedef struct _CLIENTLOADLIBRARYMSG { 04892 CAPTUREBUF CaptureBuf; 04893 UNICODE_STRING strLib; 04894 BOOL bWx86KnownDll; 04895 } CLIENTLOADLIBRARYMSG; 04896 04897 #ifdef SENDSIDE 04898 HANDLE ClientLoadLibrary( 04899 IN PUNICODE_STRING pstrLib, 04900 IN BOOL bWx86KnownDll) 04901 { 04902 SETUP(CLIENTLOADLIBRARY) 04903 04904 BEGINSENDCAPTURE(CLIENTLOADLIBRARY, 1, pstrLib->MaximumLength, TRUE) 04905 04906 MSGDATA()->bWx86KnownDll = bWx86KnownDll; 04907 COPYSTRING(strLib); 04908 04909 MAKECALLCAPTURE(CLIENTLOADLIBRARY); 04910 CHECKRETURN(); 04911 04912 TRACECALLBACK("ClientLoadLibrary"); 04913 ENDSENDCAPTURE(HANDLE,0); 04914 } 04915 #endif // SENDSIDE 04916 04917 #ifdef RECVSIDE 04918 RECVCALL(ClientLoadLibrary, CLIENTLOADLIBRARYMSG) 04919 { 04920 BEGINRECV(0, NULL, 0); 04921 FIXUPPOINTERS(); 04922 04923 #if defined(WX86) 04924 04925 if (CALLDATA(bWx86KnownDll)) { 04926 04927 // 04928 // If we haven't done so yet, setup this process to use Wx86 04929 // to emulate x86 hook procedures. Wx86 once loaded into the client 04930 // process is NEVER freed. This avoids having to load\free wx86 every 04931 // time a client hook dll is loaded, and hence every time a 04932 // sethook\unsethook cycle occurs. 04933 // 04934 04935 04936 RtlEnterCriticalSection(&gcsWx86Load); 04937 04938 if (Wx86LoadCount > 0) { 04939 Wx86LoadCount++; 04940 } 04941 else if (!Wx86LoadCount){ 04942 Wx86LoadCount++; 04943 hWx86Dll = LoadLibraryExW(L"Wx86.dll", NULL, 0); 04944 if (hWx86Dll) { 04945 pfnWx86HookCallBack = (PVOID)GetProcAddress(hWx86Dll, 04946 "Wx86HookCallBack" 04947 ); 04948 04949 pfnWx86LoadX86Dll = (PVOID)GetProcAddress(hWx86Dll, 04950 "Wx86LoadX86Dll" 04951 ); 04952 04953 04954 pfnWx86FreeX86Dll = (PVOID)GetProcAddress(hWx86Dll, 04955 "Wx86FreeX86Dll" 04956 ); 04957 } 04958 04959 04960 if (!hWx86Dll || !pfnWx86HookCallBack || !pfnWx86LoadX86Dll || !pfnWx86FreeX86Dll) { 04961 pfnWx86HookCallBack = NULL; 04962 pfnWx86LoadX86Dll = NULL; 04963 pfnWx86FreeX86Dll = NULL; 04964 Wx86LoadCount = -1; 04965 retval = 0; 04966 RtlLeaveCriticalSection(&gcsWx86Load); 04967 goto CLLFail; 04968 } 04969 } 04970 04971 // 04972 // Wx86LoadCount == -1, means load has previously failed 04973 // and can't load the x86 dll. 04974 // 04975 else { 04976 retval = 0; 04977 RtlLeaveCriticalSection(&gcsWx86Load); 04978 goto CLLFail; 04979 } 04980 04981 RtlLeaveCriticalSection(&gcsWx86Load); 04982 04983 04984 04985 04986 04987 retval = (ULONG_PTR)pfnWx86LoadX86Dll((LPTSTR)FIXUPSTRING(strLib), 04988 LOAD_WITH_ALTERED_SEARCH_PATH 04989 ); 04990 04991 } 04992 else { 04993 retval = (ULONG_PTR)LoadLibraryEx((LPTSTR)FIXUPSTRING(strLib), 04994 NULL, 04995 LOAD_WITH_ALTERED_SEARCH_PATH 04996 ); 04997 } 04998 04999 #else 05000 05001 retval = (ULONG_PTR)LoadLibraryEx((LPTSTR)FIXUPSTRING(strLib), NULL, LOAD_WITH_ALTERED_SEARCH_PATH); 05002 05003 #endif 05004 05005 05006 #if defined(WX86) 05007 CLLFail: 05008 #endif 05009 05010 ENDRECV(); 05011 } 05012 #endif // RECVSIDE 05013 05014 /**************************************************************************\ 05015 * yyy 05016 * 05017 * 22-Jul-1991 mikeke Created 05018 \**************************************************************************/ 05019 05020 typedef struct _CLIENTFREELIBRARYMSG { 05021 HANDLE hmod; 05022 } CLIENTFREELIBRARYMSG; 05023 05024 #ifdef SENDSIDE 05025 BOOL ClientFreeLibrary( 05026 IN HANDLE hmod) 05027 { 05028 SETUP(CLIENTFREELIBRARY) 05029 05030 BEGINSEND(CLIENTFREELIBRARY) 05031 05032 MSGDATA()->hmod = hmod; 05033 05034 MAKECALL(CLIENTFREELIBRARY); 05035 CHECKRETURN(); 05036 05037 TRACECALLBACK("ClientFreeLibrary"); 05038 ENDSEND(BOOL,0); 05039 } 05040 #endif // SENDSIDE 05041 05042 #ifdef RECVSIDE 05043 RECVCALL(ClientFreeLibrary, CLIENTFREELIBRARYMSG) 05044 { 05045 BEGINRECV(0, NULL, 0); 05046 05047 #if defined(WX86) 05048 05049 // 05050 // if the Hook Module is an X86 image, notify Wx86, so that 05051 // it can clear its hook cache. 05052 // 05053 05054 if (RtlImageNtHeader(pmsg->hmod)->FileHeader.Machine == IMAGE_FILE_MACHINE_I386) { 05055 05056 RtlEnterCriticalSection(&gcsWx86Load); 05057 05058 if (Wx86LoadCount > 0) { 05059 pfnWx86HookCallBack(0, NULL); 05060 retval = (DWORD)pfnWx86FreeX86Dll(pmsg->hmod); 05061 if (!--Wx86LoadCount) { 05062 FreeLibrary(hWx86Dll); 05063 } 05064 } 05065 else { 05066 retval = 0; // FALSE 05067 } 05068 05069 RtlLeaveCriticalSection(&gcsWx86Load); 05070 05071 } 05072 else { 05073 retval = (DWORD)FreeLibrary(pmsg->hmod); 05074 } 05075 05076 #else 05077 05078 retval = (DWORD)FreeLibrary(pmsg->hmod); 05079 05080 #endif 05081 05082 ENDRECV(); 05083 } 05084 #endif // RECVSIDE 05085 05086 /**************************************************************************\ 05087 * xxxClientGetCharsetInfo 05088 * 05089 * 96-06-11 IanJa Created 05090 \**************************************************************************/ 05091 05092 typedef struct _CLIENTGETCHARSETINFOMSG { 05093 LCID lcid; 05094 CHARSETINFO cs; 05095 } CLIENTGETCHARSETINFOMSG; 05096 05097 #ifdef SENDSIDE 05098 BOOL xxxClientGetCharsetInfo( 05099 IN LCID lcid, 05100 OUT PCHARSETINFO pcs) 05101 { 05102 SETUP(CLIENTGETCHARSETINFO) 05103 05104 BEGINSEND(CLIENTGETSCHARSETINFO) 05105 05106 MSGDATA()->lcid = lcid; 05107 05108 MAKECALL(CLIENTGETCHARSETINFO); 05109 CHECKRETURN(); 05110 05111 OUTSTRUCT(pcs, CHARSETINFO); 05112 05113 TRACECALLBACK("ClientGetCharsetInfo"); 05114 ENDSEND(BOOL,0); 05115 } 05116 #endif // SENDSIDE 05117 05118 #ifdef RECVSIDE 05119 RECVCALL(ClientGetCharsetInfo, CLIENTGETCHARSETINFOMSG) 05120 { 05121 BEGINRECV(0, &pmsg->cs, sizeof(CHARSETINFO)); 05122 05123 // TCI_SRCLOCALE = 0x1000 05124 // Sundown: lcid value should be zero-extended in the TCI_SRCLOCALE case. 05125 retval = (DWORD)TranslateCharsetInfo((DWORD *)ULongToPtr( pmsg->lcid ), &pmsg->cs, TCI_SRCLOCALE); 05126 05127 ENDRECV(); 05128 } 05129 #endif // RECVSIDE 05130 05131 /**************************************************************************\ 05132 * ClientFreeDDEHandle 05133 * 05134 * 9-29-91 sanfords Created. 05135 \**************************************************************************/ 05136 05137 typedef struct _CLIENTFREEDDEHANDLEMSG { 05138 HANDLE hClient; 05139 DWORD flags; 05140 } CLIENTFREEDDEHANDLEMSG; 05141 05142 #ifdef SENDSIDE 05143 DWORD ClientFreeDDEHandle( 05144 IN HANDLE hClient, 05145 IN DWORD flags) 05146 { 05147 SETUP(CLIENTFREEDDEHANDLE) 05148 05149 BEGINSEND(CLIENTFREEDDEHANDLE) 05150 05151 MSGDATA()->hClient = hClient; 05152 MSGDATA()->flags = flags; 05153 05154 MAKECALL(CLIENTFREEDDEHANDLE); 05155 CHECKRETURN(); 05156 05157 TRACECALLBACK("ClientFreeDDEHandle"); 05158 ENDSEND(DWORD, 0); 05159 } 05160 #endif // SENDSIDE 05161 05162 05163 05164 #ifdef RECVSIDE 05165 RECVCALL(ClientFreeDDEHandle, CLIENTFREEDDEHANDLEMSG) 05166 { 05167 BEGINRECV(0, NULL, 0); 05168 _ClientFreeDDEHandle(CALLDATA(hClient), CALLDATA(flags)); 05169 ENDRECV(); 05170 } 05171 #endif // RECVSIDE 05172 05173 05174 05175 05176 /**************************************************************************\ 05177 * ClientGetDDEFlags 05178 * 05179 * This function is used to get a peek at the wStatus flags packed within 05180 * DDE handles - this could either be within the DdePack structure directly 05181 * or within the direct data handle given or referenced via the DdePack 05182 * structure. flags is used to figure out the right thing to do. 05183 * 05184 * 9-29-91 sanfords Created. 05185 \**************************************************************************/ 05186 05187 typedef struct _CLIENTGETDDEFLAGSMSG { 05188 HANDLE hClient; 05189 DWORD flags; 05190 } CLIENTGETDDEFLAGSMSG; 05191 05192 #ifdef SENDSIDE 05193 DWORD ClientGetDDEFlags( 05194 IN HANDLE hClient, 05195 IN DWORD flags) 05196 { 05197 SETUP(CLIENTGETDDEFLAGS) 05198 05199 BEGINSEND(CLIENTGETDDEFLAGS) 05200 05201 MSGDATA()->hClient = hClient; 05202 MSGDATA()->flags = flags; 05203 05204 MAKECALL(CLIENTGETDDEFLAGS); 05205 CHECKRETURN(); 05206 05207 TRACECALLBACK("ClientGetDDEFlags"); 05208 ENDSEND(DWORD, 0); 05209 } 05210 #endif // SENDSIDE 05211 05212 05213 05214 #ifdef RECVSIDE 05215 RECVCALL(ClientGetDDEFlags, CLIENTGETDDEFLAGSMSG) 05216 { 05217 BEGINRECV(0, NULL, 0); 05218 retval = _ClientGetDDEFlags(CALLDATA(hClient), CALLDATA(flags)); 05219 ENDRECV(); 05220 } 05221 #endif // RECVSIDE 05222 05223 05224 05225 /************************************************************************ 05226 * ClientCopyDDEIn1 05227 * 05228 * History: 05229 * 10-22-91 sanfords Created 05230 \***********************************************************************/ 05231 05232 typedef struct _CLIENTCOPYDDEIN1MSG { 05233 HANDLE hClient; // client side DDE handle - non-0 on initial call 05234 DWORD flags; 05235 } CLIENTCOPYDDEIN1MSG; 05236 05237 #ifdef SENDSIDE 05238 DWORD xxxClientCopyDDEIn1( 05239 HANDLE hClient, 05240 DWORD flags, 05241 PINTDDEINFO *ppi) 05242 { 05243 PINTDDEINFO pi; 05244 INTDDEINFO IntDdeInfo; 05245 05246 SETUP(CLIENTCOPYDDEIN1) 05247 05248 BEGINSEND(CLIENTCOPYDDEIN1) 05249 05250 retval = FAIL_POST; 05251 *ppi = NULL; 05252 MSGDATA()->hClient = hClient; 05253 MSGDATA()->flags = flags; 05254 05255 MAKECALL(CLIENTCOPYDDEIN1); 05256 CHECKRETURN(); 05257 05258 if (retval != DO_POST) { 05259 MSGERROR(); 05260 } 05261 05262 try { 05263 OUTSTRUCT(&IntDdeInfo, INTDDEINFO); 05264 05265 pi = (PINTDDEINFO)UserAllocPool( 05266 sizeof(INTDDEINFO) + IntDdeInfo.cbDirect + 05267 IntDdeInfo.cbIndirect, TAG_DDE); 05268 05269 if (pi != NULL) { 05270 *ppi = pi; 05271 *pi = IntDdeInfo; 05272 05273 if (IntDdeInfo.cbDirect) { 05274 RtlCopyMemory((PBYTE)pi + sizeof(INTDDEINFO), 05275 IntDdeInfo.pDirect, 05276 IntDdeInfo.cbDirect); 05277 } 05278 05279 if (IntDdeInfo.cbIndirect) { 05280 RtlCopyMemory((PBYTE)pi + sizeof(INTDDEINFO) + 05281 IntDdeInfo.cbDirect, 05282 IntDdeInfo.pIndirect, 05283 IntDdeInfo.cbIndirect); 05284 } 05285 05286 xxxClientCopyDDEIn2(pi); 05287 05288 } else { 05289 retval = FAILNOFREE_POST; 05290 } 05291 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 05292 if (pi != NULL) 05293 UserFreePool(pi); 05294 retval = FAILNOFREE_POST; 05295 MSGERROR(); 05296 } 05297 05298 TRACECALLBACK("ClientCopyDDEIn1"); 05299 ENDSEND(DWORD, retval); 05300 } 05301 #endif // SENDSIDE 05302 05303 #ifdef RECVSIDE 05304 RECVCALL(ClientCopyDDEIn1, CLIENTCOPYDDEIN1MSG) 05305 { 05306 INTDDEINFO IntDdeInfo; 05307 05308 BEGINRECV(0, &IntDdeInfo, sizeof(INTDDEINFO)); 05309 05310 IntDdeInfo.flags = CALLDATA(flags); 05311 retval = _ClientCopyDDEIn1(CALLDATA(hClient), &IntDdeInfo); 05312 05313 ENDRECV(); 05314 } 05315 #endif // RECVSIDE 05316 05317 05318 /************************************************************************ 05319 * ClientCopyDDEIn2 05320 * 05321 * History: 05322 * 9-3-91 sanfords Created 05323 \***********************************************************************/ 05324 05325 typedef struct _CLIENTCOPYDDEIN2MSG { 05326 INTDDEINFO IntDdeInfo; 05327 } CLIENTCOPYDDEIN2MSG; 05328 05329 #ifdef SENDSIDE 05330 BOOL xxxClientCopyDDEIn2( 05331 PINTDDEINFO pi) 05332 { 05333 SETUP(CLIENTCOPYDDEIN2) 05334 05335 BEGINSEND(CLIENTCOPYDDEIN2) 05336 05337 MSGDATA()->IntDdeInfo = *pi; 05338 05339 MAKECALL(CLIENTCOPYDDEIN2); 05340 CHECKRETURN(); 05341 05342 TRACECALLBACK("ClientCopyDDEIn2"); 05343 ENDSEND(BOOL, 0); 05344 } 05345 #endif // SENDSIDE 05346 05347 #ifdef RECVSIDE 05348 RECVCALL(ClientCopyDDEIn2, CLIENTCOPYDDEIN2MSG) 05349 { 05350 BEGINRECV(0, NULL, 0); 05351 05352 _ClientCopyDDEIn2(PCALLDATA(IntDdeInfo)); 05353 05354 ENDRECV(); 05355 } 05356 #endif // RECVSIDE 05357 05358 05359 05360 /************************************************************************ 05361 * ClientCopyDDEOut2 05362 * 05363 * History: 05364 * 10-22-91 sanfords Created 05365 \***********************************************************************/ 05366 05367 typedef struct _CLIENTCOPYDDEOUT2MSG { 05368 INTDDEINFO IntDdeInfo; 05369 } CLIENTCOPYDDEOUT2MSG; 05370 05371 #ifdef SENDSIDE 05372 DWORD xxxClientCopyDDEOut2( 05373 PINTDDEINFO pi) 05374 { 05375 SETUP(CLIENTCOPYDDEOUT2) 05376 05377 BEGINSEND(CLIENTCOPYDDEOUT2) 05378 05379 MSGDATA()->IntDdeInfo = *pi; 05380 05381 MAKECALL(CLIENTCOPYDDEOUT2); 05382 /* 05383 * This read is covered by a try/except in ClientCopyDDEOut1. 05384 */ 05385 pi->hDirect = MSGDATA()->IntDdeInfo.hDirect; 05386 CHECKRETURN(); 05387 05388 TRACECALLBACK("ClientCopyDDEOut2"); 05389 ENDSEND(DWORD, 0); 05390 } 05391 #endif // SENDSIDE 05392 05393 #ifdef RECVSIDE 05394 RECVCALL(ClientCopyDDEOut2, CLIENTCOPYDDEOUT2MSG) 05395 { 05396 BEGINRECV(0, NULL, 0); 05397 05398 retval = _ClientCopyDDEOut2(PCALLDATA(IntDdeInfo)); 05399 05400 ENDRECV(); 05401 } 05402 #endif // RECVSIDE 05403 05404 /************************************************************************ 05405 * ClientCopyDDEOut1 05406 * 05407 * History: 05408 * 10-22-91 sanfords Created 05409 \***********************************************************************/ 05410 05411 typedef struct _CLIENTCOPYDDEOUT1MSG { 05412 INTDDEINFO IntDdeInfo; 05413 } CLIENTCOPYDDEOUT1MSG; 05414 05415 #ifdef SENDSIDE 05416 HANDLE xxxClientCopyDDEOut1( 05417 PINTDDEINFO pi) 05418 { 05419 INTDDEINFO IntDdeInfo; 05420 05421 SETUP(CLIENTCOPYDDEOUT1) 05422 05423 BEGINSEND(CLIENTCOPYDDEOUT1) 05424 05425 MSGDATA()->IntDdeInfo = *pi; 05426 05427 MAKECALL(CLIENTCOPYDDEOUT1); 05428 CHECKRETURN(); 05429 05430 if (retval) { 05431 try { 05432 OUTSTRUCT(&IntDdeInfo, INTDDEINFO); 05433 05434 if (pi->cbDirect) { 05435 RtlCopyMemory(IntDdeInfo.pDirect, 05436 (PBYTE)pi + sizeof(INTDDEINFO), 05437 pi->cbDirect); 05438 } 05439 05440 if (pi->cbIndirect) { 05441 RtlCopyMemory(IntDdeInfo.pIndirect, 05442 (PBYTE)pi + sizeof(INTDDEINFO) + pi->cbDirect, 05443 pi->cbIndirect); 05444 } 05445 05446 if (IntDdeInfo.hDirect != NULL) { 05447 BOOL fSuccess = xxxClientCopyDDEOut2(&IntDdeInfo); 05448 if (fSuccess && IntDdeInfo.flags & XS_EXECUTE) { 05449 /* 05450 * In case value was changed by Execute Fixup. 05451 */ 05452 retval = (ULONG_PTR)IntDdeInfo.hDirect; 05453 } 05454 } 05455 *pi = IntDdeInfo; 05456 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 05457 retval = 0; 05458 MSGERROR(); 05459 } 05460 } 05461 05462 TRACECALLBACK("ClientCopyDDEOut1"); 05463 ENDSEND(HANDLE, 0); 05464 } 05465 #endif // SENDSIDE 05466 05467 05468 05469 #ifdef RECVSIDE 05470 RECVCALL(ClientCopyDDEOut1, CLIENTCOPYDDEOUT1MSG) 05471 { 05472 BEGINRECV(0, &pmsg->IntDdeInfo, sizeof(INTDDEINFO)); 05473 05474 retval = (ULONG_PTR)_ClientCopyDDEOut1(&pmsg->IntDdeInfo); 05475 05476 ENDRECV(); 05477 } 05478 #endif // RECVSIDE 05479 05480 05481 05482 /**************************************************************************\ 05483 * ClientEventCallback 05484 * 05485 * 11-11-91 sanfords Created 05486 \**************************************************************************/ 05487 05488 typedef struct _CLIENTEVENTCALLBACKMSG { 05489 CAPTUREBUF CaptureBuf; 05490 PVOID pcii; 05491 PVOID pep; 05492 } CLIENTEVENTCALLBACKMSG; 05493 05494 #ifdef SENDSIDE 05495 DWORD ClientEventCallback( 05496 IN PVOID pcii, 05497 IN PEVENT_PACKET pep) 05498 { 05499 DWORD cbCapture = pep->cbEventData + 05500 sizeof(EVENT_PACKET) - sizeof(DWORD); 05501 05502 SETUP(CLIENTEVENTCALLBACK) 05503 05504 BEGINSENDCAPTURE(CLIENTEVENTCALLBACK, 1, cbCapture, TRUE) 05505 05506 MSGDATA()->pcii = pcii; 05507 COPYBYTES(pep, cbCapture); 05508 05509 MAKECALLCAPTURE(CLIENTEVENTCALLBACK); 05510 CHECKRETURN(); 05511 05512 TRACECALLBACK("ClientEventCallback"); 05513 ENDSENDCAPTURE(DWORD,0); 05514 } 05515 #endif // SENDSIDE 05516 05517 #ifdef RECVSIDE 05518 RECVCALL(ClientEventCallback, CLIENTEVENTCALLBACKMSG) 05519 { 05520 BEGINRECV(0, NULL, 0); 05521 FIXUPPOINTERS(); 05522 05523 _ClientEventCallback(CALLDATA(pcii), (PEVENT_PACKET)FIXUP(pep)); 05524 05525 ENDRECV(); 05526 } 05527 #endif // RECVSIDE 05528 05529 /**************************************************************************\ 05530 * ClientGetDDEHookData 05531 * 05532 * 11-11-91 sanfords Created 05533 \**************************************************************************/ 05534 05535 typedef struct _CLIENTGETDDEHOOKDATAMSG { 05536 UINT message; 05537 LPARAM lParam; 05538 DDEML_MSG_HOOK_DATA dmhd; 05539 } CLIENTGETDDEHOOKDATAMSG; 05540 05541 #ifdef SENDSIDE 05542 DWORD ClientGetDDEHookData( 05543 IN UINT message, 05544 IN LPARAM lParam, 05545 OUT PDDEML_MSG_HOOK_DATA pdmhd) 05546 { 05547 SETUP(CLIENTGETDDEHOOKDATA) 05548 05549 BEGINSEND(CLIENTGETDDEHOOKDATA) 05550 05551 MSGDATA()->lParam = lParam; 05552 MSGDATA()->message = message; 05553 05554 MAKECALL(CLIENTGETDDEHOOKDATA); 05555 CHECKRETURN(); 05556 05557 OUTSTRUCT(pdmhd, DDEML_MSG_HOOK_DATA); 05558 05559 TRACECALLBACK("ClientGetDDEHookData"); 05560 ENDSEND(DWORD,0); 05561 } 05562 #endif // SENDSIDE 05563 05564 #ifdef RECVSIDE 05565 RECVCALL(ClientGetDDEHookData, CLIENTGETDDEHOOKDATAMSG) 05566 { 05567 BEGINRECV(0, &pmsg->dmhd, sizeof(DDEML_MSG_HOOK_DATA)); 05568 05569 _ClientGetDDEHookData(CALLDATA(message), CALLDATA(lParam), 05570 (PDDEML_MSG_HOOK_DATA)&pmsg->dmhd); 05571 05572 ENDRECV(); 05573 } 05574 #endif // RECVSIDE 05575 05576 /**************************************************************************\ 05577 * 05578 * 05579 * 22-Jul-1991 mikeke Created 05580 \**************************************************************************/ 05581 05582 typedef struct _CLIENTCHARTOWCHARMSG { 05583 WORD CodePage; 05584 WORD wch; 05585 } CLIENTCHARTOWCHARMSG; 05586 05587 #ifdef SENDSIDE 05588 WCHAR xxxClientCharToWchar( 05589 IN WORD CodePage, 05590 IN WORD wch) 05591 { 05592 SETUP(CLIENTCHARTOWCHAR) 05593 05594 BEGINSEND(CLIENTCHARTOWCHAR) 05595 05596 MSGDATA()->CodePage = CodePage; 05597 MSGDATA()->wch = wch; 05598 05599 MAKECALL(CLIENTCHARTOWCHAR); 05600 CHECKRETURN(); 05601 05602 TRACECALLBACK("ClientCharToWchar"); 05603 ENDSEND(WCHAR, L'_'); 05604 } 05605 #endif // SENDSIDE 05606 05607 #ifdef RECVSIDE 05608 RECVCALL(ClientCharToWchar, CLIENTCHARTOWCHARMSG) 05609 { 05610 char ach[2]; 05611 WCHAR wch = L'_'; 05612 05613 BEGINRECV(0, NULL, 0); 05614 05615 ach[0] = LOBYTE(CALLDATA(wch)); 05616 ach[1] = HIBYTE(CALLDATA(wch)); 05617 05618 MultiByteToWideChar( 05619 CALLDATA(CodePage), // CP_THREAD_ACP, 437, 850 etc. 05620 MB_PRECOMPOSED | MB_USEGLYPHCHARS, // visual map to precomposed 05621 ach, ach[1] ? 2 : 1, // source & length 05622 &wch, // destination 05623 1); // max poss. precomposed length 05624 05625 retval = (DWORD)wch; 05626 05627 ENDRECV(); 05628 } 05629 #endif // RECVSIDE 05630 05631 /**************************************************************************\ 05632 * 05633 * 05634 * 22-Jul-1991 mikeke Created 05635 \**************************************************************************/ 05636 05637 typedef struct _CLIENTFINDMNEMCHARMSG { 05638 CAPTUREBUF CaptureBuf; 05639 UNICODE_STRING strSrc; 05640 WCHAR ch; 05641 BOOL fFirst; 05642 BOOL fPrefix; 05643 } CLIENTFINDMNEMCHARMSG; 05644 05645 #ifdef SENDSIDE 05646 int xxxClientFindMnemChar( 05647 IN PUNICODE_STRING pstrSrc, 05648 IN WCHAR ch, 05649 IN BOOL fFirst, 05650 IN BOOL fPrefix) 05651 { 05652 SETUP(CLIENTFINDMNEMCHAR) 05653 05654 BEGINSENDCAPTURE(CLIENTFINDMNEMCHAR, 1, pstrSrc->MaximumLength, TRUE) 05655 05656 MSGDATA()->ch = ch; 05657 MSGDATA()->fFirst = fFirst; 05658 MSGDATA()->fPrefix = fPrefix; 05659 COPYSTRING(strSrc); 05660 05661 MAKECALLCAPTURE(CLIENTFINDMNEMCHAR); 05662 CHECKRETURN(); 05663 05664 TRACECALLBACK("ClientFindMnemChar"); 05665 ENDSENDCAPTURE(BOOL,0); 05666 } 05667 #endif // SENDSIDE 05668 05669 #ifdef RECVSIDE 05670 RECVCALL(ClientFindMnemChar, CLIENTFINDMNEMCHARMSG) 05671 { 05672 BEGINRECV(0, NULL, 0); 05673 FIXUPPOINTERS(); 05674 05675 retval = (DWORD)FindMnemChar((LPWSTR)FIXUPSTRING(strSrc), 05676 CALLDATA(ch), CALLDATA(fFirst), CALLDATA(fPrefix)); 05677 05678 ENDRECV(); 05679 } 05680 #endif // RECVSIDE 05681 05682 /**************************************************************************\ 05683 * xxxClientPSMTextOut 05684 * 05685 * Called when a client-side LanguagePack (LPK) is installed 05686 * 05687 * 18-Sep-1996 GregoryW Created 05688 * 11-Dec-1997 SamerA Calling LPK with user-mode accessible DC 05689 \**************************************************************************/ 05690 05691 typedef struct _CLIENTPSMTEXTOUTMSG { 05692 CAPTUREBUF CaptureBuf; 05693 UNICODE_STRING strSrc; 05694 HDC hdc; 05695 int xLeft; 05696 int yTop; 05697 int cch; 05698 DWORD dwFlags; 05699 } CLIENTPSMTEXTOUTMSG; 05700 05701 #ifdef SENDSIDE 05702 void xxxClientPSMTextOut( 05703 IN HDC hdc, 05704 IN int xLeft, 05705 IN int yTop, 05706 IN PUNICODE_STRING pstrSrc, 05707 IN int cch, 05708 IN DWORD dwFlags) 05709 { 05710 SETUPDC(CLIENTPSMTEXTOUT) 05711 05712 /* 05713 * Make sure this routine is called when a client LanguagePack (LPK) 05714 * is installed. 05715 */ 05716 UserAssert(CALL_LPK(PtiCurrentShared())); 05717 05718 BEGINSENDCAPTUREVOIDDC(CLIENTPSMTEXTOUT, 1, pstrSrc->MaximumLength, TRUE) 05719 05720 #if DBG 05721 CheckPublicDC ("xxxClientPSMTextOut: Public DC passed to LPK. hdcUse=%lX", hdcUse); 05722 #endif 05723 05724 MSGDATA()->hdc = hdcUse; 05725 MSGDATA()->xLeft = xLeft; 05726 MSGDATA()->yTop = yTop; 05727 MSGDATA()->cch = cch; 05728 MSGDATA()->dwFlags = dwFlags; 05729 COPYSTRING(strSrc); 05730 05731 MAKECALLCAPTUREDC(CLIENTPSMTEXTOUT); 05732 05733 CHECKRETURN(); 05734 05735 TRACECALLBACK("ClientPSMTextOut"); 05736 ENDSENDCAPTUREVOIDDC(); 05737 } 05738 #endif // SENDSIDE 05739 05740 #ifdef RECVSIDE 05741 RECVCALL(ClientPSMTextOut, CLIENTPSMTEXTOUTMSG) 05742 { 05743 BEGINRECV(0, NULL, 0); 05744 FIXUPPOINTERS(); 05745 05746 PSMTextOut(CALLDATA(hdc), CALLDATA(xLeft), CALLDATA(yTop), 05747 (LPWSTR)FIXUPSTRING(strSrc), CALLDATA(cch), CALLDATA(dwFlags)); 05748 05749 retval = 0; 05750 ENDRECV(); 05751 } 05752 #endif // RECVSIDE 05753 05754 /**************************************************************************\ 05755 * xxxClientLpkDrawTextEx 05756 * 05757 * Called when a client-side LanguagePack (LPK) is installed 05758 * 05759 * 18-Sep-1996 GregoryW Created 05760 * 11-Dec-1997 SamerA Calling LPK with user-mode accessible DC 05761 \**************************************************************************/ 05762 05763 typedef struct _CLIENTLPKDRAWTEXTEXMSG { 05764 CAPTUREBUF CaptureBuf; 05765 UNICODE_STRING strSrc; 05766 HDC hdc; 05767 int xLeft; 05768 int yTop; 05769 int nCount; 05770 BOOL fDraw; 05771 UINT wFormat; 05772 DRAWTEXTDATA DrawInfo; 05773 UINT bAction; 05774 int iCharSet; 05775 } CLIENTLPKDRAWTEXTEXMSG; 05776 05777 #ifdef SENDSIDE 05778 int xxxClientLpkDrawTextEx( 05779 IN HDC hdc, 05780 IN int xLeft, 05781 IN int yTop, 05782 IN LPCWSTR lpsz, 05783 IN int nCount, 05784 IN BOOL fDraw, 05785 IN UINT wFormat, 05786 IN LPDRAWTEXTDATA lpDrawInfo, 05787 IN UINT bAction, 05788 IN int iCharSet) 05789 { 05790 SETUPDC(CLIENTLPKDRAWTEXTEX) 05791 UNICODE_STRING strSrc; 05792 UNICODE_STRING *pstrSrc = &strSrc; 05793 05794 /* 05795 * Make sure this routine is called when a client LanguagePack (LPK) 05796 * is installed. 05797 */ 05798 UserAssert(CALL_LPK(PtiCurrentShared())); 05799 05800 05801 RtlInitUnicodeString(pstrSrc, lpsz); 05802 05803 BEGINSENDCAPTUREDC(CLIENTLPKDRAWTEXTEX, 1, pstrSrc->MaximumLength, TRUE) 05804 05805 #if DBG 05806 CheckPublicDC ("xxxClientLpkDrawTextEx: Public DC passed to LPK. hdcUse=%lX", hdcUse); 05807 #endif 05808 05809 MSGDATA()->hdc = hdcUse; 05810 MSGDATA()->xLeft = xLeft; 05811 MSGDATA()->yTop = yTop; 05812 MSGDATA()->nCount = nCount; 05813 MSGDATA()->fDraw = fDraw; 05814 MSGDATA()->wFormat = wFormat; 05815 MSGDATA()->DrawInfo = *lpDrawInfo; 05816 MSGDATA()->bAction = bAction; 05817 MSGDATA()->iCharSet = iCharSet; 05818 COPYSTRING(strSrc); 05819 05820 MAKECALLCAPTUREDC(CLIENTLPKDRAWTEXTEX); 05821 05822 CHECKRETURN(); 05823 05824 TRACECALLBACK("ClientLpkDrawTextEx"); 05825 ENDSENDCAPTUREDC(int, 0); 05826 } 05827 #endif // SENDSIDE 05828 05829 #ifdef RECVSIDE 05830 RECVCALL(ClientLpkDrawTextEx, CLIENTLPKDRAWTEXTEXMSG) 05831 { 05832 BEGINRECV(0, NULL, 0); 05833 FIXUPPOINTERS(); 05834 05835 retval = (*fpLpkDrawTextEx)(CALLDATA(hdc), CALLDATA(xLeft), CALLDATA(yTop), 05836 (LPWSTR)FIXUPSTRING(strSrc), CALLDATA(nCount), CALLDATA(fDraw), 05837 CALLDATA(wFormat), PCALLDATA(DrawInfo), CALLDATA(bAction), CALLDATA(iCharSet)); 05838 05839 ENDRECV(); 05840 } 05841 #endif // RECVSIDE 05842 05843 /**************************************************************************\ 05844 * xxxClientExtTextOutW 05845 * 05846 * Called when a client-side LanguagePack (LPK) is installed 05847 * 05848 * 26-Jan-1997 GregoryW Created 05849 * 11-Dec-1997 SamerA Calling LPK with user-mode accessible DC 05850 \**************************************************************************/ 05851 05852 typedef struct _CLIENTEXTTEXTOUTW { 05853 CAPTUREBUF CaptureBuf; 05854 UNICODE_STRING strSrc; 05855 HDC hdc; 05856 int x; 05857 int y; 05858 int flOpts; 05859 RECT rcl; 05860 UINT cwc; 05861 BOOL fNullRect; 05862 } CLIENTEXTTEXTOUTWMSG; 05863 05864 #ifdef SENDSIDE 05865 BOOL xxxClientExtTextOutW( 05866 IN HDC hdc, 05867 IN int x, 05868 IN int y, 05869 IN int flOpts, 05870 IN RECT *prcl, 05871 IN LPCWSTR pwsz, 05872 IN UINT cwc, 05873 IN INT *pdx) 05874 { 05875 SETUPDC(CLIENTEXTTEXTOUTW) 05876 UNICODE_STRING strSrc; 05877 UNICODE_STRING *pstrSrc = &strSrc; 05878 05879 /* 05880 * Make sure this routine is called when a client LanguagePack (LPK) 05881 * is installed. 05882 */ 05883 UserAssert(CALL_LPK(PtiCurrentShared())); 05884 05885 05886 RtlInitUnicodeString(pstrSrc, pwsz); 05887 05888 BEGINSENDCAPTUREDC(CLIENTEXTTEXTOUTW, 1, pstrSrc->MaximumLength, TRUE) 05889 05890 #if DBG 05891 CheckPublicDC ("xxxClientExtTextOutW: Public DC passed to LPK. hdcUse=%lX", hdcUse); 05892 #endif 05893 05894 MSGDATA()->hdc = hdcUse; 05895 MSGDATA()->x = x; 05896 MSGDATA()->y = y; 05897 MSGDATA()->flOpts = flOpts; 05898 /* In order not to pass a NULL ptr */ 05899 if( prcl ){ 05900 MSGDATA()->rcl = *prcl; 05901 MSGDATA()->fNullRect=TRUE; 05902 } 05903 else { 05904 MSGDATA()->fNullRect=FALSE; 05905 } 05906 MSGDATA()->cwc = cwc; 05907 COPYSTRING(strSrc); 05908 05909 MAKECALLCAPTUREDC(CLIENTEXTTEXTOUTW); 05910 05911 CHECKRETURN(); 05912 05913 TRACECALLBACK("ClientExtTextOutW"); 05914 ENDSENDCAPTUREDC(BOOL, 0); 05915 05916 UNREFERENCED_PARAMETER(pdx); 05917 } 05918 #endif // SENDSIDE 05919 05920 #ifdef RECVSIDE 05921 RECVCALL(ClientExtTextOutW, CLIENTEXTTEXTOUTWMSG) 05922 { 05923 BEGINRECV(0, NULL, 0); 05924 FIXUPPOINTERS(); 05925 05926 retval = ExtTextOutW(CALLDATA(hdc), CALLDATA(x), CALLDATA(y), 05927 CALLDATA(flOpts), (CALLDATA(fNullRect)) ? PCALLDATA(rcl) : NULL , (LPWSTR)FIXUPSTRING(strSrc), 05928 CALLDATA(cwc), NULL); 05929 05930 ENDRECV(); 05931 } 05932 #endif // RECVSIDE 05933 05934 /**************************************************************************\ 05935 * xxxClientGetTextExtentPointW 05936 * 05937 * Called when a client-side LanguagePack (LPK) is installed 05938 * 05939 * 06-Feb-1997 GregoryW Created 05940 * 19-Jan-1998 SamerA EIP_ERROR if a public DC is passed other than hdcGray 05941 \**************************************************************************/ 05942 05943 typedef struct _CLIENTGETTEXTEXTENTPOINTW { 05944 CAPTUREBUF CaptureBuf; 05945 UNICODE_STRING strSrc; 05946 HDC hdc; 05947 int cch; 05948 SIZE size; 05949 } CLIENTGETTEXTEXTENTPOINTWMSG; 05950 05951 #ifdef SENDSIDE 05952 BOOL xxxClientGetTextExtentPointW( 05953 IN HDC hdc, 05954 IN LPCWSTR lpstr, 05955 IN int cch, 05956 OUT PSIZE psize) 05957 { 05958 SETUPDC(CLIENTGETTEXTEXTENTPOINTW) 05959 UNICODE_STRING strSrc; 05960 UNICODE_STRING *pstrSrc = &strSrc; 05961 05962 /* 05963 * Make sure this routine is called when a client LanguagePack (LPK) 05964 * is installed. 05965 */ 05966 UserAssert(CALL_LPK(PtiCurrentShared())); 05967 05968 RtlInitUnicodeString(pstrSrc, lpstr); 05969 05970 BEGINSENDCAPTUREDC(CLIENTGETTEXTEXTENTPOINTW, 1, pstrSrc->MaximumLength, TRUE) 05971 05972 #if DBG 05973 CheckPublicDC ("xxxGetTextExtentPointW: Public DC passed to LPK. hdcUse=%lX", hdcUse); 05974 #endif 05975 05976 MSGDATA()->hdc = hdcUse; 05977 MSGDATA()->cch = cch; 05978 COPYSTRING(strSrc); 05979 05980 MAKECALLCAPTUREDC(CLIENTGETTEXTEXTENTPOINTW); 05981 05982 CHECKRETURN(); 05983 05984 OUTSTRUCT(psize, SIZE); 05985 05986 TRACECALLBACK("ClientGetTextExtentPointW"); 05987 ENDSENDCAPTUREDC(BOOL, 0); 05988 05989 } 05990 #endif // SENDSIDE 05991 05992 #ifdef RECVSIDE 05993 RECVCALL(ClientGetTextExtentPointW, CLIENTGETTEXTEXTENTPOINTWMSG) 05994 { 05995 BEGINRECV(0, &pmsg->size, sizeof(SIZE)); 05996 FIXUPPOINTERS(); 05997 05998 retval = GetTextExtentPointW(CALLDATA(hdc), (LPWSTR)FIXUPSTRING(strSrc), 05999 CALLDATA(cch), PCALLDATA(size)); 06000 06001 ENDRECV(); 06002 } 06003 #endif // RECVSIDE 06004 06005 /**************************************************************************\ 06006 * 06007 * 06008 * 22-Jul-1991 mikeke Created 06009 \**************************************************************************/ 06010 06011 typedef struct _CLIENTADDFONTRESOURCEWMSG { 06012 CAPTUREBUF CaptureBuf; 06013 UNICODE_STRING strSrc; 06014 DWORD dwFlags; 06015 DESIGNVECTOR dv; 06016 } CLIENTADDFONTRESOURCEWMSG; 06017 06018 #ifdef SENDSIDE 06019 int xxxClientAddFontResourceW( 06020 IN PUNICODE_STRING pstrSrc, 06021 IN DWORD dwFlags, 06022 IN DESIGNVECTOR *pdv) 06023 { 06024 SETUP(CLIENTADDFONTRESOURCEW) 06025 06026 BEGINSENDCAPTURE(CLIENTADDFONTRESOURCEW, 1, pstrSrc->MaximumLength, TRUE) 06027 06028 COPYSTRING(strSrc); 06029 MSGDATA()->dwFlags = dwFlags; 06030 06031 if (pdv && pdv->dvNumAxes) { 06032 MSGDATA()->dv = *pdv; 06033 } else { 06034 MSGDATA()->dv.dvNumAxes = 0; 06035 } 06036 06037 MAKECALLCAPTURE(CLIENTADDFONTRESOURCEW); 06038 CHECKRETURN(); 06039 06040 TRACECALLBACK("ClientAddFontResourceW"); 06041 ENDSENDCAPTURE(int,0); 06042 } 06043 #endif // SENDSIDE 06044 06045 #ifdef RECVSIDE 06046 06047 06048 RECVCALL(ClientAddFontResourceW, CLIENTADDFONTRESOURCEWMSG) 06049 { 06050 DWORD AddFont(LPWSTR, DWORD, DESIGNVECTOR*); 06051 06052 BEGINRECV(0, NULL, 0); 06053 FIXUPPOINTERS(); 06054 06055 retval = GdiAddFontResourceW((LPWSTR)FIXUPSTRING(strSrc), 06056 CALLDATA(dwFlags), CALLDATA(dv).dvNumAxes ? &CALLDATA(dv) : NULL); 06057 06058 ENDRECV(); 06059 } 06060 #endif // RECVSIDE 06061 06062 06063 06064 /******************************Public*Routine******************************\ 06065 * 06066 * FontSweep() 06067 * 06068 * History: 06069 * 23-Oct-1995 -by- Bodin Dresevic [BodinD] 06070 * Wrote it. 06071 \**************************************************************************/ 06072 06073 06074 06075 #ifdef SENDSIDE 06076 VOID ClientFontSweep(VOID) 06077 { 06078 PVOID p; 06079 ULONG cb; 06080 06081 LeaveCrit(); 06082 KeUserModeCallback( 06083 FI_CLIENTFONTSWEEP, 06084 NULL, 06085 0, 06086 &p, 06087 &cb); 06088 EnterCrit(); 06089 return; 06090 } 06091 #endif // SENDSIDE 06092 06093 #ifdef RECVSIDE 06094 06095 DWORD __ClientFontSweep( 06096 PVOID p) 06097 { 06098 UNREFERENCED_PARAMETER(p); 06099 vFontSweep(); 06100 return NtCallbackReturn(NULL, 0, STATUS_SUCCESS); 06101 } 06102 #endif // RECVSIDE 06103 06104 06105 /******************************Public*Routine******************************\ 06106 * 06107 * VOID ClientLoadLocalT1Fonts(VOID) 06108 * very similar to above, only done for t1 fonts 06109 * 06110 * History: 06111 * 25-Apr-1996 -by- Bodin Dresevic [BodinD] 06112 * Wrote it. 06113 \**************************************************************************/ 06114 06115 06116 06117 #ifdef SENDSIDE 06118 VOID ClientLoadLocalT1Fonts(VOID) 06119 { 06120 PVOID p; 06121 ULONG cb; 06122 06123 LeaveCrit(); 06124 KeUserModeCallback( 06125 FI_CLIENTLOADLOCALT1FONTS, 06126 NULL, 06127 0, 06128 &p, 06129 &cb); 06130 EnterCrit(); 06131 return; 06132 } 06133 #endif // SENDSIDE 06134 06135 #ifdef RECVSIDE 06136 06137 06138 06139 DWORD __ClientLoadLocalT1Fonts( 06140 PVOID p) 06141 { 06142 UNREFERENCED_PARAMETER(p); 06143 vLoadLocalT1Fonts(); 06144 return NtCallbackReturn(NULL, 0, STATUS_SUCCESS); 06145 } 06146 #endif // RECVSIDE 06147 06148 06149 06150 /******************************Public*Routine******************************\ 06151 * 06152 * VOID ClientLoadRemoteT1Fonts(VOID) 06153 * very similar to above, only done for t1 fonts 06154 * 06155 * History: 06156 * 25-Apr-1996 -by- Bodin Dresevic [BodinD] 06157 * Wrote it. 06158 \**************************************************************************/ 06159 06160 06161 06162 #ifdef SENDSIDE 06163 VOID ClientLoadRemoteT1Fonts(VOID) 06164 { 06165 PVOID p; 06166 ULONG cb; 06167 06168 LeaveCrit(); 06169 KeUserModeCallback( 06170 FI_CLIENTLOADREMOTET1FONTS, 06171 NULL, 06172 0, 06173 &p, 06174 &cb); 06175 EnterCrit(); 06176 return; 06177 } 06178 #endif // SENDSIDE 06179 06180 #ifdef RECVSIDE 06181 06182 06183 06184 DWORD __ClientLoadRemoteT1Fonts( 06185 PVOID p) 06186 { 06187 UNREFERENCED_PARAMETER(p); 06188 vLoadRemoteT1Fonts(); 06189 return NtCallbackReturn(NULL, 0, STATUS_SUCCESS); 06190 } 06191 #endif // RECVSIDE 06192 06193 /**************************************************************************\ 06194 * pppUserModeCallback 06195 * 06196 * Same as xxxUserModeCallback except not leaving/re-entering critical section 06197 * 06198 * 12/9/97 LingyunW Copied from xxxUserModeCallback 06199 \**************************************************************************/ 06200 #ifdef SENDSIDE 06201 NTSTATUS pppUserModeCallback (ULONG uApi, PVOID pIn, ULONG cbIn, PVOID pOut, ULONG cbOut) 06202 { 06203 NTSTATUS Status; 06204 PVOID pLocalOut; 06205 ULONG cbLocalOut; 06206 06207 /* 06208 * Call the client 06209 */ 06210 Status = KeUserModeCallback(uApi, pIn, cbIn, &pLocalOut, &cbLocalOut); 06211 06212 /* 06213 * If it failed, bail 06214 */ 06215 if (!NT_SUCCESS(Status)) { 06216 return Status; 06217 } 06218 06219 /* 06220 * If we didn't get the right amount of data, fail. 06221 */ 06222 if (cbLocalOut != cbOut) { 06223 RIPMSG3(RIP_WARNING, "pppUserModeCallback: uAPi: %#lx cbOut: %#lx cbLocalOut: %#lx", 06224 uApi, cbOut, cbLocalOut); 06225 return STATUS_UNSUCCESSFUL; 06226 } 06227 06228 /* 06229 * If we were expecting some data, copy it. 06230 */ 06231 if (cbOut != 0) { 06232 try { 06233 ProbeForRead(pLocalOut, cbLocalOut, sizeof(DWORD)); 06234 RtlCopyMemory(pOut, pLocalOut, cbLocalOut); 06235 } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { 06236 RIPMSG2(RIP_WARNING, "pppUserModeCallback: uAPi: %#lx Exception: %#lx", uApi, GetExceptionCode()); 06237 Status = STATUS_UNSUCCESSFUL; 06238 } 06239 } 06240 06241 return Status; 06242 } 06243 #endif // SENDSIDE 06244 06245 /******************************Public*Routine******************************\ 06246 * ClientPrinterThunk 06247 * 06248 * Callback used as the kernel-to-user transport layer. 06249 * 06250 * Note: User critical section is not held by the caller. 06251 * 06252 * History: 06253 * 22-Jun-1997 -by- Gilman Wong [gilmanw] 06254 * 11/13/97 -by- Lingyun Wang [lingyunw] clean up 06255 * 06256 * Wrote it. 06257 \**************************************************************************/ 06258 06259 #define CLIENTPRINTERTHUNKMSG UMTHDR 06260 06261 #ifdef SENDSIDE 06262 DWORD ClientPrinterThunk(PVOID pvIn, ULONG cjIn, PVOID pvOut, ULONG cjOut) 06263 { 06264 NTSTATUS Status; 06265 06266 /* 06267 * (Temporarly..) we return failure if we are holding USERK's crit section 06268 */ 06269 if (ExIsResourceAcquiredExclusiveLite(gpresUser) 06270 || (ExIsResourceAcquiredSharedLite(gpresUser) != 0)) { 06271 RIPMSG0(RIP_ERROR, "ClientPrinterThunk: Holding USERK critical section!"); 06272 return 0xffffffff; 06273 } 06274 06275 /* 06276 * The pvIn buffer must have at least a CLIENTPRINTERTHUNK header. 06277 */ 06278 UserAssertMsg1(cjIn >= sizeof(CLIENTPRINTERTHUNKMSG), "ClientPrinterThunk: incorrect cjIn:%#lx", cjIn); 06279 06280 /* 06281 * Set the private cjOut. The receive-side uses this to allocate 06282 * a return buffer. 06283 */ 06284 ((CLIENTPRINTERTHUNKMSG *) pvIn)->ulReserved1 = cjOut; 06285 ((CLIENTPRINTERTHUNKMSG *) pvIn)->ulReserved2 = 0; 06286 06287 06288 /* 06289 * Do the callback. 06290 */ 06291 Status = pppUserModeCallback(FI_CLIENTPRINTERTHUNK, pvIn, cjIn, pvOut, cjOut); 06292 06293 return (NT_SUCCESS(Status) ? 0 : 0xFFFFFFFF); 06294 } 06295 #endif // SENDSIDE 06296 06297 #ifdef RECVSIDE 06298 DWORD __ClientPrinterThunk(CLIENTPRINTERTHUNKMSG *pMsg) 06299 { 06300 PVOID pv; 06301 ULONG aul[526]; 06302 NTSTATUS Status; 06303 06304 /* 06305 * Check that the local buffer is big enough. 06306 */ 06307 if (pMsg->ulReserved1 <= sizeof(aul)) { 06308 pv = (PVOID) aul; 06309 /* 06310 * Call GDI to process command. 06311 */ 06312 if (GdiPrinterThunk((UMTHDR *) pMsg, pv, pMsg->ulReserved1) != GPT_ERROR) { 06313 Status = STATUS_SUCCESS; 06314 } else { 06315 RIPMSG0(RIP_WARNING, "ClientPrinterThunk failed"); 06316 Status = STATUS_UNSUCCESSFUL; 06317 } 06318 } else { 06319 RIPMSG0(RIP_WARNING, "ClientPrinterThunk: buffer too big!"); 06320 Status = STATUS_NO_MEMORY; 06321 } 06322 06323 06324 /* 06325 * Return to kernel. 06326 */ 06327 if (NT_SUCCESS(Status)) { 06328 return UserCallbackReturn(pv, pMsg->ulReserved1, Status); 06329 } else { 06330 return UserCallbackReturn(NULL, 0, Status); 06331 } 06332 } 06333 #endif // RECVSIDE 06334 06335 /**************************************************************************\ 06336 * 06337 * 06338 * 22-Jul-1991 mikeke Created 06339 \**************************************************************************/ 06340 06341 #ifdef SENDSIDE 06342 VOID ClientNoMemoryPopup(VOID) 06343 { 06344 PVOID p; 06345 ULONG cb; 06346 06347 LeaveCrit(); 06348 KeUserModeCallback( 06349 FI_CLIENTNOMEMORYPOPUP, 06350 NULL, 06351 0, 06352 &p, 06353 &cb); 06354 EnterCrit(); 06355 return; 06356 } 06357 #endif // SENDSIDE 06358 06359 #ifdef RECVSIDE 06360 06361 DWORD __ClientNoMemoryPopup( 06362 PVOID p) 06363 { 06364 WCHAR szNoMem[200]; 06365 06366 UNREFERENCED_PARAMETER(p); 06367 06368 if (LoadStringW(hmodUser, STR_NOMEMBITMAP, szNoMem, 06369 sizeof(szNoMem) / sizeof(WCHAR))) { 06370 MessageBoxW(GetActiveWindow(), szNoMem, NULL, MB_OK); 06371 } 06372 06373 return NtCallbackReturn(NULL, 0, STATUS_SUCCESS); 06374 } 06375 #endif // RECVSIDE 06376 06377 /**************************************************************************\ 06378 * ClientThreadSetup 06379 * 06380 * Callback to the client to perform thread initialization. 06381 * 06382 * 04-07-95 JimA Created. 06383 \**************************************************************************/ 06384 06385 #ifdef SENDSIDE 06386 NTSTATUS ClientThreadSetup(VOID) 06387 { 06388 PVOID p; 06389 ULONG cb; 06390 NTSTATUS Status; 06391 06392 LeaveCrit(); 06393 Status = KeUserModeCallback( 06394 FI_CLIENTTHREADSETUP, 06395 NULL, 06396 0, 06397 &p, 06398 &cb); 06399 EnterCrit(); 06400 return Status; 06401 } 06402 #endif // SENDSIDE 06403 06404 #ifdef RECVSIDE 06405 DWORD __ClientThreadSetup( 06406 PVOID p) 06407 { 06408 BOOL fSuccess; 06409 BOOL ClientThreadSetup(VOID); 06410 06411 UNREFERENCED_PARAMETER(p); 06412 06413 fSuccess = ClientThreadSetup(); 06414 return NtCallbackReturn(NULL, 0, 06415 fSuccess ? STATUS_SUCCESS : STATUS_UNSUCCESSFUL); 06416 } 06417 #endif // RECVSIDE 06418 06419 /**************************************************************************\ 06420 * ClientDeliverUserApc 06421 * 06422 * Callback to the client to handle a user APC. This is needed to 06423 * ensure that a thread will exit promptly when terminated. 06424 * 06425 * 08-12-95 JimA Created. 06426 \**************************************************************************/ 06427 06428 #ifdef SENDSIDE 06429 VOID ClientDeliverUserApc(VOID) 06430 { 06431 PVOID p; 06432 ULONG cb; 06433 06434 LeaveCrit(); 06435 KeUserModeCallback( 06436 FI_CLIENTDELIVERUSERAPC, 06437 NULL, 06438 0, 06439 &p, 06440 &cb); 06441 EnterCrit(); 06442 } 06443 #endif // SENDSIDE 06444 06445 #ifdef RECVSIDE 06446 DWORD __ClientDeliverUserApc( 06447 PVOID p) 06448 { 06449 UNREFERENCED_PARAMETER(p); 06450 return NtCallbackReturn(NULL, 0, STATUS_SUCCESS); 06451 } 06452 #endif // RECVSIDE 06453 06454 06455 /**************************************************************************\ 06456 * ClientImmLoadLayout 06457 * 06458 * 29-Jan-1996 wkwok Created 06459 \**************************************************************************/ 06460 06461 typedef struct _CLIENTIMMLOADLAYOUTMSG { 06462 HKL hKL; 06463 } CLIENTIMMLOADLAYOUTMSG; 06464 06465 #ifdef SENDSIDE 06466 BOOL ClientImmLoadLayout( 06467 IN HKL hKL, 06468 OUT PIMEINFOEX piiex) 06469 { 06470 SETUP(CLIENTIMMLOADLAYOUT) 06471 06472 BEGINSEND(CLIENTIMMLOADLAYOUT) 06473 06474 MSGDATA()->hKL = hKL; 06475 06476 MAKECALL(CLIENTIMMLOADLAYOUT); 06477 CHECKRETURN(); 06478 06479 if (retval) 06480 OUTSTRUCT(piiex, IMEINFOEX); 06481 06482 TRACECALLBACK("ClientImmLoadLayout"); 06483 ENDSEND(BOOL, 0); 06484 } 06485 #endif // SENDSIDE 06486 06487 #ifdef RECVSIDE 06488 RECVCALL(ClientImmLoadLayout, CLIENTIMMLOADLAYOUTMSG) 06489 { 06490 IMEINFOEX iiex; 06491 06492 BEGINRECV(0, &iiex, sizeof(iiex)); 06493 06494 retval = fpImmLoadLayout(CALLDATA(hKL), &iiex); 06495 06496 ENDRECV(); 06497 } 06498 #endif // RECVSIDE 06499 06500 /**************************************************************************\ 06501 * ClientImmProcessKey 06502 * 06503 * 03-Mar-1996 TakaoK Created 06504 \**************************************************************************/ 06505 06506 typedef struct _CLIENTIMMPROCESSKEYMSG { 06507 HWND hWnd; 06508 HKL hkl; 06509 UINT uVKey; 06510 LPARAM lParam; 06511 DWORD dwHotKeyID; 06512 } CLIENTIMMPROCESSKEYMSG; 06513 06514 #ifdef SENDSIDE 06515 DWORD ClientImmProcessKey( 06516 IN HWND hWnd, 06517 IN HKL hkl, 06518 IN UINT uVKey, 06519 IN LPARAM lParam, 06520 IN DWORD dwHotKeyID) 06521 { 06522 SETUP(CLIENTIMMPROCESSKEY) 06523 06524 UserAssert(IS_IME_ENABLED()); 06525 06526 BEGINSEND(CLIENTIMMPROCESSKEY) 06527 06528 MSGDATA()->hWnd = hWnd, 06529 MSGDATA()->hkl = hkl; 06530 MSGDATA()->uVKey = uVKey; 06531 MSGDATA()->lParam = lParam; 06532 MSGDATA()->dwHotKeyID = dwHotKeyID; 06533 06534 MAKECALL(CLIENTIMMPROCESSKEY); 06535 CHECKRETURN(); 06536 06537 TRACECALLBACK("ClientImmProcessKey"); 06538 ENDSEND(DWORD, 0); 06539 } 06540 #endif // SENDSIDE 06541 06542 #ifdef RECVSIDE 06543 RECVCALL(ClientImmProcessKey, CLIENTIMMPROCESSKEYMSG) 06544 { 06545 BEGINRECV(0, NULL, 0); 06546 06547 retval = fpImmProcessKey(CALLDATA(hWnd), 06548 CALLDATA(hkl), 06549 CALLDATA(uVKey), 06550 CALLDATA(lParam), 06551 CALLDATA(dwHotKeyID)); 06552 06553 ENDRECV(); 06554 } 06555 #endif // RECVSIDE 06556 06557 /**************************************************************************\ 06558 * fnIMECONTROL 06559 * 06560 * 22-Apr-1996 wkwok Created 06561 \**************************************************************************/ 06562 06563 typedef struct _FNIMECONTROL { 06564 CAPTUREBUF CaptureBuf; 06565 PWND pwnd; 06566 UINT msg; 06567 WPARAM wParam; 06568 union { 06569 PCANDIDATEFORM pCandForm; 06570 PCOMPOSITIONFORM pCompForm; 06571 PLOGFONTA pLogFontA; 06572 PLOGFONTW pLogFontW; 06573 PSOFTKBDDATA pSoftKbdData; 06574 LPARAM lParam; 06575 } u; 06576 ULONG_PTR xParam; 06577 PROC xpfnProc; 06578 PBYTE pOutput; 06579 DWORD cbOutput; 06580 } FNIMECONTROLMSG; 06581 06582 #ifdef SENDSIDE 06583 void CopyLogFontAtoW( 06584 PLOGFONTW pdest, 06585 PLOGFONTA psrc) 06586 { 06587 LPSTR lpstrFont = (LPSTR)(&psrc->lfFaceName); 06588 LPWSTR lpstrFontW = (LPWSTR)(&pdest->lfFaceName); 06589 06590 memcpy((LPBYTE)pdest, psrc, sizeof(LOGFONTA) - LF_FACESIZE); 06591 memset(pdest->lfFaceName, 0, LF_FACESIZE * sizeof(WCHAR)); 06592 MBToWCS(lpstrFont, -1, &lpstrFontW, LF_FACESIZE, FALSE); 06593 } 06594 06595 SMESSAGECALL(IMECONTROL) 06596 { 06597 DWORD cCapture, cbCapture; 06598 06599 SETUPPWND(FNIMECONTROL) 06600 06601 switch (wParam) { 06602 case IMC_GETCANDIDATEPOS: 06603 case IMC_SETCANDIDATEPOS: 06604 cCapture = 1; 06605 cbCapture = sizeof(CANDIDATEFORM); 06606 break; 06607 06608 case IMC_GETCOMPOSITIONWINDOW: 06609 case IMC_SETCOMPOSITIONWINDOW: 06610 cCapture = 1; 06611 cbCapture = sizeof(COMPOSITIONFORM); 06612 break; 06613 06614 case IMC_GETCOMPOSITIONFONT: 06615 case IMC_SETCOMPOSITIONFONT: 06616 case IMC_GETSOFTKBDFONT: 06617 cCapture = 1; 06618 cbCapture = (dwSCMSFlags & SCMS_FLAGS_ANSI) 06619 ? sizeof(LOGFONTA) : sizeof(LOGFONTW) ; 06620 break; 06621 06622 case IMC_SETSOFTKBDDATA: 06623 cCapture = 1; 06624 cbCapture = FIELD_OFFSET(SOFTKBDDATA, wCode[0]) 06625 + ((PSOFTKBDDATA)lParam)->uCount * sizeof(WORD) * 256; 06626 06627 break; 06628 06629 default: 06630 cCapture = 0; 06631 cbCapture = 0; 06632 break; 06633 } 06634 06635 BEGINSENDCAPTURE(FNIMECONTROL, cCapture, cbCapture, TRUE); 06636 06637 MSGDATA()->pwnd = pwndClient; 06638 MSGDATA()->msg = msg; 06639 MSGDATA()->wParam = wParam; 06640 MSGDATA()->u.lParam = lParam; 06641 MSGDATA()->xParam = xParam; 06642 MSGDATA()->xpfnProc = xpfnProc; 06643 06644 LOCKPWND(); 06645 06646 switch (wParam) { 06647 06648 case IMC_GETCANDIDATEPOS: 06649 case IMC_GETCOMPOSITIONWINDOW: 06650 case IMC_GETCOMPOSITIONFONT: 06651 case IMC_GETSOFTKBDFONT: 06652 06653 RESERVEBYTES(cbCapture, pOutput, cbOutput); 06654 MAKECALLCAPTURE(FNIMECONTROL); 06655 UNLOCKPWND(); 06656 CHECKRETURN(); 06657 06658 BEGINCOPYOUT() 06659 try { 06660 ProbeForRead(pcbs->pOutput, pcbs->cbOutput, sizeof(DWORD)); 06661 switch (wParam) { 06662 case IMC_GETCANDIDATEPOS: 06663 case IMC_GETCOMPOSITIONWINDOW: 06664 memcpy((LPBYTE)lParam, pcbs->pOutput, cbCapture); 06665 break; 06666 06667 case IMC_GETCOMPOSITIONFONT: 06668 case IMC_GETSOFTKBDFONT: 06669 if (dwSCMSFlags & SCMS_FLAGS_ANSI) { 06670 CopyLogFontAtoW((PLOGFONTW)lParam, (PLOGFONTA)pcbs->pOutput); 06671 } 06672 else { 06673 memcpy((LPBYTE)lParam, pcbs->pOutput, cbCapture); 06674 } 06675 break; 06676 } 06677 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 06678 MSGERROR(); 06679 } 06680 ENDCOPYOUT() 06681 06682 break; 06683 06684 case IMC_SETCANDIDATEPOS: 06685 case IMC_SETCOMPOSITIONWINDOW: 06686 case IMC_SETCOMPOSITIONFONT: 06687 case IMC_SETSOFTKBDDATA: 06688 if (wParam == IMC_SETCANDIDATEPOS) { 06689 PCANDIDATEFORM pCandForm = (PCANDIDATEFORM)lParam; 06690 LARGECOPYBYTES2(pCandForm, sizeof(CANDIDATEFORM), u.pCandForm); 06691 } 06692 else if (wParam == IMC_SETCOMPOSITIONWINDOW) { 06693 PCOMPOSITIONFORM pCompForm = (PCOMPOSITIONFORM)lParam; 06694 LARGECOPYBYTES2(pCompForm, sizeof(COMPOSITIONFORM), u.pCompForm); 06695 } 06696 else if (wParam == IMC_SETCOMPOSITIONFONT) { 06697 if (dwSCMSFlags & SCMS_FLAGS_ANSI) { 06698 LOGFONTA LogFontA; 06699 LPSTR lpstrFontA = LogFontA.lfFaceName; 06700 LPWSTR lpstrFontW = ((PLOGFONTW)lParam)->lfFaceName; 06701 06702 memcpy(&LogFontA, (PBYTE)lParam, sizeof(LOGFONTA)-LF_FACESIZE); 06703 memset(lpstrFontA, 0, LF_FACESIZE * sizeof(CHAR)); 06704 WCSToMB(lpstrFontW, -1, &lpstrFontA, LF_FACESIZE, FALSE); 06705 LARGECOPYBYTES2(&LogFontA, sizeof(LOGFONTA), u.pLogFontA); 06706 } 06707 else { 06708 PLOGFONTW pLogFontW = (PLOGFONTW)lParam; 06709 LARGECOPYBYTES2(pLogFontW, sizeof(LOGFONTW), u.pLogFontW); 06710 } 06711 } 06712 else if (wParam == IMC_SETSOFTKBDDATA) { 06713 PSOFTKBDDATA pSoftKbdData; 06714 06715 if (dwSCMSFlags & SCMS_FLAGS_ANSI) { 06716 PWORD pCodeA; 06717 PWSTR pCodeW; 06718 CHAR ch[2]; 06719 PSTR pch = (PSTR)&ch; 06720 UINT i; 06721 06722 pSoftKbdData = (PSOFTKBDDATA)UserAllocPool(cbCapture, TAG_IME); 06723 if (pSoftKbdData == NULL) 06724 MSGERROR(); 06725 06726 pCodeA = &pSoftKbdData->wCode[0][0]; 06727 pCodeW = (PWSTR)&((PSOFTKBDDATA)lParam)->wCode[0][0]; 06728 06729 pSoftKbdData->uCount = ((PSOFTKBDDATA)lParam)->uCount; 06730 06731 i = pSoftKbdData->uCount * 256; 06732 06733 while (i--) { 06734 pch[1] = '\0'; 06735 WCSToMBEx(THREAD_CODEPAGE(), pCodeW, 1, &pch, 2, FALSE); 06736 if (pch[1]) { 06737 *pCodeA = MAKEWORD(pch[1], pch[0]); 06738 } else { 06739 *pCodeA = MAKEWORD(pch[0], 0); 06740 } 06741 pCodeA++; pCodeW++; 06742 } 06743 06744 LARGECOPYBYTES2(pSoftKbdData, cbCapture, u.pSoftKbdData); 06745 06746 UserFreePool(pSoftKbdData); 06747 } 06748 else { 06749 pSoftKbdData = (PSOFTKBDDATA)lParam; 06750 LARGECOPYBYTES2(pSoftKbdData, cbCapture, u.pSoftKbdData); 06751 } 06752 } 06753 06754 /* 06755 * Fall thur. 06756 */ 06757 06758 default: 06759 MAKECALLCAPTURE(FNIMECONTROL); 06760 UNLOCKPWND(); 06761 CHECKRETURN(); 06762 break; 06763 } 06764 06765 06766 TRACECALLBACKMSG("SfnINSTRINGNULL"); 06767 ENDSENDCAPTURE(DWORD,0); 06768 } 06769 #endif // SENDSIDE 06770 06771 #ifdef RECVSIDE 06772 RECVCALL(fnIMECONTROL, FNIMECONTROLMSG) 06773 { 06774 BYTE abOutput[CALLBACKSTACKLIMIT]; 06775 LPARAM lParam; 06776 06777 BEGINRECV(0, NULL, pmsg->cbOutput); 06778 FIXUPPOINTERS(); 06779 if (pmsg->cbOutput <= CALLBACKSTACKLIMIT) 06780 CallbackStatus.pOutput = abOutput; 06781 else 06782 CallbackStatus.pOutput = pmsg->pOutput; 06783 06784 switch (CALLDATA(wParam)) { 06785 case IMC_GETCANDIDATEPOS: 06786 case IMC_GETCOMPOSITIONWINDOW: 06787 case IMC_GETCOMPOSITIONFONT: 06788 case IMC_GETSOFTKBDFONT: 06789 lParam = (LPARAM)CallbackStatus.pOutput; 06790 break; 06791 06792 case IMC_SETCANDIDATEPOS: 06793 case IMC_SETCOMPOSITIONWINDOW: 06794 case IMC_SETCOMPOSITIONFONT: 06795 case IMC_SETSOFTKBDDATA: 06796 lParam = FIRSTFIXUP(u.lParam); 06797 break; 06798 06799 default: 06800 lParam = CALLDATA(u.lParam); 06801 break; 06802 } 06803 06804 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 06805 CALLDATA(pwnd), 06806 CALLDATA(msg), 06807 CALLDATA(wParam), 06808 lParam, 06809 CALLDATA(xParam)); 06810 06811 06812 ENDRECV(); 06813 } 06814 #endif // RECVSIDE 06815 06816 /**************************************************************************\ 06817 * fnIMEREQUEST 06818 * 06819 * 22-Apr-1996 Created 06820 \**************************************************************************/ 06821 06822 #ifdef LATER 06823 typedef struct _FNIMEREQUEST { 06824 CAPTUREBUF CaptureBuf; 06825 PWND pwnd; 06826 UINT msg; 06827 WPARAM wParam; 06828 union { 06829 LPCANDIDATEFORM pCandidateForm; 06830 LPLOGFONTA pLogFontA; 06831 LPLOGFONTW pLogFontW; 06832 LPCOMPOSITIONFORM pCompositionForm; 06833 LPRECONVERTSTRING pReconvertString; 06834 LPPrivateIMECHARPOSITION pImeCharPosition; 06835 LPARAM lParam; 06836 } u; 06837 ULONG_PTR xParam; 06838 PROC xpfnProc; 06839 PBYTE pOutput; 06840 DWORD cbOutput; 06841 BOOL fAnsi; 06842 } FNIMEREQUESTMSG; 06843 06844 #ifdef SENDSIDE 06845 06846 SMESSAGECALL(IMEREQUEST) 06847 { 06848 DWORD cCapture, cbCapture; 06849 06850 SETUPPWND(FNIMEREQUEST) 06851 06852 // 06853 // IMEREQUEST assumes the callback is within the thread 06854 // (see MESSAGECALL(IMEREQUEST) in kernel/ntstubs.c.) 06855 // 06856 // All the data pointed by lParam should point the valid 06857 // client side address. Thus all the validation and copy 06858 // (if needed) will be done in the receiver side. 06859 // 06860 UserAssert(psms == NULL || psms->ptiSender == psms->ptiReceiver); 06861 06862 switch (wParam) { 06863 case IMR_CANDIDATEWINDOW: 06864 cCapture = 1; 06865 cbCapture = sizeof(CANDIDATEFORM); 06866 break; 06867 06868 case IMR_COMPOSITIONWINDOW: 06869 cCapture = 1; 06870 cbCapture = sizeof(COMPOSITIONFORM); 06871 break; 06872 06873 case IMR_CONFIRMRECONVERTSTRING: 06874 case IMR_RECONVERTSTRING: 06875 case IMR_DOCUMENTFEED: 06876 case IMR_QUERYCHARPOSITION: 06877 cCapture = 0; 06878 cbCapture = 0; 06879 break; 06880 06881 case IMR_COMPOSITIONFONT: // only the exception to the rule above. 06882 cCapture = 1; 06883 cbCapture = (dwSCMSFlags & SCMS_FLAGS_ANSI) ? sizeof(LOGFONTA) : sizeof(LOGFONTW); 06884 break; 06885 06886 default: 06887 UserAssert(FALSE); 06888 cCapture = 0; 06889 cbCapture = 0; 06890 break; 06891 } 06892 06893 BEGINSENDCAPTURE(FNIMEREQUEST, cCapture, cbCapture, TRUE); 06894 06895 MSGDATA()->pwnd = pwndClient; 06896 MSGDATA()->msg = msg; 06897 MSGDATA()->wParam = wParam; 06898 MSGDATA()->u.lParam = lParam; 06899 MSGDATA()->xParam = xParam; 06900 MSGDATA()->xpfnProc = xpfnProc; 06901 MSGDATA()->fAnsi = (dwSCMSFlags & SCMS_FLAGS_ANSI); 06902 06903 LOCKPWND(); 06904 06905 // 06906 // Preparation 06907 // 06908 06909 switch (wParam) { 06910 case IMR_COMPOSITIONFONT: 06911 RESERVEBYTES(cbCapture, pOutput, cbOutput); 06912 break; 06913 } 06914 06915 MAKECALLCAPTURE(FNIMEREQUEST); 06916 UNLOCKPWND(); 06917 CHECKRETURN(); 06918 06919 BEGINCOPYOUT() 06920 try { 06921 switch (wParam) { 06922 case IMR_COMPOSITIONFONT: 06923 ProbeForRead(pcbs->pOutput, pcbs->cbOutput, sizeof(DWORD)); 06924 if (dwSCMSFlags & SCMS_FLAGS_ANSI) { 06925 CopyLogFontAtoW((PLOGFONTW)lParam, (PLOGFONTA)pcbs->pOutput); 06926 } 06927 else { 06928 memcpy((LPBYTE)lParam, pcbs->pOutput, cbCapture); 06929 } 06930 break; 06931 } 06932 } except (EXCEPTION_EXECUTE_HANDLER) { 06933 MSGERROR(); 06934 } 06935 ENDCOPYOUT() 06936 06937 TRACECALLBACKMSG("SfnIMEREQUEST"); 06938 ENDSENDCAPTURE(DWORD,0); 06939 } 06940 #endif // SENDSIDE 06941 06942 #ifdef RECVSIDE 06943 RECVCALL(fnIMEREQUEST, FNIMEREQUESTMSG) 06944 { 06945 BYTE abOutput[CALLBACKSTACKLIMIT]; 06946 LPVOID pvNew = NULL; 06947 LPARAM lParam; 06948 06949 BEGINRECV(0, NULL, pmsg->cbOutput); 06950 FIXUPPOINTERS(); 06951 if (pmsg->cbOutput <= CALLBACKSTACKLIMIT) 06952 CallbackStatus.pOutput = abOutput; 06953 else 06954 CallbackStatus.pOutput = pmsg->pOutput; 06955 06956 lParam = CALLDATA(u.lParam); 06957 06958 switch (CALLDATA(wParam)) { 06959 case IMR_COMPOSITIONWINDOW: 06960 case IMR_CANDIDATEWINDOW: 06961 // lParam = CALLDATA(lParam); 06962 break; 06963 06964 case IMR_COMPOSITIONFONT: 06965 lParam = (LPARAM)CallbackStatus.pOutput; 06966 break; 06967 06968 case IMR_QUERYCHARPOSITION: 06969 if (CALLDATA(fAnsi)) { 06970 LPPrivateIMECHARPOSITION lpCharPos; 06971 06972 pvNew = UserLocalAlloc(0, sizeof(PrivateIMECHARPOSITION)); 06973 if (pvNew == NULL) { 06974 goto error_return; 06975 } 06976 lpCharPos = pvNew; 06977 *lpCharPos = *CALLDATA(u.pImeCharPosition); 06978 lpCharPos->dwCharPos = lpCharPos->dwCharPositionA; 06979 } 06980 break; 06981 06982 case IMR_RECONVERTSTRING: 06983 case IMR_CONFIRMRECONVERTSTRING: 06984 case IMR_DOCUMENTFEED: 06985 // Real W/A conversion may be needed. 06986 if (CALLDATA(fAnsi) && lParam) { 06987 PRECONVERTSTRING Source = (LPRECONVERTSTRING)lParam; 06988 // Do conversion. 06989 DWORD dwNewSize = ImmGetReconvertTotalSize(((LPRECONVERTSTRING)lParam)->dwSize, FROM_IME, TRUE); 06990 if (dwNewSize == 0) { 06991 goto error_return; 06992 } 06993 06994 pvNew = UserLocalAlloc(0, dwNewSize); 06995 if (pvNew == NULL) { 06996 goto error_return; 06997 } 06998 lParam = (LPARAM)pvNew; 06999 07000 #define lpReconv ((LPRECONVERTSTRING)lParam) 07001 // setup the information in the allocated structure 07002 lpReconv->dwVersion = 0; 07003 lpReconv->dwSize = dwNewSize; 07004 if (CALLDATA(wParam) == IMR_CONFIRMRECONVERTSTRING) { 07005 ImmReconversionWorker(lpReconv, (LPRECONVERTSTRING)lParam, TRUE, CP_ACP); 07006 } 07007 } 07008 break; 07009 07010 default: 07011 lParam = CALLDATA(u.lParam); 07012 break; 07013 } 07014 07015 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 07016 CALLDATA(pwnd), 07017 CALLDATA(msg), 07018 CALLDATA(wParam), 07019 lParam, 07020 CALLDATA(xParam)); 07021 07022 switch (CALLDATA(wParam)) { 07023 case IMR_RECONVERTSTRING: 07024 case IMR_DOCUMENTFEED: 07025 if (CALLDATA(fAnsi)) { 07026 retval = ImmGetReconvertTotalSize((DWORD)retval, FROM_APP, TRUE); 07027 if (lParam) { 07028 retval = ImmReconversionWorker((LPRECONVERTSTRING)CALLDATA(u.lParam), (LPRECONVERTSTRING)pvNew, FALSE, CP_ACP); 07029 } 07030 } 07031 break; 07032 } 07033 07034 if (pvNew) { 07035 UserLocalFree(pvNew); 07036 } 07037 error_return: 07038 ENDRECV(); 07039 } 07040 07041 #undef lpReconv 07042 07043 #endif // RECVSIDE 07044 07045 #endif 07046 07047 /**************************************************************************\ 07048 * fnGETDBCSTEXTLENGTHS (DBCS-aware Version) 07049 * 07050 * Gets the Unicode & ANSI lengths 07051 * Internally, lParam pints to the ANSI length in bytes and the return value 07052 * is the Unicode length in bytes. However, the public definition is maintained 07053 * on the client side, where lParam is not used and either ANSI or Unicode is 07054 * returned. 07055 * 07056 * 14-Mar-1996 HideyukN Created 07057 \**************************************************************************/ 07058 07059 #if (WM_GETTEXTLENGTH - WM_GETTEXT) != 1 07060 #error "WM_GETTEXT Messages no longer 1 apart. Error in code." 07061 #endif 07062 #if (LB_GETTEXTLEN - LB_GETTEXT) != 1 07063 #error "LB_GETTEXT Messages no longer 1 apart. Error in code." 07064 #endif 07065 #if (CB_GETLBTEXTLEN - CB_GETLBTEXT) != 1 07066 #error "CB_GETLBTEXT Messages no longer 1 apart. Error in code." 07067 #endif 07068 07069 typedef struct _FNGETDBCSTEXTLENGTHSMSG { 07070 PWND pwnd; 07071 UINT msg; 07072 WPARAM wParam; 07073 ULONG_PTR xParam; 07074 PROC xpfnProc; 07075 } FNGETDBCSTEXTLENGTHSMSG; 07076 07077 #ifdef SENDSIDE 07078 SMESSAGECALL(GETDBCSTEXTLENGTHS) 07079 { 07080 BOOL fAnsiSender = !!(BOOL)lParam; 07081 BOOL fAnsiReceiver = ((dwSCMSFlags & SCMS_FLAGS_ANSI) != 0); 07082 LPVOID pfnSavedWndProc = pwnd->lpfnWndProc; 07083 07084 SETUPPWND(FNGETDBCSTEXTLENGTHS) 07085 07086 BEGINSEND(FNGETDBCSTEXTLENGTHS) 07087 07088 UserAssert((fAnsiReceiver & 1) == fAnsiReceiver && (fAnsiSender & 1) == fAnsiSender); 07089 07090 MSGDATA()->pwnd = pwndClient; 07091 MSGDATA()->msg = msg; 07092 MSGDATA()->wParam = wParam; 07093 MSGDATA()->xParam = xParam; 07094 MSGDATA()->xpfnProc = xpfnProc; 07095 07096 LOCKPWND(); 07097 MAKECALL(FNGETTEXTLENGTHS); 07098 UNLOCKPWND(); 07099 CHECKRETURN1(); 07100 07101 /* 07102 * ANSI client wndproc returns us cbANSI. We want cchUnicode, 07103 * so we guess cchUnicode = cbANSI. (It may be less if 07104 * multi-byte characters are involved, but it will never be more). 07105 * Save cbANSI in *lParam in case the server ultimately returns 07106 * the length to an ANSI caller. 07107 * 07108 * Unicode client wndproc returns us cchUnicode. If we want to know 07109 * cbANSI, we must guess how many 'ANSI' chars we would need. 07110 * We guess cbANSI = cchUnicode * 2. (It may be this much if all 07111 * 'ANSI' characters are multi-byte, but it will never be more). 07112 * 07113 * Return cchUnicode (server code is all Unicode internally). 07114 * Put cbANSI in *lParam to be passed along within the server in case 07115 * we ultimately need to return it to the client. 07116 * 07117 * NOTE: this will sometimes cause text lengths to be misreported 07118 * up to twice the real length, but that is expected to be harmless. 07119 * This will only * happen if an app sends WM_GETcode TEXTLENGTH to a 07120 * window with an ANSI client-side wndproc, or a ANSI WM_GETTEXTLENGTH 07121 * is sent to a Unicode client-side wndproc. 07122 */ 07123 07124 BEGINCOPYOUT() 07125 07126 // 07127 // retval can be [CB|LB]_ERR (-1) or [CB|LB]_ERRSPACE (-2) 07128 // then, it should be grater then zero. otherwise we can handle 07129 // it as error, or zero length string. 07130 // 07131 if ((LONG)retval > 0) { 07132 07133 // 07134 // Check we need to Ansi <-> Unicode conversion. 07135 // 07136 if (fAnsiSender != fAnsiReceiver) { 07137 if (pwnd->lpfnWndProc != pfnSavedWndProc) { 07138 // The window procedure is changed during the first callback. 07139 // Let's take a guess for the worst case. 07140 RIPMSG1(RIP_WARNING, "GETTEXTLENGTHS(pwnd=%x): The subclass status of winproc changed during 1st callback.", 07141 pwnd); 07142 retval *= 2; 07143 } 07144 else { 07145 BOOL bNotString = FALSE; // default is string.... 07146 07147 if (msg != WM_GETTEXTLENGTH) { 07148 DWORD dw; 07149 07150 if (!RevalidateHwnd(HW(pwnd))) { 07151 MSGERROR1(); 07152 } 07153 07154 // 07155 // Get window style. 07156 // 07157 dw = pwnd->style; 07158 07159 if (msg == LB_GETTEXTLEN) { 07160 // 07161 // See if the control is ownerdraw and does not have the LBS_HASSTRINGS 07162 // style. 07163 // 07164 bNotString = (!(dw & LBS_HASSTRINGS) && 07165 (dw & (LBS_OWNERDRAWFIXED | LBS_OWNERDRAWVARIABLE))); 07166 } else if (msg == CB_GETLBTEXTLEN) { 07167 // 07168 // See if the control is ownerdraw and does not have the CBS_HASSTRINGS 07169 // style. 07170 // 07171 bNotString = (!(dw & CBS_HASSTRINGS) && 07172 (dw & (CBS_OWNERDRAWFIXED | CBS_OWNERDRAWVARIABLE))); 07173 } else { 07174 MSGERROR1(); 07175 } 07176 07177 // 07178 // if so, the length should be ULONG_PTR. 07179 // 07180 if (bNotString) { 07181 retval = sizeof(ULONG_PTR); 07182 } 07183 } 07184 07185 // 07186 // if the target data is "string", get it, and compute the length 07187 // 07188 if (!bNotString) { 07189 if (PtiCurrent()->TIF_flags & TIF_INGETTEXTLENGTH) { 07190 if (fAnsiSender) { 07191 UserAssert(!fAnsiReceiver); 07192 // 07193 // retval has Unicode character count, guessed DBCS length. 07194 // 07195 retval *= 2; 07196 } 07197 } else { 07198 // 07199 // fAnsiReceiver == 1, retval has MBCS character count. 07200 // fAnsiReceiver == 0, retval has Unicode character count. 07201 // 07202 // Add 1 to make room for zero-terminator. 07203 // 07204 DWORD cchText = (DWORD)retval + 1; 07205 DWORD cbCapture = cchText; 07206 07207 SETUPPWND(FNOUTSTRING) 07208 07209 PtiCurrent()->TIF_flags |= TIF_INGETTEXTLENGTH; 07210 07211 // 07212 // if reciver is Unicode, The buffder should be reserved as musg as 07213 // (TextLength * sizeof(WCHAR). 07214 // 07215 if (!fAnsiReceiver) { 07216 cbCapture *= sizeof(WCHAR); 07217 } 07218 07219 BEGINSENDCAPTURE(FNOUTSTRING, 1, cbCapture, FALSE) 07220 07221 MSGDATA()->pwnd = pwndClient; 07222 07223 // 07224 // Use (msg-1) for sending the WM_GETTEXT, LB_GETTEXT or CB_GETLBTEXT 07225 // since the above precompiler checks passed. 07226 // 07227 MSGDATA()->msg = msg-1; 07228 07229 if (msg == WM_GETTEXTLENGTH) { 07230 // 07231 // WM_GETTEXT: 07232 // wParam = cchTextMax; // number of character to copy. 07233 // lParam = lpszText; // address of buffer for text. 07234 // 07235 MSGDATA()->wParam = cchText; 07236 } else { 07237 // 07238 // LB_GETTEXT: 07239 // CB_GETLBTEXT: 07240 // wParam = index; // item index 07241 // lParam = lpszText; // address of buffer for text. 07242 // 07243 MSGDATA()->wParam = wParam; 07244 } 07245 07246 MSGDATA()->xParam = xParam; 07247 MSGDATA()->xpfnProc = xpfnProc; 07248 07249 RESERVEBYTES(cbCapture, pOutput, cbOutput); 07250 07251 LOCKPWND(); 07252 MAKECALLCAPTURE(FNOUTSTRING); 07253 UNLOCKPWND(); 07254 CHECKRETURN(); 07255 07256 BEGINCOPYOUT() 07257 // 07258 // retval can be [CB|LB]_ERR (-1) or [CB|LB]_ERRSPACE (-2) 07259 // then, it should be grater then zero. 07260 // 07261 if ((LONG)retval > 0) { 07262 /* 07263 * Non-zero retval means some text to copy out. 07264 */ 07265 CALC_SIZE_STRING_OUT((LONG)retval); 07266 } 07267 ENDCOPYOUT() 07268 07269 PtiCurrent()->TIF_flags &= ~TIF_INGETTEXTLENGTH; 07270 07271 TRACECALLBACKMSG("SfnOUTSTRING"); 07272 ENDSENDCAPTURE(DWORD,0); 07273 } 07274 } 07275 } 07276 } 07277 } 07278 ENDCOPYOUT() 07279 07280 TRACECALLBACKMSG("SfnGETDBCSTEXTLENGTHS"); 07281 ENDSEND1(DWORD,0); 07282 } 07283 #endif // SENDSIDE 07284 07285 #ifdef RECVSIDE 07286 /* 07287 * The fnGETTEXTLENGTHS routine is used for this message (see... client\dispcb.tpl) 07288 */ 07289 #endif // RECVSIDE 07290 07291 /***************************************************************************\ 07292 * xxxClientMonitorEnumProc 07293 * 07294 * Calls the client callback given to EnumDisplayMonitors. 07295 * 07296 * History: 07297 * 05-Sep-1996 adams Created. 07298 \***************************************************************************/ 07299 07300 typedef struct _CLIENTMONITORENUMPROCMSG { 07301 HMONITOR hMonitor; 07302 HDC hdcMonitor; 07303 RECT rc; 07304 LPARAM dwData; 07305 MONITORENUMPROC xpfnProc; 07306 } CLIENTMONITORENUMPROCMSG; 07307 07308 #ifdef SENDSIDE 07309 BOOL xxxClientMonitorEnumProc( 07310 HMONITOR hMonitor, 07311 HDC hdcMonitor, 07312 LPRECT lprc, 07313 LPARAM dwData, 07314 MONITORENUMPROC xpfnProc) 07315 { 07316 SETUP(CLIENTMONITORENUMPROC) 07317 07318 BEGINSEND(CLIENTMONITORENUMPROCMSG) 07319 07320 MSGDATA()->hMonitor = hMonitor; 07321 MSGDATA()->hdcMonitor = hdcMonitor; 07322 MSGDATA()->rc = *lprc; 07323 MSGDATA()->dwData = dwData; 07324 MSGDATA()->xpfnProc = xpfnProc; 07325 07326 MAKECALL(CLIENTMONITORENUMPROC); 07327 CHECKRETURN(); 07328 07329 TRACECALLBACK("SxxxClientMonitorEnumProc"); 07330 ENDSEND(BOOL,FALSE); 07331 } 07332 #endif // SENDSIDE 07333 07334 #ifdef RECVSIDE 07335 RECVCALL(ClientMonitorEnumProc, CLIENTMONITORENUMPROCMSG) 07336 { 07337 BEGINRECV(FALSE, NULL, 0); 07338 07339 retval = (DWORD)CALLPROC(pmsg->xpfnProc)( 07340 CALLDATA(hMonitor), 07341 CALLDATA(hdcMonitor), 07342 PCALLDATA(rc), 07343 CALLDATA(dwData)); 07344 07345 ENDRECV(); 07346 } 07347 #endif // RECVSIDE 07348 07349 /**************************************************************************\ 07350 * xxxUserModeCallback 07351 * 07352 * Generic kernel callback stub 07353 * 07354 * 10/28/96 GerardoB Created 07355 \**************************************************************************/ 07356 #ifdef SENDSIDE 07357 NTSTATUS xxxUserModeCallback (ULONG uApi, PVOID pIn, ULONG cbIn, PVOID pOut, ULONG cbOut) 07358 { 07359 NTSTATUS Status; 07360 PVOID pLocalOut; 07361 ULONG cbLocalOut; 07362 07363 /* 07364 * Call the client 07365 */ 07366 LeaveCrit(); 07367 Status = KeUserModeCallback(uApi, pIn, cbIn, &pLocalOut, &cbLocalOut); 07368 EnterCrit(); 07369 07370 /* 07371 * If it failed, bail 07372 */ 07373 if (!NT_SUCCESS(Status)) { 07374 return Status; 07375 } 07376 07377 /* 07378 * If we didn't get the right amount of data, fail. 07379 */ 07380 if (cbLocalOut != cbOut) { 07381 RIPMSG3(RIP_WARNING, "xxxUserModeCallback: uAPi: %#lx cbOut: %#lx cbLocalOut: %#lx", 07382 uApi, cbOut, cbLocalOut); 07383 return STATUS_UNSUCCESSFUL; 07384 } 07385 07386 /* 07387 * If we were expecting some data, copy it. 07388 */ 07389 if (cbOut != 0) { 07390 try { 07391 ProbeForRead(pLocalOut, cbLocalOut, sizeof(DWORD)); 07392 RtlCopyMemory(pOut, pLocalOut, cbLocalOut); 07393 } except (W32ExceptionHandler(FALSE, RIP_WARNING)) { 07394 RIPMSG2(RIP_WARNING, "xxxUserModeCallback: uAPi: %#lx Exception: %#lx", uApi, GetExceptionCode()); 07395 Status = STATUS_UNSUCCESSFUL; 07396 } 07397 } 07398 07399 return Status; 07400 } 07401 #endif // SENDSIDE 07402 07403 /**************************************************************************\ 07404 * fnINOUTMENUGETOBJECT 07405 * 07406 * 11/12/96 GerardoB Created 07407 \**************************************************************************/ 07408 typedef struct _FNINOUTMENUGETOBJECTMSG { 07409 PWND pwnd; 07410 UINT msg; 07411 WPARAM wParam; 07412 MENUGETOBJECTINFO mngoi; 07413 ULONG_PTR xParam; 07414 PROC xpfnProc; 07415 } FNINOUTMENUGETOBJECTMSG; 07416 07417 #ifdef SENDSIDE 07418 SMESSAGECALL(INOUTMENUGETOBJECT) 07419 { 07420 SETUPPWND(FNINOUTMENUGETOBJECT) 07421 07422 UNREFERENCED_PARAMETER(dwSCMSFlags); 07423 07424 BEGINSEND(FNOUTDWORDINDWORD) 07425 07426 PMENUGETOBJECTINFO pmngoi = (PMENUGETOBJECTINFO)lParam; 07427 07428 MSGDATA()->pwnd = pwndClient; 07429 MSGDATA()->msg = msg; 07430 MSGDATA()->wParam = wParam; 07431 MSGDATA()->mngoi = *pmngoi; 07432 MSGDATA()->xParam = xParam; 07433 MSGDATA()->xpfnProc = xpfnProc; 07434 07435 LOCKPWND(); 07436 MAKECALL(FNINOUTMENUGETOBJECT); 07437 UNLOCKPWND(); 07438 CHECKRETURN(); 07439 07440 BEGINCOPYOUT() 07441 try { 07442 UserAssert(pcbs->cbOutput == sizeof(pmngoi->pvObj)); 07443 ProbeForRead(pcbs->pOutput, sizeof(pmngoi->pvObj), sizeof(DWORD)); 07444 pmngoi->pvObj = *((PVOID *)(pcbs->pOutput)); 07445 } except (W32ExceptionHandler(TRUE, RIP_WARNING)) { 07446 MSGERROR(); 07447 } 07448 ENDCOPYOUT() 07449 07450 TRACECALLBACKMSG("SfnINOUTMENUGETOBJECT"); 07451 ENDSEND(DWORD, 0); 07452 } 07453 #endif // SENDSIDE 07454 07455 #ifdef RECVSIDE 07456 RECVCALL(fnINOUTMENUGETOBJECT, FNINOUTMENUGETOBJECTMSG) 07457 { 07458 BEGINRECV(0, &(pmsg->mngoi.pvObj), sizeof(pmsg->mngoi.pvObj)); 07459 07460 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 07461 CALLDATA(pwnd), 07462 CALLDATA(msg), 07463 CALLDATA(wParam), 07464 PCALLDATA(mngoi), 07465 CALLDATA(xParam)); 07466 07467 ENDRECV(); 07468 } 07469 #endif // RECVSIDE 07470 07471 /**************************************************************************\ 07472 * fnLOGONNOTIFY 07473 * 07474 * 2/1/97 JerrySh Created 07475 \**************************************************************************/ 07476 typedef struct _FNLOGONNOTIFYMSG { 07477 PWND pwnd; 07478 UINT msg; 07479 WPARAM wParam; 07480 LPARAM lParam; 07481 POWERSTATEPARAMS psParams; 07482 ULONG_PTR xParam; 07483 PROC xpfnProc; 07484 } FNLOGONNOTIFYMSG; 07485 07486 #ifdef SENDSIDE 07487 SMESSAGECALL(LOGONNOTIFY) 07488 { 07489 SETUPPWND(FNLOGONNOTIFY) 07490 07491 UNREFERENCED_PARAMETER(dwSCMSFlags); 07492 UNREFERENCED_PARAMETER(psms); 07493 07494 BEGINSEND(FNLOGONNOTIFY) 07495 07496 if (wParam == LOGON_POWERSTATE) 07497 MSGDATA()->psParams = *((PPOWERSTATEPARAMS)lParam); 07498 07499 MSGDATA()->pwnd = pwndClient; 07500 MSGDATA()->msg = msg; 07501 MSGDATA()->wParam = wParam; 07502 MSGDATA()->lParam = lParam; 07503 MSGDATA()->xParam = xParam; 07504 MSGDATA()->xpfnProc = xpfnProc; 07505 07506 LOCKPWND(); 07507 MAKECALL(FNLOGONNOTIFY); 07508 UNLOCKPWND(); 07509 CHECKRETURN(); 07510 07511 TRACECALLBACKMSG("SfnLOGONNOTIFY"); 07512 ENDSEND(DWORD, 0); 07513 } 07514 #endif // SENDSIDE 07515 07516 #ifdef RECVSIDE 07517 RECVCALL(fnLOGONNOTIFY, FNLOGONNOTIFYMSG) 07518 { 07519 LPARAM lParam; 07520 07521 BEGINRECV(0, NULL, 0); 07522 07523 lParam = (CALLDATA(wParam) == LOGON_POWERSTATE) ? (LPARAM)&CALLDATA(psParams) : CALLDATA(lParam); 07524 07525 retval = (ULONG_PTR)CALLPROC(CALLDATA(xpfnProc))( 07526 CALLDATA(pwnd), 07527 CALLDATA(msg), 07528 CALLDATA(wParam), 07529 lParam, 07530 CALLDATA(xParam)); 07531 07532 ENDRECV(); 07533 } 07534 #endif // RECVSIDE 07535 07536 /**************************************************************************\ 07537 * xxxClientCallWinEventProc 07538 * 07539 * cf. Win'97 Call32BitEventProc() in user_40\user32\user.c 07540 * 07541 * 1996-10-18 IanJa Created 07542 \**************************************************************************/ 07543 07544 typedef struct _CLIENTCALLWINEVENTPROCMSG { 07545 WINEVENTPROC pfn; 07546 HWINEVENTHOOK hWinEventHook; 07547 DWORD event; 07548 HWND hwnd; 07549 LONG idObject; 07550 LONG idChild; 07551 DWORD idEventThread; 07552 DWORD dwmsEventTime; 07553 } CLIENTCALLWINEVENTPROCMSG; 07554 07555 #ifdef SENDSIDE 07556 BOOL xxxClientCallWinEventProc( 07557 WINEVENTPROC pfn, 07558 PEVENTHOOK pEventHook, 07559 PNOTIFY pNotify) 07560 { 07561 SETUP(CLIENTCALLWINEVENTPROC) 07562 07563 BEGINSEND(CLIENTCALLWINEVENTPROC) 07564 07565 MSGDATA()->pfn = pfn; 07566 MSGDATA()->hWinEventHook = (HWINEVENTHOOK)PtoH(pEventHook); 07567 MSGDATA()->hwnd = pNotify->hwnd; 07568 MSGDATA()->event = pNotify->event; 07569 MSGDATA()->idObject = pNotify->idObject; 07570 MSGDATA()->idChild = pNotify->idChild; 07571 MSGDATA()->idEventThread = pNotify->idSenderThread; 07572 MSGDATA()->dwmsEventTime = pNotify->dwEventTime; 07573 07574 MAKECALL(CLIENTCALLWINEVENTPROC); 07575 CHECKRETURN(); 07576 07577 TRACECALLBACK("xxxClientCallWinEventProc"); 07578 ENDSEND(BOOL, FALSE); 07579 } 07580 #endif // SENDSIDE 07581 07582 #ifdef RECVSIDE 07583 RECVCALL(ClientCallWinEventProc, CLIENTCALLWINEVENTPROCMSG) 07584 { 07585 BEGINRECV(FALSE, NULL, 0); 07586 07587 retval = (DWORD)CALLPROC(pmsg->pfn)( 07588 CALLDATA(hWinEventHook), 07589 CALLDATA(event), 07590 CALLDATA(hwnd), 07591 CALLDATA(idObject), 07592 CALLDATA(idChild), 07593 CALLDATA(idEventThread), 07594 CALLDATA(dwmsEventTime)); 07595 07596 ENDRECV(); 07597 07598 } 07599 #endif // RECVSIDE 07600 07601 07602 07603 /**************************************************************************\ 07604 * WOWGetProcModule 07605 * 07606 * 3/25/97 FritzS created 07607 \**************************************************************************/ 07608 07609 typedef struct _CLIENTWOWGETPROCMODULEMSG { 07610 WNDPROC_PWND pfn; 07611 } CLIENTWOWGETPROCMODULEMSG; 07612 07613 07614 07615 #ifdef SENDSIDE 07616 WORD xxxClientWOWGetProcModule( 07617 WNDPROC_PWND pfn) 07618 { 07619 SETUP(CLIENTWOWGETPROCMODULE) 07620 07621 BEGINSEND(CLIENTWOWGETPROCMODULE) 07622 07623 MSGDATA()->pfn = pfn; 07624 07625 MAKECALL(CLIENTWOWGETPROCMODULE); 07626 CHECKRETURN(); 07627 07628 TRACECALLBACK("xxxWOWGetProcModule"); 07629 ENDSEND(WORD, FALSE); 07630 } 07631 #endif // SENDSIDE 07632 07633 #ifdef RECVSIDE 07634 RECVCALL(ClientWOWGetProcModule, CLIENTWOWGETPROCMODULEMSG) 07635 { 07636 ULONG ulReal; 07637 BEGINRECV(0, NULL, 0); 07638 07639 if ((pfnWowGetProcModule == NULL) || !IsWOWProc(CALLDATA(pfn))) { 07640 retval = 0; 07641 } else { 07642 UnMarkWOWProc(CALLDATA(pfn),ulReal); 07643 retval = (pfnWowGetProcModule)(ulReal); 07644 } 07645 07646 ENDRECV(); 07647 07648 } 07649 #endif // RECVSIDE