|
|
// 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
|
