1123 lines
34 KiB
C++
1123 lines
34 KiB
C++
// Copyright (c) 1996-2000 Microsoft Corporation
|
|
// ----------------------------------------------------------------------------
|
|
// Win64Helper.cpp
|
|
//
|
|
// Helper functions used by all the control wrappers
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
#include "Win64Helper.h"
|
|
#include "w95trace.h"
|
|
|
|
#include "RemoteProxy6432.h"
|
|
#include <atlbase.h> // CComPtr
|
|
|
|
|
|
// Used for Tab control code
|
|
// cbExtra for the tray is 8, so pick something even bigger, 16
|
|
#define CBEXTRA_TRAYTAB 16
|
|
|
|
|
|
|
|
// Stuff in this file:
|
|
//
|
|
// * Bitness utility functions
|
|
// - determine whether we are on a 32- or 64- bit system, determine
|
|
// what bitness a process is.
|
|
//
|
|
// * Cross-proc SendMessage utility class
|
|
// - manages allocting a struct in the remote process, copying to that
|
|
// struct, sending a message, and copying back out the result.
|
|
//
|
|
// * Remote type template class
|
|
// - template class used in the explicit 64/32 structure definitions
|
|
//
|
|
// * Explicit 64/32 structure definitions
|
|
// - Definitions of comctl and related structs (eg. LVITEM) in separate
|
|
// 64- and 32-bit versions (eg. LVITEM_64, LVITEM_32) that have the
|
|
// correct item sizes, layout and alignment for that bitness.
|
|
//
|
|
// * Cross-proc message handlers
|
|
// - one for each supported message/datatype. (eg. ListView_Get_Handler
|
|
// handles LVM_GETITEM which uses LVITEM.) These copy the 'in' fields
|
|
// from a local struct (eg. LVITEM) to a local copy of the appropriate
|
|
// 'remote' struct (eg. LVITEM_32 or LVITEM_64, depending on the bitness
|
|
// of the target proxy), use the cross-proc sendmessage helper to
|
|
// copy that to the remote proc, send the message, and copy back; and
|
|
// then copy the appropriate 'out' fields back to the original local
|
|
// struct.
|
|
//
|
|
// * Stub macro
|
|
// - this macro declares a function that does a plain sendmessage if we're
|
|
// in the same process as the target HWND - otherwise it uses a cross-proc
|
|
// handler (see above) to send the message cross-proc.
|
|
//
|
|
//
|
|
// * GetRemoteProxyFactory
|
|
// - Lives here because there's no other suitable place for it.
|
|
//
|
|
//
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Bitness utility functions
|
|
//
|
|
// Class CProcessorType is used to determine whether we are running on a
|
|
// 64- or 32-bit system (regardless of whether this is a 32- or 64-bit
|
|
// process - eg. we could be a 32-bit process on a 64-bit machine).
|
|
//
|
|
// Function SameBitness determines if a window belongs to a process with the
|
|
// same bitness as the current process.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
|
// Taken from enum _PROCESSINFOCLASS in NT\PUBLIC\sdk\inc\ntpsapi.h ...
|
|
|
|
#define ProcessWow64Information 26
|
|
|
|
#define NT_ERROR(Status) ((ULONG)(Status) >> 30 == 3)
|
|
|
|
typedef enum ProcessorTypes {
|
|
ProcessorUndef,
|
|
ProcessorX86,
|
|
ProcessorIA64
|
|
} ProcessorTypes;
|
|
|
|
class CProcessorType {
|
|
private:
|
|
static ProcessorTypes m_ProcessorType;
|
|
static void Init()
|
|
{
|
|
if (m_ProcessorType != ProcessorUndef)
|
|
return;
|
|
#ifndef _WIN64
|
|
ULONG_PTR Wow64Info = NULL;
|
|
HANDLE hProcess;
|
|
|
|
hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, GetCurrentProcessId());
|
|
long lStatus = MyNtQueryInformationProcess(hProcess, ProcessWow64Information, &Wow64Info, sizeof(Wow64Info), NULL);
|
|
CloseHandle(hProcess);
|
|
if (NT_ERROR(lStatus))
|
|
{
|
|
// Query failed. Must be on an NT4 or earlier NT machine. Definitely a 32-bit machine.
|
|
m_ProcessorType = ProcessorX86;
|
|
} else if (Wow64Info)
|
|
{
|
|
// We are running inside WOW64 on a 64-bit machine
|
|
m_ProcessorType = ProcessorIA64;
|
|
} else
|
|
{
|
|
// We are running on x86 Win2000 or later OS
|
|
m_ProcessorType = ProcessorX86;
|
|
}
|
|
DBPRINTF(TEXT("CProcessorType: !_WIN64 defined m_ProcessorType=%d\r\n"), m_ProcessorType);
|
|
#else
|
|
// _WIN64 is defined, so definitely running on a 64-bit processor
|
|
m_ProcessorType = ProcessorIA64;
|
|
DBPRINTF(TEXT("CProcessorType: _WIN64 defined m_ProcessorType=%d\r\n"), m_ProcessorType);
|
|
#endif
|
|
};
|
|
public:
|
|
CProcessorType() {};
|
|
~CProcessorType() {};
|
|
static BOOL ProcessorIsIA64() {
|
|
Init();
|
|
return m_ProcessorType == ProcessorIA64;
|
|
}
|
|
static BOOL ProcessorIsX86() {
|
|
Init();
|
|
return m_ProcessorType == ProcessorX86;
|
|
}
|
|
};
|
|
ProcessorTypes CProcessorType::m_ProcessorType = ProcessorUndef;
|
|
|
|
|
|
|
|
|
|
HRESULT SameBitness(HWND hwnd, BOOL *pfIsSameBitness)
|
|
{
|
|
*pfIsSameBitness = TRUE;
|
|
|
|
#ifndef ENABLE6432_INTEROP
|
|
return S_OK;
|
|
#endif
|
|
|
|
// If running on an X86 then we must be same bitness
|
|
if (CProcessorType::ProcessorIsX86())
|
|
return S_OK;
|
|
|
|
DWORD dwProcessId;
|
|
if ( !GetWindowThreadProcessId(hwnd, &dwProcessId) )
|
|
return E_FAIL;
|
|
|
|
BOOL fIs32Bit;
|
|
|
|
HANDLE hProcess = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, dwProcessId);
|
|
if ( NULL == hProcess )
|
|
{
|
|
// The desktop window is in a process that OpenProcess fails on
|
|
// with an ERROR_ACCESS_DENIED (5) so special case it an assume
|
|
// its the same as the platform
|
|
// TODO figure out what other thisngs could fall in this catagory
|
|
// and deal with them as exceptions
|
|
const HWND hwndDesktop = GetDesktopWindow();
|
|
if ( hwnd == hwndDesktop )
|
|
{
|
|
// at this point we are on a 64 bit platfrom and therefore
|
|
// can assume that the desktop is 64 bit as well
|
|
fIs32Bit = FALSE;
|
|
}
|
|
else
|
|
{
|
|
DWORD dwErr = GetLastError();
|
|
DBPRINTF( TEXT("OpenProcess returned null GetLastError()=%d\r\n"), dwErr );
|
|
return E_FAIL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ULONG_PTR Wow64Info = NULL;
|
|
long rv = MyNtQueryInformationProcess(
|
|
hProcess
|
|
, ProcessWow64Information
|
|
, &Wow64Info
|
|
, sizeof(Wow64Info)
|
|
, NULL);
|
|
CloseHandle(hProcess);
|
|
|
|
if (NT_ERROR(rv))
|
|
{
|
|
Wow64Info = NULL; // fake that process is 64bit (OK because this code only executed for _WIN64)
|
|
}
|
|
|
|
fIs32Bit = (NULL != Wow64Info);
|
|
}
|
|
|
|
#ifdef _WIN64
|
|
*pfIsSameBitness = !fIs32Bit;
|
|
#else
|
|
*pfIsSameBitness = fIs32Bit;
|
|
#endif
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Cross-proc SendMessage utility class
|
|
//
|
|
// The cross-proc message handlers all follow a similar pattern.
|
|
//
|
|
// First, the handler works out how much extra storage it will need - eg.
|
|
// for returning a text string. It then calls Alloc() with the size of the
|
|
// base struct (eg. LVITEM), and the size of the extra data - if any (may be
|
|
// 0).
|
|
//
|
|
// Alloc() then allocaes space for both the base struct and the extra
|
|
// data, and returns TRUE if the allocation succeeded.
|
|
//
|
|
// GetExtraPtr() returns a pointer, relative to the remote process, to the
|
|
// extra space. If no extra space was requested, it returns NULL.
|
|
//
|
|
// ReadExtra() is used to read data in that extra space from the remote
|
|
// process to the local process. If no extra space was requested, it
|
|
// does nothing.
|
|
//
|
|
// WriteSendMsgRead() copies the struct to the remote process, sends the
|
|
// message using SendMessage, and then copies the struct back to the local
|
|
// process.
|
|
//
|
|
// WriteSendMsg() is the same as WriteSendMsgRead(), except it does not
|
|
// copy the result back. (This is used for 'put' messages that do not
|
|
// return information.)
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
class CXSendHelper
|
|
{
|
|
private:
|
|
void * m_pvAddress; // Ptr to remote shared mem
|
|
HANDLE m_hProcess; // Handle of remote process
|
|
UINT m_cbSize; // Size of base struct
|
|
UINT m_cbExtra; // Size of extra stuff - usually text - stored after the struct
|
|
|
|
public:
|
|
|
|
CXSendHelper() : m_pvAddress(0) {};
|
|
|
|
virtual ~CXSendHelper()
|
|
{
|
|
if (m_pvAddress)
|
|
{
|
|
::SharedFree(m_pvAddress, m_hProcess);
|
|
m_pvAddress = 0;
|
|
}
|
|
}
|
|
|
|
BOOL Alloc( HWND hwnd, UINT cbSize, UINT cbExtra )
|
|
{
|
|
m_cbSize = cbSize;
|
|
m_cbExtra = cbExtra;
|
|
m_pvAddress = ::SharedAlloc( cbSize + cbExtra, hwnd, &m_hProcess );
|
|
return m_pvAddress != NULL;
|
|
}
|
|
|
|
void * GetExtraPtr()
|
|
{
|
|
// If no extra space was requested, then return NULL...
|
|
if( ! m_cbExtra )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Return pointer to the 'extra' data that follows the struct
|
|
return (BYTE *)m_pvAddress + m_cbSize;
|
|
}
|
|
|
|
BOOL ReadExtra( LPVOID lpvDest, LPVOID lpvRemoteSrc, BOOL fIsString )
|
|
{
|
|
// Does nothing if no extra space was requested.
|
|
if( ! m_cbExtra )
|
|
return TRUE;
|
|
|
|
if( lpvRemoteSrc )
|
|
{
|
|
// This may point to the extra space we allocated, or the control may
|
|
// have changed the pointer to point to its own data instead of copying
|
|
// into the space we allocated.
|
|
if( ! SharedRead( lpvRemoteSrc, lpvDest, m_cbExtra, m_hProcess ) )
|
|
return FALSE;
|
|
|
|
if( fIsString )
|
|
{
|
|
// Paranoia - forcibly NUL-terminate, in case we get garbage...
|
|
LPTSTR pEnd = (LPTSTR)((BYTE *)lpvDest + m_cbExtra) - 1;
|
|
*pEnd = '\0';
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
// The control changed the pointer to NULL - assume that this means there's
|
|
// nothing there.
|
|
if( fIsString )
|
|
{
|
|
// Use empty string
|
|
*(LPTSTR)lpvDest = '\0';
|
|
return TRUE;
|
|
}
|
|
else
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
template < class T >
|
|
BOOL WriteSendMsgRead ( T * pStruct, HWND hwnd, UINT uMsg, WPARAM wParam, BOOL fCheckSend )
|
|
{
|
|
// Copy the struct to the remote process...
|
|
if( ! SharedWrite( pStruct, m_pvAddress, sizeof( T ), m_hProcess ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Send the message...
|
|
// If SendMessage fails, we fail only if the fCheckSend flag is specified.
|
|
if( ( ! SendMessage( hwnd, uMsg, wParam, (LPARAM) m_pvAddress) ) && fCheckSend )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
// Copy returned struct back to local process...
|
|
if( ! SharedRead( m_pvAddress, pStruct, sizeof( T ), m_hProcess ) )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
template < class T >
|
|
BOOL WriteSendMsg ( T * pStruct, HWND hwnd, UINT uMsg, WPARAM wParam, BOOL fCheckSend )
|
|
{
|
|
// Copy the struct remotely...
|
|
if( ! SharedWrite( pStruct, m_pvAddress, sizeof( T ), m_hProcess ) )
|
|
return FALSE;
|
|
|
|
// Send the message...
|
|
// If SendMessage fails, we fail only if the fCheckSend flag is specified.
|
|
if( ! SendMessage( hwnd, uMsg, wParam, (LPARAM) m_pvAddress) && fCheckSend )
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// 'Remote Type' template class
|
|
//
|
|
// This is used to represent a type in a remote address space.
|
|
// While the local type may be a poiter, a handle, or some other 'native'
|
|
// type, when accessed remotely, an integer type is used to ensure correct
|
|
// size.
|
|
//
|
|
// Eg. a pointer in a 64-bit process is represented as a ULONG64; a ptr in a
|
|
// 32-bit process is represented as a ULONG32.
|
|
//
|
|
// Signedness matters for some types - pointers are zero-extended when going
|
|
// from 32-to-64, but handles are sign-extended.
|
|
//
|
|
// This class, which has assignment and conversion operators defined, takes
|
|
// care of the necessary casting to ensure correct conversion between the
|
|
// local type and the remote representation
|
|
//
|
|
// This is a template class, which takes the following parameters:
|
|
//
|
|
// REMOTE_INT - remote representation type - eg. ULONG64, LONG32, etc.
|
|
// LOCAL_INT_PTR - local integer type, eg. ULONG_PTR, LONG_PTR
|
|
// LOCAL_TYPE - local type - eg handle, void*, LPARAM, etc.
|
|
//
|
|
//
|
|
// A 64-bit pointer, for example, would have a REMOTE_INT of ULONG64 - 64bit
|
|
// size, unsigned for zero-extension; a LOCAL_INT_PTR of ULONG_PTR - same
|
|
// sign as REMOTE_INT - and a local type of void*.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
template < typename REMOTE_INT, typename LOCAL_INT_PTR, typename LOCAL_TYPE >
|
|
class RemoteType
|
|
{
|
|
REMOTE_INT m_val;
|
|
|
|
public:
|
|
|
|
void operator = ( LOCAL_TYPE h )
|
|
{
|
|
// Convert from local type to remote integer type, via local integer type
|
|
m_val = (REMOTE_INT) (LOCAL_INT_PTR) h;
|
|
}
|
|
|
|
operator LOCAL_TYPE ( )
|
|
{
|
|
// Convert from remote integer to local type, via local integer type
|
|
return (LOCAL_TYPE) (LOCAL_INT_PTR) m_val;
|
|
}
|
|
};
|
|
|
|
|
|
typedef RemoteType< ULONG32, ULONG_PTR, void * > Ptr32;
|
|
typedef RemoteType< ULONG64, ULONG_PTR, void * > Ptr64;
|
|
|
|
typedef RemoteType< LONG32, LONG_PTR, LPARAM > LParam32;
|
|
typedef RemoteType< LONG64, LONG_PTR, LPARAM > LParam64;
|
|
|
|
typedef RemoteType< LONG32, LONG_PTR, HWND > HWnd32;
|
|
typedef RemoteType< LONG64, LONG_PTR, HWND > HWnd64;
|
|
|
|
typedef RemoteType< LONG32, LONG_PTR, HBITMAP > HBitmap32;
|
|
typedef RemoteType< LONG64, LONG_PTR, HBITMAP > HBitmap64;
|
|
|
|
typedef RemoteType< LONG32, LONG_PTR, HINSTANCE > HInstance32;
|
|
typedef RemoteType< LONG64, LONG_PTR, HINSTANCE > HInstance64;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Explicit 32-bit and 64-bit versions of the control structs
|
|
//
|
|
// These use explicit 'remote type' fields instead of handler or pointer,
|
|
// to ensure the correct size and sign extension when compiled as either
|
|
// 32-bit or 64-code. "for_alignment" fields are also added to the 64-bit
|
|
// versions where necessary to obtain correct alignment.
|
|
//
|
|
// These structs do not contain recently added fields (those that are ifdef'd
|
|
// out with #if (_WIN32_IE >= 0x0300) or later) - we go for a 'least common
|
|
// denominator' approach. The earlier, smalleer structs are accepted by both
|
|
// old and new comctl versions; but only the recent comctl versions accept
|
|
// the larger structs.
|
|
//
|
|
// (This only really matters where the struct has a cbSize field - otherwise
|
|
// a field isn't used unless it is referenced by a bit in the mask.)
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
struct LVITEM_32 {
|
|
UINT mask;
|
|
int iItem;
|
|
int iSubItem;
|
|
UINT state;
|
|
UINT stateMask;
|
|
Ptr32 pszText;
|
|
int cchTextMax;
|
|
int iImage;
|
|
LParam32 lParam;
|
|
int iIndent;
|
|
};
|
|
|
|
struct LVITEM_64 {
|
|
UINT mask;
|
|
int iItem;
|
|
int iSubItem;
|
|
UINT state;
|
|
UINT stateMask;
|
|
UINT for_alignment;
|
|
Ptr64 pszText;
|
|
int cchTextMax;
|
|
int iImage;
|
|
LParam64 lParam;
|
|
int iIndent;
|
|
};
|
|
|
|
|
|
// LVITEM_V6 structs are extensions of the old ones...
|
|
struct LVITEM_V6_32: public LVITEM_32
|
|
{
|
|
int iGroupId;
|
|
UINT cColumns;
|
|
Ptr32 puColumns;
|
|
};
|
|
|
|
struct LVITEM_V6_64: public LVITEM_64
|
|
{
|
|
int iGroupId;
|
|
UINT cColumns;
|
|
Ptr64 puColumns;
|
|
};
|
|
|
|
struct LVGROUP_V6_32
|
|
{
|
|
UINT cbSize;
|
|
UINT mask;
|
|
Ptr32 pszHeader;
|
|
int cchHeader;
|
|
|
|
Ptr32 pszFooter;
|
|
int cchFooter;
|
|
|
|
int iGroupId;
|
|
|
|
UINT stateMask;
|
|
UINT state;
|
|
UINT uAlign;
|
|
};
|
|
|
|
struct LVGROUP_V6_64
|
|
{
|
|
UINT cbSize;
|
|
UINT mask;
|
|
Ptr64 pszHeader;
|
|
int cchHeader;
|
|
|
|
Ptr64 pszFooter;
|
|
int cchFooter;
|
|
|
|
int iGroupId;
|
|
|
|
UINT stateMask;
|
|
UINT state;
|
|
UINT uAlign;
|
|
};
|
|
|
|
|
|
|
|
struct LVCOLUMN_32 {
|
|
UINT mask;
|
|
int fmt;
|
|
int cx;
|
|
Ptr32 pszText;
|
|
int cchTextMax;
|
|
int iSubItem;
|
|
};
|
|
|
|
struct LVCOLUMN_64 {
|
|
UINT mask;
|
|
int fmt;
|
|
int cx;
|
|
UINT for_alignment;
|
|
Ptr64 pszText;
|
|
int cchTextMax;
|
|
int iSubItem;
|
|
};
|
|
|
|
|
|
|
|
struct HDITEM_32 {
|
|
UINT mask;
|
|
int cxy;
|
|
Ptr32 pszText;
|
|
HBitmap32 hbm;
|
|
int cchTextMax;
|
|
int fmt;
|
|
LParam32 lParam;
|
|
int iImage;
|
|
int iOrder;
|
|
};
|
|
|
|
struct HDITEM_64 {
|
|
UINT mask;
|
|
int cxy;
|
|
Ptr64 pszText;
|
|
HBitmap64 hbm;
|
|
int cchTextMax;
|
|
int fmt;
|
|
LParam64 lParam;
|
|
int iImage;
|
|
int iOrder;
|
|
};
|
|
|
|
struct TCITEM_32 {
|
|
UINT mask;
|
|
DWORD dwState;
|
|
DWORD dwStateMask;
|
|
Ptr32 pszText;
|
|
int cchTextMax;
|
|
int iImage;
|
|
LParam32 lParam;
|
|
};
|
|
|
|
struct TCITEM_64 {
|
|
UINT mask;
|
|
DWORD dwState;
|
|
DWORD dwStateMask;
|
|
UINT for_alignment;
|
|
Ptr64 pszText;
|
|
int cchTextMax;
|
|
int iImage;
|
|
LParam64 lParam;
|
|
};
|
|
|
|
struct TOOLINFO_32 {
|
|
UINT cbSize;
|
|
UINT uFlags;
|
|
HWnd32 hwnd;
|
|
WPARAM uId;
|
|
RECT rect;
|
|
HInstance32 hinst;
|
|
Ptr32 lpszText;
|
|
};
|
|
|
|
struct TOOLINFO_64 {
|
|
UINT cbSize;
|
|
UINT uFlags;
|
|
HWnd64 hwnd;
|
|
WPARAM uId;
|
|
RECT rect;
|
|
HInstance64 hinst;
|
|
Ptr64 lpszText;
|
|
};
|
|
|
|
|
|
struct TTGETTITLE_32
|
|
{
|
|
DWORD dwSize;
|
|
UINT uTitleBitmap;
|
|
UINT cch;
|
|
Ptr32 pszTitle;
|
|
};
|
|
|
|
struct TTGETTITLE_64
|
|
{
|
|
DWORD dwSize;
|
|
UINT uTitleBitmap;
|
|
UINT cch;
|
|
UINT for_alignment;
|
|
Ptr64 pszTitle;
|
|
};
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Handlers for the common controls message handlers
|
|
//
|
|
// The basic structure of these is:
|
|
//
|
|
// 1. Determine if extra storage is needed for text.
|
|
// 2. Allocate storage
|
|
// 3. Fill a local struct that has the same bitness as the target
|
|
// 4. Copy that struct to the remote process, do the SendMessage, and copy
|
|
// the struct back
|
|
// 5. Copy fields from that struct back to the local one
|
|
// 6. Copy any extra data back (usually text) if necessary
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
|
template <class T>
|
|
HRESULT ListView_Get_Handler( T & lvDest, HWND hwnd, UINT uiMsg, WPARAM wParam, LVITEM * pItemSrc, BOOL fCheckSend, UINT )
|
|
{
|
|
// work out required size of target struct, and allocate...
|
|
DWORD dwTextSize = 0;
|
|
if(pItemSrc->mask & LVIF_TEXT)
|
|
dwTextSize = sizeof(TCHAR) * (pItemSrc->cchTextMax + 1);
|
|
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T), dwTextSize ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
lvDest.mask = pItemSrc->mask;
|
|
lvDest.iItem = pItemSrc->iItem;
|
|
lvDest.iSubItem = pItemSrc->iSubItem;
|
|
lvDest.pszText = xsh.GetExtraPtr();
|
|
lvDest.cchTextMax = pItemSrc->cchTextMax;
|
|
|
|
|
|
if( ! xsh.WriteSendMsgRead( & lvDest, hwnd, uiMsg, wParam, fCheckSend ) )
|
|
return E_FAIL;
|
|
|
|
// Copy back the struct out members...
|
|
pItemSrc->state = lvDest.state;
|
|
pItemSrc->stateMask = lvDest.stateMask;
|
|
pItemSrc->iImage = lvDest.iImage;
|
|
pItemSrc->lParam = lvDest.lParam;
|
|
pItemSrc->iIndent = lvDest.iIndent;
|
|
|
|
// Copy text back out separately...
|
|
if( ! xsh.ReadExtra( pItemSrc->pszText, lvDest.pszText, TRUE ) )
|
|
return E_FAIL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
template <class T> // T is one of the LVITEM types
|
|
HRESULT ListView_Set_Handler( T & lvDest, HWND hwnd, UINT uiMsg, WPARAM wParam, LVITEM *pItemSrc, BOOL fCheckSend, UINT )
|
|
{
|
|
// work out required size of target struct, and allocate...
|
|
DWORD dwTextSize = 0;
|
|
if(pItemSrc->mask & LVIF_TEXT)
|
|
dwTextSize = sizeof(TCHAR) * (pItemSrc->cchTextMax + 1);
|
|
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T), dwTextSize ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
lvDest.mask = pItemSrc->mask;
|
|
lvDest.iItem = pItemSrc->iItem;
|
|
lvDest.iSubItem = pItemSrc->iSubItem;
|
|
lvDest.pszText = xsh.GetExtraPtr();
|
|
lvDest.cchTextMax = pItemSrc->cchTextMax;
|
|
lvDest.state = pItemSrc->state;
|
|
lvDest.stateMask = pItemSrc->stateMask;
|
|
lvDest.iImage = pItemSrc->iImage;
|
|
lvDest.lParam = pItemSrc->lParam;
|
|
lvDest.iIndent = pItemSrc->iIndent;
|
|
|
|
xsh.WriteSendMsg( & lvDest, hwnd, uiMsg, wParam, fCheckSend );
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
template <class T>
|
|
HRESULT ListView_GetCol_Handler( T & lvDest, HWND hwnd, UINT uiMsg, WPARAM wParam, LVCOLUMN * pItemSrc, BOOL fCheckSend, UINT )
|
|
{
|
|
// work out required size of target struct, and allocate...
|
|
DWORD dwTextSize = 0;
|
|
if(pItemSrc->mask & LVCF_TEXT)
|
|
dwTextSize = sizeof(TCHAR) * (pItemSrc->cchTextMax + 1);
|
|
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T), dwTextSize ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
lvDest.mask = pItemSrc->mask;
|
|
lvDest.iSubItem = pItemSrc->iSubItem;
|
|
lvDest.pszText = xsh.GetExtraPtr();
|
|
lvDest.cchTextMax = pItemSrc->cchTextMax;
|
|
|
|
if( ! xsh.WriteSendMsgRead( & lvDest, hwnd, uiMsg, wParam, fCheckSend ) )
|
|
return E_FAIL;
|
|
|
|
// Copy text back out separately...
|
|
if( ! xsh.ReadExtra( pItemSrc->pszText, lvDest.pszText, TRUE ) )
|
|
return E_FAIL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
HRESULT ListView_V6_Get_Handler( T & lvDest, HWND hwnd, UINT uiMsg, WPARAM wParam, LVITEM_V6 * pItemSrc, BOOL fCheckSend, UINT )
|
|
{
|
|
// This version only gets column information, not text...
|
|
|
|
DWORD dwExtraSize = 0;
|
|
if(pItemSrc->mask & LVIF_COLUMNS)
|
|
dwExtraSize = sizeof(UINT) * (pItemSrc->cColumns);
|
|
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T), dwExtraSize ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
lvDest.mask = pItemSrc->mask;
|
|
lvDest.iItem = pItemSrc->iItem;
|
|
lvDest.iSubItem = pItemSrc->iSubItem;
|
|
lvDest.cColumns = pItemSrc->cColumns;
|
|
lvDest.puColumns = xsh.GetExtraPtr();
|
|
|
|
// LVM_GETITEM/LVIF_COLUMNS returns FALSE when puColumns is NULL, even though it
|
|
// does set cColumns to the size required. So we should only check that SendMessage
|
|
// returns TRUE when puColumns is non-NULL.
|
|
if( ! xsh.WriteSendMsgRead( & lvDest, hwnd, uiMsg, wParam, fCheckSend ) )
|
|
return E_FAIL;
|
|
|
|
// Copy back the struct out members...
|
|
pItemSrc->cColumns = lvDest.cColumns;
|
|
pItemSrc->iGroupId = lvDest.iGroupId;
|
|
|
|
// Copy columns back out separately...
|
|
// UINTs are the same on 64 vs 32, so don't need extra processing here.
|
|
if( ! xsh.ReadExtra( pItemSrc->puColumns, lvDest.puColumns, FALSE ) )
|
|
return E_FAIL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
HRESULT ListView_V6_GetGroup_Handler( T & lvDest, HWND hwnd, UINT uiMsg, WPARAM wParam, LVGROUP_V6 * pItemSrc, BOOL fCheckSend, UINT )
|
|
{
|
|
DWORD dwTextSize = 0;
|
|
if( pItemSrc->mask & LVGF_HEADER )
|
|
dwTextSize = sizeof(TCHAR) * (pItemSrc->cchHeader + 1);
|
|
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T), dwTextSize ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
lvDest.cbSize = pItemSrc->cbSize;
|
|
lvDest.mask = pItemSrc->mask;
|
|
lvDest.pszHeader = xsh.GetExtraPtr();
|
|
lvDest.cchHeader = pItemSrc->cchHeader;
|
|
lvDest.iGroupId = pItemSrc->iGroupId;
|
|
|
|
if( ! xsh.WriteSendMsgRead( &lvDest, hwnd, uiMsg, wParam, fCheckSend ) )
|
|
return E_FAIL;
|
|
|
|
// Copy text back out separately...
|
|
if( ! xsh.ReadExtra( pItemSrc->pszHeader, lvDest.pszHeader, TRUE ) )
|
|
return E_FAIL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
HRESULT HeaderCtrl_Get_Handler( T & hdDest, HWND hwnd, UINT uiMsg, WPARAM wParam, HDITEM *pItemSrc, BOOL fCheckSend, UINT )
|
|
{
|
|
// work out required size of target struct, and allocate...
|
|
DWORD dwTextSize = 0;
|
|
if(pItemSrc->mask & HDI_TEXT)
|
|
dwTextSize = sizeof(TCHAR) * (pItemSrc->cchTextMax + 1);
|
|
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T), dwTextSize ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
hdDest.mask = pItemSrc->mask;
|
|
hdDest.pszText = xsh.GetExtraPtr();
|
|
hdDest.cchTextMax = pItemSrc->cchTextMax;
|
|
|
|
if( ! xsh.WriteSendMsgRead( & hdDest, hwnd, uiMsg, wParam, fCheckSend ) )
|
|
return E_FAIL;
|
|
|
|
// Copy back the struct out members...
|
|
pItemSrc->cxy = hdDest.cxy;
|
|
pItemSrc->hbm = hdDest.hbm;
|
|
pItemSrc->fmt = hdDest.fmt;
|
|
pItemSrc->lParam = hdDest.lParam;
|
|
pItemSrc->iImage = hdDest.iImage;
|
|
pItemSrc->iOrder = hdDest.iOrder;
|
|
|
|
// Copy text back out separately...
|
|
if( ! xsh.ReadExtra( pItemSrc->pszText, hdDest.pszText, TRUE ) )
|
|
return E_FAIL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
template <class T>
|
|
HRESULT TabCtrl_Get_Handler( T & tcDest, HWND hwnd, UINT uiMsg, WPARAM wParam, TCITEM *pItemSrc, BOOL fCheckSend, UINT )
|
|
{
|
|
// work out required size of target struct, and allocate...
|
|
DWORD dwTextSize = 0;
|
|
if(pItemSrc->mask & TCIF_TEXT)
|
|
dwTextSize = sizeof(TCHAR) * (pItemSrc->cchTextMax + 1);
|
|
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T) + CBEXTRA_TRAYTAB, dwTextSize ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
tcDest.mask = pItemSrc->mask;
|
|
tcDest.dwState = pItemSrc->dwState;
|
|
tcDest.dwStateMask = pItemSrc->dwStateMask;
|
|
tcDest.pszText = xsh.GetExtraPtr();
|
|
tcDest.cchTextMax = pItemSrc->cchTextMax;
|
|
tcDest.iImage = pItemSrc->iImage;
|
|
tcDest.lParam = pItemSrc->lParam;
|
|
|
|
if( ! xsh.WriteSendMsgRead( & tcDest, hwnd, uiMsg, wParam, fCheckSend ) )
|
|
return E_FAIL;
|
|
|
|
// Copy back the struct out members...
|
|
pItemSrc->dwState = tcDest.dwState;
|
|
pItemSrc->dwStateMask = tcDest.dwStateMask;
|
|
pItemSrc->iImage = tcDest.iImage;
|
|
pItemSrc->lParam = tcDest.lParam;
|
|
|
|
// Copy text back out separately...
|
|
if( ! xsh.ReadExtra( pItemSrc->pszText, tcDest.pszText, TRUE ) )
|
|
return E_FAIL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
template <class T>
|
|
HRESULT ToolInfo_Get_Handler( T & tiDest, HWND hwnd, UINT uiMsg, WPARAM wParam, TOOLINFO *pItemSrc, BOOL fCheckSend, UINT cchTextMax )
|
|
{
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T), sizeof(TCHAR) * cchTextMax ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
tiDest.cbSize = sizeof( tiDest );
|
|
tiDest.uFlags = pItemSrc->uFlags;
|
|
tiDest.uId = pItemSrc->uId;
|
|
tiDest.hwnd = pItemSrc->hwnd;
|
|
tiDest.lpszText = xsh.GetExtraPtr();
|
|
|
|
// Don't fail if the message is TTM_GETTEXT and 0 is returned - that's OK for that message.
|
|
// (TTM_GETTEXT has no documented return value!)
|
|
if( ! xsh.WriteSendMsgRead( & tiDest, hwnd, uiMsg, wParam, fCheckSend ) )
|
|
return E_FAIL;
|
|
|
|
// Copy back the struct out members...
|
|
pItemSrc->uFlags = tiDest.uFlags;
|
|
pItemSrc->uId = tiDest.uId;
|
|
pItemSrc->rect = tiDest.rect;
|
|
|
|
// Copy text back out...
|
|
if( ! xsh.ReadExtra( pItemSrc->lpszText, tiDest.lpszText, TRUE ) )
|
|
return E_FAIL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
HRESULT ToolInfo_GetTitle_Handler( T & tiDest, HWND hwnd, UINT uiMsg, WPARAM wParam, TTGETTITLE *pItemSrc, BOOL fCheckSend, UINT )
|
|
{
|
|
CXSendHelper xsh;
|
|
if( ! xsh.Alloc( hwnd, sizeof(T), sizeof(TCHAR) * pItemSrc->cch ) )
|
|
return E_OUTOFMEMORY;
|
|
|
|
// Copy to remote struct...
|
|
tiDest.dwSize = sizeof( tiDest );
|
|
tiDest.cch = pItemSrc->cch;
|
|
tiDest.pszTitle = xsh.GetExtraPtr();
|
|
|
|
if( ! xsh.WriteSendMsgRead( & tiDest, hwnd, uiMsg, wParam, fCheckSend ) )
|
|
return E_FAIL;
|
|
|
|
// Copy back the struct out members...
|
|
pItemSrc->uTitleBitmap = tiDest.uTitleBitmap;
|
|
|
|
// Copy text back out...
|
|
if( ! xsh.ReadExtra( pItemSrc->pszTitle, tiDest.pszTitle, TRUE ) )
|
|
return E_FAIL;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Cross-proc sendmessage stub macro
|
|
//
|
|
// All cross-proc SendMessage code has the same basic structure - some tests
|
|
// to determine if a cross proc send message is needed in the first place -
|
|
// if not, we can do a regular local SendMessage instead.
|
|
// If we do need to do a remote SendMessage, we call either a 32-bit or 64-bit
|
|
// "handler" routine based on the bitness of the target proxy.
|
|
//
|
|
// Since this code is the same for all cases, a #define is used to avoid
|
|
// duplication of code.
|
|
//
|
|
//
|
|
// DEFINE_XSEND_STUB takes the following parameters:
|
|
//
|
|
// Name - the name of the function being defined
|
|
// Handler - the name of the cross-proc handler (see above)
|
|
// Type - base type used.
|
|
// CheckSendExpr - expression that indicates if the result of SendMessage
|
|
// should be checked. Most - but not all - messages return
|
|
// TRUE to indicate success.
|
|
//
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
|
|
// For a given type - eg. LVITEM - this macro sets LVITEM_THIS and
|
|
// LVITEM_REMOTE to be typedef'd to LVITEM_32 and LVITEM_64 as appropriate,
|
|
// depending on whether this is 32- or 64- bit code.
|
|
//
|
|
// This relies on the base struct (eg. LVITEM) having the same base name as the
|
|
// explicit 32- and 64- bit structs which are defined above.
|
|
|
|
#ifdef _WIN64
|
|
#define DEFINE_TYPE_6432( Type ) typedef Type ## _64 Type ## _THIS; typedef Type ## _32 Type ## _REMOTE;
|
|
#else
|
|
#define DEFINE_TYPE_6432( Type ) typedef Type ## _32 Type ## _THIS; typedef Type ## _64 Type ## _REMOTE;
|
|
#endif
|
|
|
|
|
|
#define DEFINE_XSEND_STUB( Name, Handler, Type, CheckSendExpr ) /**/ \
|
|
HRESULT Name ( HWND hwnd, UINT uiMsg, WPARAM wParam, Type * pItem, UINT uiParam )\
|
|
{\
|
|
/* Optimize if in same process...*/\
|
|
DWORD dwProcessId;\
|
|
if( ! GetWindowThreadProcessId( hwnd, & dwProcessId ) )\
|
|
return E_FAIL;\
|
|
\
|
|
BOOL fCheckSend = CheckSendExpr;\
|
|
\
|
|
if( dwProcessId == GetCurrentProcessId() )\
|
|
{\
|
|
DBPRINTF( TEXT("Inprocess") );\
|
|
if( ! SendMessage( hwnd, uiMsg, wParam, (LPARAM) pItem ) && fCheckSend )\
|
|
{\
|
|
DBPRINTF( TEXT("SendMessag failed") );\
|
|
return E_FAIL;\
|
|
}\
|
|
\
|
|
return S_OK;\
|
|
}\
|
|
\
|
|
/* Otherwise pass the correct type off to the template function...*/\
|
|
BOOL fIsSameBitness;\
|
|
if( FAILED( SameBitness( hwnd, & fIsSameBitness ) ) )\
|
|
return E_FAIL;\
|
|
\
|
|
if( fIsSameBitness )\
|
|
{\
|
|
Type ## _THIS t;\
|
|
memset( & t, 0, sizeof( t ) );\
|
|
return Handler( t, hwnd, uiMsg, wParam, pItem, fCheckSend, uiParam );\
|
|
}\
|
|
else\
|
|
{\
|
|
Type ## _REMOTE t;\
|
|
memset( & t, 0, sizeof( t ) );\
|
|
return Handler( t, hwnd, uiMsg, wParam, pItem, fCheckSend, uiParam );\
|
|
}\
|
|
}
|
|
|
|
|
|
DEFINE_TYPE_6432( LVITEM )
|
|
DEFINE_TYPE_6432( LVITEM_V6 )
|
|
DEFINE_TYPE_6432( LVGROUP_V6 )
|
|
DEFINE_TYPE_6432( LVCOLUMN )
|
|
DEFINE_TYPE_6432( TCITEM )
|
|
DEFINE_TYPE_6432( HDITEM )
|
|
DEFINE_TYPE_6432( TOOLINFO )
|
|
DEFINE_TYPE_6432( TTGETTITLE )
|
|
|
|
DEFINE_XSEND_STUB( XSend_ListView_GetItem, ListView_Get_Handler, LVITEM, TRUE )
|
|
DEFINE_XSEND_STUB( XSend_ListView_SetItem, ListView_Set_Handler, LVITEM, FALSE )
|
|
DEFINE_XSEND_STUB( XSend_ListView_GetColumn, ListView_GetCol_Handler, LVCOLUMN, TRUE )
|
|
DEFINE_XSEND_STUB( XSend_ListView_V6_GetItem, ListView_V6_Get_Handler, LVITEM_V6, pItem->puColumns != NULL )
|
|
DEFINE_XSEND_STUB( XSend_ListView_V6_GetGroupInfo, ListView_V6_GetGroup_Handler, LVGROUP_V6, TRUE )
|
|
DEFINE_XSEND_STUB( XSend_TabCtrl_GetItem, TabCtrl_Get_Handler, TCITEM, TRUE )
|
|
DEFINE_XSEND_STUB( XSend_HeaderCtrl_GetItem, HeaderCtrl_Get_Handler, HDITEM, TRUE )
|
|
DEFINE_XSEND_STUB( XSend_ToolTip_GetItem, ToolInfo_Get_Handler, TOOLINFO, uiMsg != TTM_GETTEXT )
|
|
DEFINE_XSEND_STUB( XSend_ToolTip_GetTitle, ToolInfo_GetTitle_Handler, TTGETTITLE, TRUE )
|
|
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// GetRemoteProxyFactory()
|
|
//
|
|
// Returns an AddRef'd proxy factory for the other bitness
|
|
//
|
|
|
|
CComPtr<IRemoteProxyFactory> g_pRemoteProxyFactory; // Only a single instance. CComPtr
|
|
// will release on dll unload.
|
|
|
|
HRESULT GetRemoteProxyFactory(IRemoteProxyFactory **pRPF)
|
|
{
|
|
if (IsBadWritePtr(pRPF, sizeof(IRemoteProxyFactory *)))
|
|
return E_POINTER;
|
|
|
|
*pRPF = NULL;
|
|
|
|
if (!g_pRemoteProxyFactory)
|
|
{
|
|
HRESULT hr = CoCreateInstance(
|
|
#ifdef _WIN64
|
|
CLSID_RemoteProxyFactory32
|
|
#else
|
|
CLSID_RemoteProxyFactory64
|
|
#endif
|
|
, NULL
|
|
, CLSCTX_LOCAL_SERVER
|
|
, IID_IRemoteProxyFactory
|
|
, reinterpret_cast<void **>(&g_pRemoteProxyFactory));
|
|
|
|
if (FAILED(hr))
|
|
{
|
|
DBPRINTF(TEXT("GetRemoteProxyFactory: CoCreateInstance FAILED "));
|
|
#ifdef _WIN64
|
|
DBPRINTF(TEXT("for clsid 0x%x\r\n"), CLSID_RemoteProxyFactory32.Data1);
|
|
#else
|
|
DBPRINTF(TEXT("for clsid 0x%x\r\n"), CLSID_RemoteProxyFactory64.Data1);
|
|
#endif
|
|
return hr;
|
|
}
|
|
|
|
if (!g_pRemoteProxyFactory)
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
DBPRINTF(TEXT("GetRemoteProxyFactory: CoCreateInstance SUCCEEDED\r\n"));
|
|
*pRPF = g_pRemoteProxyFactory;
|
|
(*pRPF)->AddRef();
|
|
|
|
return S_OK;
|
|
}
|