// olerem.h - private defintions for OLE implementation of REMoting
#if !defined( _OLEREM_H_ )
#define _OLEREM_H_
// name changes
#define ILrpc IRpcChannel
#define IStub IRpcStub
#define IProxy IRpcProxy
#define Dispatch Invoke
#define IID_ILrpc IID_IRpcChannel
#define IID_IStub IID_IRpcStub
#define IID_IProxy IID_IRpcProxy
// -----------------------------------------------------------------------
// init/term
STDAPI RemInitialize(void);
STDAPI_(void) RemUninitialize(void);
#ifdef _MAC
// entry point for lrpc HLE's
STDAPI RemProcessLrpcHLE(EventRecord *pHle);
#endif
// -----------------------------------------------------------------------
// Communications Layer
typedef LONG OID;
STDAPI_(OID) RemAllocOID(interface IStubManager FAR* pSM);
STDAPI_(BOOL) RemFreeOID(OID oid);
// NOTE: ILrpc defined in stdps.h
STDAPI RemConnectToObject(OID oid, ILrpc FAR* FAR* ppLrpc);
STDAPI RemDisconnectObject(OID oid, DWORD dwReserved);
// -----------------------------------------------------------------------
// State Management
// Class Factory Table
STDAPI RemRegisterFactory(REFCLSID rclsid, IUnknown FAR* pUnk, DWORD dwContext,
DWORD flags, LPDWORD lpdwRegister);
STDAPI RemRevokeFactory(DWORD dwRegister, LPCLSID lpclsid,
IUnknown FAR* FAR* ppUnk, LPDWORD lpdwContext);
STDAPI RemLookupFactory(REFCLSID rclsid, BOOL fHide, OID FAR *pOid);
// Handler Table
interface IProxyManager : public IUnknown
{
STDMETHOD(CreateServer)(REFCLSID rclsid) = 0;
STDMETHOD(Connect)(OID oid, REFCLSID rclsid) = 0;
STDMETHOD(LockConnection)(BOOL fLock, BOOL fLastUnlockReleases) = 0;
STDMETHOD_(void, GetClassID)(CLSID FAR* pClsid) = 0;
STDMETHOD_(OID, GetOID)() = 0;
STDMETHOD_(BOOL, IsConnected)(void) = 0;
STDMETHOD(EstablishIID)(REFIID iid, LPVOID FAR* ppv) = 0;
STDMETHOD_(void, Disconnect)() = 0;
};
INTERNAL RemSetHandler(OID oid, REFCLSID clsid, IProxyManager FAR* pPM);
INTERNAL RemClearHandler(OID oid, IProxyManager FAR* pPM);
// Server Table
interface IStubManager : public IUnknown
{
STDMETHOD_(void, SetReg)(OID oid) = 0;
STDMETHOD_(void, Connect)(IUnknown FAR* pUnk) = 0;
STDMETHOD_(void, Disconnect)() = 0;
STDMETHOD_(OID, GetOID)() = 0;
STDMETHOD_(IUnknown FAR*, GetServer)(BOOL fAddRef) = 0;
STDMETHOD_(void, AddRefRegConn)(DWORD mshlflags) = 0;
STDMETHOD_(void, ReleaseRegConn)(DWORD mshlflags, BOOL fLastUR) = 0;
STDMETHOD (Dispatch)(REFIID iid, int iMethod, IStream FAR* pIStream,
DWORD dwDestCtx, LPVOID lpvDestCtx, BOOL FAR* lpfStrongConn) = 0;
};
// tables are now merged; combined registration:
// MSHLHDR: first part of what is written to marshal stream
struct FAR MSHLHDR
{
CLSID clsid; // oid == NULL -> unmarshal class
// oid != NULL -> class of handler
OID oid; // global id for object
DWORD mshlflags; // marshal flags
};
struct FAR SHREG
{
MSHLHDR m_hdr; // simplifies things; see below
IUnknown FAR* m_pUnkLookup; // NOTE: no addref
IStubManager FAR* m_pSM; // if NULL, have handler
};
// There are two forms of SHREG:
// 1. server registration:
// m_hdr.clsid is class of handler
// m_hdr.oid is non-NULL
// m_hdr.mshlflags is NULL
// m_pUnkLookup = non-addref'd pointer to server; not necessarily valid
// (not valid when stubmgr disconnected, but still registered)
// m_pSM = addref'd pointer to stubmgr.
//
// 2. handler registration (when connected to server)
// m_hdr.clsid is class of handler (same as above)
// m_hdr.oid is non-NULL
// m_hdr.mshlflags is NULL
// m_pUnkLookup = non-addref'd pProxyManager of handler; always valid
// m_pSM = NULL
//
// NOTE: the MSHLHDR is present in the SHREG so as to make CoMarshalInterface
// faster. The m_hdr.mshlflags is always zero in a reg entry; is set before
// writing the hdr to a stream.
//
// We get and save the clsid so that we don't have to figure it out each
// time we marshal the interface.
// see olerem2.h for inline functions that manipulate SHREGs.
STDAPI RemRegisterServer(IUnknown FAR* pUnk, DWORD mshlflags, SHREG FAR* pshreg);
STDAPI RemRevokeServer(OID oid);
STDAPI RemLookupSHOID(OID oid, IProxyManager FAR* FAR* ppPM,
IStubManager FAR* FAR* ppSM);
STDAPI RemLookupSHUnk(IUnknown FAR* pUnkGiven, IUnknown FAR* FAR* ppUnkServer, SHREG FAR* pshreg);
// -----------------------------------------------------------------------
// Other Routines
STDAPI RemCreateRemoteHandler(REFCLSID rclsid, IUnknown FAR* pUnkOuter, REFIID riid, void FAR* FAR* ppv);
INTERNAL RemCreateRHClassObject(REFCLSID rclsid, IID iid, void FAR* FAR* ppv);
INTERNAL RemEnsureLocalClassObject(REFCLSID rclsid, OID FAR* pOidCF);
INTERNAL RemEnsureUniqueHandler(REFCLSID rclsid, OID oid,
IUnknown FAR* FAR* ppUnk, IProxyManager FAR* FAR* ppPM);
// REVIEW MM2 (craigwi): these aren't used much; do we keep them?
/* -----------------------------------------------------------------------
* Proxy/Stub macros
*
* The follwoing macros can be used to implement Proxy/Stub classes for
* classes that support only one or more interfaces other then IUnknown
* (and maybe IDebug). The resulting classes will support IProxy, IStub
* interface in addition to the interfaces supported by the original class.
* Assuming the interfaces supported is IName and it is implemented
* by a class CName:
*
* Declaration (in *.h):
*
* class CName { class CNameProxy { class CNameStub {
* ............ ............ ............
* STDUNKDECL(CName,Name) STDUNKDECL(CNameProxy,NameProxy) STDUNKDECL(CNameStub,NameStub)
* STDDEBDECL(CName,Name) STDDEBDECL(CNameProxy,NameProxy) STDDEBDECL(CNameStub,NameStub)
* STDPROXYDECL(CNameProxy,NameProxy) STDSTUBDECL(NameStub,1)
* <IName Declaration> <IName for proxy> <IName for stub>
* ............ ............ ............
* }; }; };
*
* Implementation (in *.cpp):
*
* For original object:
*
* STDUNKIMPL(Name)
*
* STDUNK_QI_IMPL(Name,Name)
*
* STDUNKIMPL_FORDERIVED(Name,NameImpl)
*
* <Implementation of IName: CNameImpl>
*
*
* For proxy object:
*
* STDUNKIMPL(NameProxy)
*
* STDUNK_PROXY_QI_IMPL(NameProxy,Name)
*
* STDUNKIMPL_FORDERIVED(NameProxy,NameProxyImpl)
*
* STDPROXYIMPL(NameProxy)
*
* <Implementation of IName: CNameProxyImpl>
*
*
* For stub object:
*
* STDUNKIMPL(NameStub)
*
* STDUNK_STUB_QI_IMPL(NameStub,Name)
*
* STDUNKIMPL_FORDERIVED(NameStub,NameStubImpl)
*
* STDSTUBIMPL(NameStub)
*
* <Implementation of IName: CNameStubImpl>
*
*
*/
// Mattp: I have moved the body of destructor to the implementation macro. ( STDPROXYIMPL)
#define STDPROXYDECL(ignore, classname) \
implement CProxy : IProxy { public: \
CProxy(C##classname FAR* p##classname) \
{ m_p##classname = p##classname; } \
~CProxy(void); \
STDMETHOD(QueryInterface)(REFIID iid, LPLPVOID ppvObj);\
STDMETHOD_(ULONG,AddRef)(void); \
STDMETHOD_(ULONG,Release)(void); \
STDMETHOD(Connect)(ILrpc FAR* pILrpc); \
STDMETHOD_(void, Disconnect)(void); \
private: C##classname FAR* m_p##classname; }; \
DECLARE_NC(C##classname,CProxy) \
CProxy m_Proxy;
#define STDSTUBDECL(ignore, classname,cIface) \
implement CStub : IStub { public: \
CStub(C##classname FAR* p##classname) \
{ m_p##classname = p##classname; m_pUnkObject = NULL; } \
~CStub(void) \
{ M_PROLOG(m_p##classname); if (m_pUnkObject != NULL) m_pUnkObject->Release(); } \
INTERNAL_(BOOL) Init(IUnknown FAR* pUnkObject); \
STDMETHOD(QueryInterface)(REFIID iid, LPLPVOID ppvObj);\
STDMETHOD_(ULONG,AddRef)(void); \
STDMETHOD_(ULONG,Release)(void); \
STDMETHOD(Connect)(IUnknown FAR* pUnkObject); \
STDMETHOD_(void, Disconnect)(void); \
STDMETHOD(Dispatch)(REFIID iid, int iMethod, IStream FAR* pIStream, \
DWORD dwDestCtx, LPVOID lpvDestCtx); \
STDMETHOD_(BOOL, IsIIDSupported)(REFIID iid); \
STDMETHOD_(ULONG, CountRefs)(void); \
private: C##classname FAR* m_p##classname; \
IUnknown FAR* m_pUnkObject; \
IUnknown FAR* m_aStubIface[cIface]; }; \
DECLARE_NC(C##classname,CStub) \
CStub m_Stub;
#define CONSTRUCT_PROXY m_Proxy(this),
#define CONSTRUCT_STUB m_Stub(this),
#define STDUNK_PROXY_QI_IMPL(classname,interfacename) \
STDMETHODIMP NC(C##classname,CUnknownImpl)::QueryInterface \
(REFIID iidInterface, void FAR* FAR* ppv) { \
M_PROLOG(m_p##classname); \
if (iidInterface == IID_IUnknown) \
{ *ppv = (void FAR*)&m_p##classname->m_Unknown; AddRef(); noError; } \
else if (iidInterface == IID_I##interfacename) \
{ *ppv = (void FAR*) &(m_p##classname->m_##classname); \
m_p##classname->m_pUnkOuter->AddRef(); noError; } \
else if (iidInterface == IID_IProxy) \
{ *ppv = (void FAR*) &(m_p##classname->m_Proxy); AddRef(); noError; } \
else \
STDDEB_QI(classname) \
{ *ppv = NULL; return ResultFromScode(E_NOINTERFACE); } \
}
#define STDUNK_STUB_QI_IMPL(classname,interfacename) \
STDMETHODIMP NC(C##classname,CUnknownImpl)::QueryInterface \
(REFIID iidInterface, void FAR* FAR* ppv) { \
A5_PROLOG(m_p##classname); \
if (iidInterface == IID_IUnknown) \
*ppv = (void FAR*)&m_p##classname->m_Unknown; \
else if (iidInterface == IID_IStub) \
*ppv = (void FAR*) &(m_p##classname->m_Stub); \
else \
STDDEB_QI(classname) \
{ *ppv = NULL; RESTORE_A5(); return ResultFromScode(E_NOINTERFACE); } \
++(m_p##classname->m_refs); RESTORE_A5(); noError; }
// Mattp: The destructor implementation has been moved to here to allow us the outer
// reference to 'm_pILrpc'.
#define STDPROXYIMPL(classname) \
NC(C##classname,CProxy)::~CProxy(void) \
{ M_PROLOG(m_p##classname);if (m_p##classname->m_pILrpc) m_p##classname->m_pILrpc->Release();}\
STDMETHODIMP NC(C##classname,CProxy)::QueryInterface(REFIID iid, LPLPVOID ppvObj) \
{ M_PROLOG(m_p##classname);return m_p##classname->m_Unknown.QueryInterface (iid, ppvObj); } \
STDMETHODIMP_(ULONG) NC(C##classname,CProxy)::AddRef(void) \
{ M_PROLOG(m_p##classname);return m_p##classname->m_Unknown.AddRef(); } \
STDMETHODIMP_(ULONG) NC(C##classname,CProxy)::Release(void) \
{ M_PROLOG(m_p##classname);return m_p##classname->m_Unknown.Release(); } \
STDMETHODIMP NC(C##classname,CProxy)::Connect(ILrpc FAR* pILrpc) \
{ \
M_PROLOG(m_p##classname); \
if (pILrpc) { \
pILrpc->AddRef(); \
m_p##classname->m_pILrpc = pILrpc; \
return NOERROR; \
} else \
return ResultFromScode(E_UNSPEC); \
} \
STDMETHODIMP_(void) NC(C##classname,CProxy)::Disconnect(void) \
{ \
M_PROLOG(m_p##classname); \
if (m_p##classname->m_pILrpc) \
m_p##classname->m_pILrpc->Release(); \
m_p##classname->m_pILrpc = NULL; \
}
#define STDSTUBIMPL(classname) STDUNKIMPL_FORDERIVED(classname,Stub) \
STDMETHODIMP NC(C##classname,CStub)::Connect(IUnknown FAR* pUnkObject) \
{ M_PROLOG(m_p##classname);return Init(pUnkObject) ? NOERROR : ResultFromScode(E_UNSPEC); } \
STDMETHODIMP_(void) NC(C##classname,CStub)::Disconnect(void) \
{M_PROLOG(m_p##classname); Init(NULL); }
/*
* Ole2 marshalling stuff
*
* REVIEW: this should go into ole2sp.h, but ILrpc is defined here and
* olerem.h is included after ole2sp.h ...
*/
//
// MOP is a single instruction to the interpreter that encodes,
// decodes parameters sent via LRPC. A string of Mops describes how to
// marshal, unmarshal function's paramaters.
//
//
typedef enum MOP {
NilMop,
// Basic types size of type (win3.1)
Void, // No value 0b
This, // FAR* this -- Not used
Int, // (INT == int) 2b
uInt, // (UINT == unsigned int) 2b
Long, // (LONG == long) 4b
uLong, // (ULONG == unsigned long) 4b
Word, // WORD 2b
dWord, // DWORD 4b
Bool, // BOOL 2b
lpStr, // LPSTR -- (zero terminated)
lplpStr, // LPLPSTR -- (zero terminated)
pBuf, // void FAR* -- (size in following long)
// Windows types
wParam, // WPARAM 2b
lParam, // LPARAM 4b
_Handle, // HANDLE 2b
hWnd, // HWND 2b
hDc, // HDC 2b
hRgn, // HRGN 2b
hClip, // HANDLE 2b
_Point, // POINT 4b
_Size, // SIZE 4b
_Rect, // RECT 8b
Msg, // MSG 18b
// Ole/Win32 types
_Pointl, // POINTL 8b
_Sizel, // SIZEL 8b
_Rectl, // RECTL 16b
// Ole types
Hresult, // HRESULT 4b
Cid, // CID 16b
Iid, // IID 16b
wChar, // WCHAR 2b
Time, // TIME_T 4b
StatStg, // STATSTG > 38b + size of member lpstr
Layout, // OLELAYOUT 2b bad size
ClipFor, // CLIPFORMAT 2b MAC bad size
DAspect, // DVASPECT 4b
TyMed, // TYMED 4b
Verb, // OLEVERB > 14b + size of member lpstr
TDev, // DVTARGETDEVICE > 16b
SMedium, // STGMEDIUM > 12b + size of member lpstr
ForEtc, // FORMATETC > 18b + size of member tdev
StatDat, // STATDATA > 48b + size of member foretc
IFace, // interface FAR* > 40b
MenuWidths, // OLEMENUGROUP_WIDTHS 24b
hMenu, // HMENU 2b
hOMenu, // HOLEMENU 2b
hAccel, // HACCEL 2b
FrameInfo, // OLEINPLACEFRAMEINFO 10b
BindOpt, // BIND_OPTS 12b might change (02/15/2000-- not likely)
LogPal, // LOGPALETTE > 8b
ArraySize, // the following is an array arg list
GenMops, // generic mop: used for with eg. Enum Next
RunArg, // inidicates a run modifier: Min or Mout based of return or not
// ->see example
// Modifiers
MMask = 0xc0,
MIn = 0x40, // FAR Pointer to in parameter
MOut = 0x80, // FAR Pointer to out parameter
MIO = 0xc0, // FAR Pointer to in, out parameter
// Interface indexes (overlap mop values)
ILast = 1, // Use last marshalled interface
IUnk, // IUnknown
IMnk, // IMoniker
IStg, // IStorage
IDObj, // IDataObject
IVObj, // IViewObject
IOleObj, // IOleObject
IIpObj, // IOleInPlaceObject
ICSite, // IOleClientSite
IIpSite, // IOleInPlaceSite
IAdvSink, // IAdviseSink
IPDName, // IParseDisplayName
IOleCont, // IOleContainer
IOleItemCont, // IOleItemContainer
IBCtx, // IBindCtx
IEStatData, // IEnumSTATDATA
IEForEtc, // IEnumFORMATETC
IEStr, // IEnumString
IEVerbs, // IEnumOLEVERB
IEMnk, // IEnumMoniker
IOleWnd, // IOleWIndow
IIpUiWnd, // IOleInPlaceUIWindow
IIpFrame, // IOleInPlaceFrame
IIpAObj, // IOleInPlaceActiveObject
IStStream,
IEnumStatStg
} MOP;
//
// Modifiers combine with other types to indicate pointer to the type:
// - MIn values are passed on call, but not updated upon return
// - MOut values are not passed on call, but are updated upon return
// - MIO values are passed on call, and updated upon return.
//
// M** indicates the argument is a pointer to the type. For types
// which imply pointer (lpStr, pBuf, IMnk) M** indicates pointer to a pointer
// (as in LPSTR FAR*, IEnumClipFormat FAR* FAR*). For MOut the value pointed
// (i.e. the interface pointer) is ignored. MIn, MIO not supported.
//
// Interface indexes follow IFace mop to specify type of interface being
// marshalled. ILast specify last IID marshalled.
//
// By convention the return value is always an HRESULT.
//
// MOP is an 8-bit value; it fits in a BYTE. Example:
//
// static mopsSomeFunc[] { pBuf | MIn, uLong, IFace, IDObj, ..., NilMop };
//
// Example for generic mops!
// static BYTE ForEtcMop[] = { MopSize(22), ClipFor, RunArg, TDev, DAspect, Long, TyMed, NilMop };
// static BYTE mopsForEtcNext[] = { uLong, ArraySize, GenMops | MOut, MopPtr(ForEtcMop), uLong | MOut, NilMop };
//
// FNI describes how to marshal, unmarshal specific function
//
typedef int FNITYPE;
#define FNITYPE_NilFni 0
#define FNITYPE_RevArg 0x01 // Arguments pushed left-to-right (pascal)
#define FNITYPE_Clean 0x02 // Callee cleans stack (pascal)
#define FNITYPE_Method 0x04 // Class method.
#define FNITYPE_Virtual 0x08 // Virtual function
#define FNITYPE_Send 0x10 // Use SendMessage (not PostMessage)
#define FNITYPE_NoWait 0x20 // Do not wait for reply (only when PostMessage)
struct FAR FNI { // Static data for function marshalling
FNITYPE m_type; // Function description
struct { // For virtual function
const IID FAR* lpIID;// far pointer to Interface ID
int iMethod; // Method index
} m_loc; // ----
UINT m_cbStk; // Stack space for pushing all arguments
UINT m_cbStm; // Stream space for marshalling arguments
UINT m_cbExtStm; // Additional stream space for strings, buffers
BYTE FAR* m_args; // Arguments MOPs
};
//
// Example
//
//static FNI fniSomeFunc = {
// FNITYPE_Method | FNITYPE_Virtual,
// { //interface and method Indices
// &_IID_ISomeIface,
// IFUNC_SomeFunc
// },
// 64, // Stack space
// 96, // Minimun Stream space
// 48, // Estimated extra stream space
// mopsSomeFunc // The mops
//};
//
// _IID_ISomeIface is the IID for the interface of this object,
// IIFACE_SomeFunc is the index of this method within the interface.
//
STDAPI LrpcCall(ILrpc FAR* pILrpc, FNI FAR* pfni, void FAR* pFirstArg);
STDAPI LrpcDispatch(IStream FAR* pIStream, FNI FAR* pfni, void FAR* pObj);
BOOL IsValidOID(OID oid);
#endif // _OLEREM_H