![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to olerem.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / h|
Return to olerem.h CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / h |
1.1 root 1: // olerem.h - private defintions for OLE implementation of REMoting
2:
3: #if !defined( _OLEREM_H_ )
4: #define _OLEREM_H_
5:
6: // name changes
7: #define ILrpc IRpcChannel
8: #define IStub IRpcStub
9: #define IProxy IRpcProxy
10: #define Dispatch Invoke
11:
12: #define IID_ILrpc IID_IRpcChannel
13: #define IID_IStub IID_IRpcStub
14: #define IID_IProxy IID_IRpcProxy
15:
16: // -----------------------------------------------------------------------
17: // init/term
18:
19: STDAPI RemInitialize(void);
20: STDAPI_(void) RemUninitialize(void);
21:
22: #ifdef _MAC
23: // entry point for lrpc HLE's
24: STDAPI RemProcessLrpcHLE(EventRecord *pHle);
25: #endif
26:
27: extern HINSTANCE hinstSO;
28:
29: // -----------------------------------------------------------------------
30: // Communications Layer
31:
32: typedef LONG OID;
33:
34: STDAPI_(OID) RemAllocOID(LPUNKNOWN pUnk);
35: STDAPI_(BOOL) RemFreeOID(OID oid);
36:
37: // NOTE: ILrpc defined in stdps.h
38:
39: STDAPI RemConnectToObject(OID oid, ILrpc FAR* FAR* ppLrpc);
40: STDAPI RemDisconnectObject(OID oid, DWORD dwReserved);
41:
42:
43: // -----------------------------------------------------------------------
44: // State Management
45:
46: // Class Factory Table
47:
48: STDAPI RemRegisterFactory(REFCLSID rclsid, IUnknown FAR* pUnk, DWORD dwContext,
49: DWORD flags, LPDWORD lpdwRegister);
50: STDAPI RemRevokeFactory(DWORD dwRegister, LPCLSID lpclsid,
51: IUnknown FAR* FAR* ppUnk, LPDWORD lpdwContext);
52: STDAPI RemLookupFactory(REFCLSID rclsid, BOOL fHide,
53: OID FAR *pOid, DWORD FAR* pCookie);
54:
55: // Handler Table
56:
57: interface IProxyManager : public IUnknown
58: {
59: STDMETHOD(CreateServer)(REFCLSID rclsid) = 0;
60: STDMETHOD(Connect)(OID oid, REFCLSID rclsid) = 0;
61: STDMETHOD_(DWORD, LockConnection)(BOOL fLock, BOOL fLastUnlockReleases) = 0;
62: STDMETHOD_(void, GetClassID)(CLSID FAR* pClsid) = 0;
63: STDMETHOD_(OID, GetOID)() = 0;
64: STDMETHOD_(BOOL, IsConnected)(void) = 0;
65: STDMETHOD(EstablishIID)(REFIID iid, LPVOID FAR* ppv) = 0;
66: STDMETHOD_(void, Disconnect)() = 0;
67: };
68:
69: STDAPI RemSetHandler(OID oid, IProxyManager FAR* pPM);
70: STDAPI RemClearHandler(OID oid);
71: STDAPI RemLookupHandler(OID oid, IProxyManager FAR* FAR* ppPM);
72:
73: #ifndef OLE2SHIP
74: STDAPI RemUninitHandlers(void);
75: STDAPI RemUninitServers(void);
76: #endif
77:
78: // Server Table
79:
80: interface IStubManager : public IUnknown
81: {
82: STDMETHOD_(void, SetReg)(OID oid) = 0;
83: STDMETHOD_(void, Connect)(IUnknown FAR* pUnk) = 0;
84: STDMETHOD_(void, Disconnect)() = 0;
85: STDMETHOD_(OID, GetOID)() = 0;
86: STDMETHOD_(IUnknown FAR*, GetServer)(BOOL fAddRef) = 0;
87: STDMETHOD_(void, AddRefRegConn)(DWORD mshlflags) = 0;
88: STDMETHOD_(void, ReleaseRegConn)(DWORD mshlflags) = 0;
89: STDMETHOD_(ULONG, ReleaseLeaveConn)(void) = 0;
90: #ifdef OLE2SHIP
91: STDMETHOD_(ULONG, ReleaseCheckConn)(void) = 0;
92: #endif
93: STDMETHOD_(void, SetPtrStrength)(BOOL fStrong) = 0;
94: STDMETHOD (Dispatch)(REFIID iid, int iMethod, IStream FAR* pIStream,
95: DWORD dwDestCtx, LPVOID lpvDestCtx) = 0;
96: };
97:
98: STDAPI RemRegisterServer(IUnknown FAR* pUnk, DWORD mshlflags, OID FAR* pOid);
99: STDAPI RemRevokeServer(OID oid);
100: STDAPI RemLookupServerUnk(OID oid, IUnknown FAR* FAR* ppUnk, IStubManager FAR* FAR* ppSM);
101: STDAPI RemLookupServerOID(IUnknown FAR* pUnk, OID FAR* oid, IStubManager FAR* FAR* ppSM);
102:
103: // -----------------------------------------------------------------------
104: // Other Routines
105:
106: STDAPI RemCreateRemoteHandler(REFCLSID rclsid, IUnknown FAR* pUnkOuter, REFIID riid, void FAR* FAR* ppv);
107:
108: STDAPI RemCreateRHClassObject(REFCLSID rclsid, REFIID iid, void FAR* FAR* ppv);
109:
110: STDAPI RemEnsureLocalClassObject(REFCLSID rclsid, OID FAR* pOidCF);
111:
112: STDAPI RemEnsureUniqueHandler(REFCLSID rclsid, OID oid, IUnknown FAR* FAR* ppUnk);
113:
114:
115: // REVIEW MM2 (craigwi): these aren't used much; do we keep them?
116:
117: /* -----------------------------------------------------------------------
118: * Proxy/Stub macros
119: *
120: * The follwoing macros can be used to implement Proxy/Stub classes for
121: * classes that support only one or more interfaces other then IUnknown
122: * (and maybe IDebug). The resulting classes will support IProxy, IStub
123: * interface in addition to the interfaces supported by the original class.
124: * Assuming the interfaces supported is IName and it is implemented
125: * by a class CName:
126: *
127: * Declaration (in *.h):
128: *
129: * class CName { class CNameProxy { class CNameStub {
130: * ............ ............ ............
131: * STDUNKDECL(CName,Name) STDUNKDECL(CNameProxy,NameProxy) STDUNKDECL(CNameStub,NameStub)
132: * STDDEBDECL(CName,Name) STDDEBDECL(CNameProxy,NameProxy) STDDEBDECL(CNameStub,NameStub)
133: * STDPROXYDECL(CNameProxy,NameProxy) STDSTUBDECL(NameStub,1)
134: * <IName Declaration> <IName for proxy> <IName for stub>
135: * ............ ............ ............
136: * }; }; };
137: *
138: * Implementation (in *.cpp):
139: *
140: * For original object:
141: *
142: * STDUNKIMPL(Name)
143: *
144: * STDUNK_QI_IMPL(Name,Name)
145: *
146: * STDUNKIMPL_FORDERIVED(Name,NameImpl)
147: *
148: * <Implementation of IName: CNameImpl>
149: *
150: *
151: * For proxy object:
152: *
153: * STDUNKIMPL(NameProxy)
154: *
155: * STDUNK_PROXY_QI_IMPL(NameProxy,Name)
156: *
157: * STDUNKIMPL_FORDERIVED(NameProxy,NameProxyImpl)
158: *
159: * STDPROXYIMPL(NameProxy)
160: *
161: * <Implementation of IName: CNameProxyImpl>
162: *
163: *
164: * For stub object:
165: *
166: * STDUNKIMPL(NameStub)
167: *
168: * STDUNK_STUB_QI_IMPL(NameStub,Name)
169: *
170: * STDUNKIMPL_FORDERIVED(NameStub,NameStubImpl)
171: *
172: * STDSTUBIMPL(NameStub)
173: *
174: * <Implementation of IName: CNameStubImpl>
175: *
176: *
177: */
178:
179: // Mattp: I have moved the body of destructor to the implementation macro. ( STDPROXYIMPL)
180:
181: #define STDPROXYDECL(ignore, classname) \
182: implement CProxy : IProxy { public: \
183: CProxy(C##classname FAR* p##classname) \
184: { m_p##classname = p##classname; } \
185: ~CProxy(void); \
186: STDMETHOD(QueryInterface)(REFIID iid, LPLPVOID ppvObj);\
187: STDMETHOD_(ULONG,AddRef)(void); \
188: STDMETHOD_(ULONG,Release)(void); \
189: STDMETHOD(Connect)(ILrpc FAR* pILrpc); \
190: STDMETHOD_(void, Disconnect)(void); \
191: private: C##classname FAR* m_p##classname; }; \
192: DECLARE_NC(C##classname,CProxy) \
193: CProxy m_Proxy;
194:
195:
196: #ifdef OLE2SHIP
197:
198: #define STDSTUBDECL(ignore, classname,cIface) \
199: implement CStub : IStub { public: \
200: CStub(C##classname FAR* p##classname) \
201: { m_p##classname = p##classname; m_pUnkObject = NULL; } \
202: ~CStub(void) \
203: { M_PROLOG(m_p##classname); if (m_pUnkObject != NULL) m_pUnkObject->Release(); } \
204: INTERNAL_(BOOL) Init(IUnknown FAR* pUnkObject); \
205: STDMETHOD(QueryInterface)(REFIID iid, LPLPVOID ppvObj);\
206: STDMETHOD_(ULONG,AddRef)(void); \
207: STDMETHOD_(ULONG,Release)(void); \
208: STDMETHOD(Connect)(IUnknown FAR* pUnkObject); \
209: STDMETHOD_(void, Disconnect)(void); \
210: STDMETHOD(Dispatch)(REFIID iid, int iMethod, IStream FAR* pIStream, \
211: DWORD dwDestCtx, LPVOID lpvDestCtx); \
212: STDMETHOD_(BOOL, IsIIDSupported)(REFIID iid); \
213: STDMETHOD_(ULONG, CountRefs)(void); \
214: private: C##classname FAR* m_p##classname; \
215: IUnknown FAR* m_pUnkObject; \
216: IUnknown FAR* m_aStubIface[cIface]; }; \
217: DECLARE_NC(C##classname,CStub) \
218: CStub m_Stub;
219:
220: #else
221:
222: #define STDSTUBDECL(ignore, classname,cIface) \
223: implement CStub : IStub { public: \
224: CStub(C##classname FAR* p##classname) \
225: { m_p##classname = p##classname; m_pUnkObject = NULL; } \
226: ~CStub(void) \
227: { M_PROLOG(m_p##classname); if (m_pUnkObject != NULL) m_pUnkObject->Release(); } \
228: INTERNAL_(BOOL) Init(IUnknown FAR* pUnkObject); \
229: STDMETHOD(QueryInterface)(REFIID iid, LPLPVOID ppvObj);\
230: STDMETHOD_(ULONG,AddRef)(void); \
231: STDMETHOD_(ULONG,Release)(void); \
232: STDMETHOD(Connect)(IUnknown FAR* pUnkObject); \
233: STDMETHOD_(void, Disconnect)(void); \
234: STDMETHOD(Dispatch)(REFIID iid, int iMethod, IStream FAR* pIStream, \
235: DWORD dwDestCtx, LPVOID lpvDestCtx); \
236: STDMETHOD_(BOOL, IsIIDSupported)(REFIID iid); \
237: private: C##classname FAR* m_p##classname; \
238: IUnknown FAR* m_pUnkObject; \
239: IUnknown FAR* m_aStubIface[cIface]; }; \
240: DECLARE_NC(C##classname,CStub) \
241: CStub m_Stub;
242:
243: #endif
244:
245:
246: #define CONSTRUCT_PROXY m_Proxy(this),
247: #define CONSTRUCT_STUB m_Stub(this),
248:
249:
250: #define STDUNK_PROXY_QI_IMPL(classname,interfacename) \
251: STDMETHODIMP NC(C##classname,CUnknownImpl)::QueryInterface \
252: (REFIID iidInterface, void FAR* FAR* ppv) { \
253: M_PROLOG(m_p##classname); \
254: if (iidInterface == IID_IUnknown) \
255: { *ppv = (void FAR*)&m_p##classname->m_Unknown; AddRef(); noError; } \
256: else if (iidInterface == IID_I##interfacename) \
257: { *ppv = (void FAR*) &(m_p##classname->m_##classname); \
258: m_p##classname->m_pUnkOuter->AddRef(); noError; } \
259: else if (iidInterface == IID_IProxy) \
260: { *ppv = (void FAR*) &(m_p##classname->m_Proxy); AddRef(); noError; } \
261: else \
262: STDDEB_QI(classname) \
263: { *ppv = NULL; return ResultFromScode(E_NOINTERFACE); } \
264: }
265:
266:
267: #define STDUNK_STUB_QI_IMPL(classname,interfacename) \
268: STDMETHODIMP NC(C##classname,CUnknownImpl)::QueryInterface \
269: (REFIID iidInterface, void FAR* FAR* ppv) { \
270: A5_PROLOG(m_p##classname); \
271: if (iidInterface == IID_IUnknown) \
272: *ppv = (void FAR*)&m_p##classname->m_Unknown; \
273: else if (iidInterface == IID_IStub) \
274: *ppv = (void FAR*) &(m_p##classname->m_Stub); \
275: else \
276: STDDEB_QI(classname) \
277: { *ppv = NULL; RESTORE_A5(); return ResultFromScode(E_NOINTERFACE); } \
278: ++(m_p##classname->m_refs); RESTORE_A5(); noError; }
279:
280: // Mattp: The destructor implementation has been moved to here to allow us the outer
281: // reference to 'm_pILrpc'.
282:
283: #define STDPROXYIMPL(classname) \
284: NC(C##classname,CProxy)::~CProxy(void) \
285: { M_PROLOG(m_p##classname);if (m_p##classname->m_pILrpc) m_p##classname->m_pILrpc->Release();}\
286: STDMETHODIMP NC(C##classname,CProxy)::QueryInterface(REFIID iid, LPLPVOID ppvObj) \
287: { M_PROLOG(m_p##classname);return m_p##classname->m_Unknown.QueryInterface (iid, ppvObj); } \
288: STDMETHODIMP_(ULONG) NC(C##classname,CProxy)::AddRef(void) \
289: { M_PROLOG(m_p##classname);return m_p##classname->m_Unknown.AddRef(); } \
290: STDMETHODIMP_(ULONG) NC(C##classname,CProxy)::Release(void) \
291: { M_PROLOG(m_p##classname);return m_p##classname->m_Unknown.Release(); } \
292: STDMETHODIMP NC(C##classname,CProxy)::Connect(ILrpc FAR* pILrpc) \
293: { \
294: M_PROLOG(m_p##classname); \
295: if (pILrpc) { \
296: pILrpc->AddRef(); \
297: m_p##classname->m_pILrpc = pILrpc; \
298: return NOERROR; \
299: } else \
300: return ResultFromScode(E_UNSPEC); \
301: } \
302: STDMETHODIMP_(void) NC(C##classname,CProxy)::Disconnect(void) \
303: { \
304: M_PROLOG(m_p##classname); \
305: if (m_p##classname->m_pILrpc) \
306: m_p##classname->m_pILrpc->Release(); \
307: m_p##classname->m_pILrpc = NULL; \
308: }
309:
310:
311: #define STDSTUBIMPL(classname) STDUNKIMPL_FORDERIVED(classname,Stub) \
312: STDMETHODIMP NC(C##classname,CStub)::Connect(IUnknown FAR* pUnkObject) \
313: { M_PROLOG(m_p##classname);return Init(pUnkObject) ? NOERROR : ResultFromScode(E_UNSPEC); } \
314: STDMETHODIMP_(void) NC(C##classname,CStub)::Disconnect(void) \
315: {M_PROLOG(m_p##classname); Init(NULL); }
316:
317:
318: /*
319: * Ole2 marshalling stuff
320: *
321: * REVIEW: this should go into ole2sp.h, but ILrpc is defined here and
322: * olerem.h is included after ole2sp.h ...
323: */
324:
325: //
326: // MOP is a single instruction to the interpreter that encodes,
327: // decodes parameters sent via LRPC. A string of Mops describes how to
328: // marshal, unmarshal function's paramaters.
329: //
330: //
331:
332: typedef enum MOP {
333: NilMop,
334: // Basic types size of type (win3.1)
335: Void, // No value 0b
336: This, // FAR* this -- BUGBUG Not used
337: Int, // (INT == int) 2b
338: uInt, // (UINT == unsigned int) 2b
339: Long, // (LONG == long) 4b
340: uLong, // (ULONG == unsigned long) 4b
341: Word, // WORD 2b
342: dWord, // DWORD 4b
343: Bool, // BOOL 2b
344: lpStr, // LPSTR -- (zero terminated)
345: pBuf, // void FAR* -- (size in following long)
346:
347: // Windows types
348: wParam, // WPARAM 2b
349: lParam, // LPARAM 4b
350: _Handle, // HANDLE 2b
351: hWnd, // HWND 2b
352: hGlobal, // GLOBAL HANDLE 2b
353: hMFPict, // METAFILE PICT HANDLE 2b
354: hGDI, // GDI HANDLE 2b
355: _Point, // POINT 4b
356: _Size, // SIZE 4b
357: _Rect, // RECT 8b
358: Msg, // MSG 18b
359:
360: // Ole/Win32 types
361: _Pointl, // POINTL 8b
362: _Sizel, // SIZEL 8b
363: _Rectl, // RECTL 16b
364:
365: // Ole types
366: Hresult, // HRESULT 4b
367: Cid, // CID 16b
368: Iid, // IID 16b
369: wChar, // WCHAR 2b
370: Time, // TIME_T 4b
371: StatStg, // STATSTG > 38b + size of member lpstr
372: Layout, // OLELAYOUT 2b BUGBUG - bad size
373: ClipFor, // CLIPFORMAT 2b BUGBUG - MAC bad size
374: DAspect, // DVASPECT 4b
375: TyMed, // TYMED 4b
376: Verb, // OLEVERB > 14b + size of member lpstr
377: TDev, // DVTARGETDEVICE > 16b
378: SMedium, // STGMEDIUM > 12b + size of member lpstr
379: ForEtc, // FORMATETC > 18b + size of member tdev
380: StatDat, // STATDATA > 48b + size of member foretc
381: IFace, // interface FAR* > 40b
382: MenuWidths, // OLEMENUGROUP_WIDTHS 24b
383: hMenu, // HMENU 2b
384: hOMenu, // HOLEMENU 2b
385: hAccel, // HACCEL 2b
386: FrameInfo, // OLEINPLACEFRAMEINFO 10b
387: BindOpt, // BIND_OPTS 12b BUGBUG might change
388: LogPal, // LOGPALETTE > 8b
389:
390: // Modifiers
391: MMask = 0xc0,
392: MIn = 0x40, // FAR Pointer to in parameter
393: MOut = 0x80, // FAR Pointer to out parameter
394: MIO = 0xc0, // FAR Pointer to in, out parameter
395:
396: // Interface indexes (overlap mop values)
397: ILast = 1, // Use last marshalled interface
398: IUnk, // IUnknown
399: IMnk, // IMoniker
400: IStg, // IStorage
401:
402: IDObj, // IDataObject
403: IVObj, // IViewObject
404: IOleObj, // IOleObject
405: IIpObj, // IOleInPlaceObject
406:
407: ICSite, // IOleClientSite
408: IIpSite, // IOleInPlaceSite
409: IAdvSink, // IAdviseSink
410:
411: IPDName, // IParseDisplayName
412: IOleCont, // IOleContainer
413: IOleItemCont, // IOleItemContainer
414: IBCtx, // IBindCtx
415:
416: IEStatData, // IEnumSTATDATA
417: IEForEtc, // IEnumFORMATETC
418: IEStr, // IEnumString
419: IEVerbs, // IEnumOLEVERB
420: IEMnk, // IEnumMoniker
421:
422: IOleWnd, // IOleWIndow
423: IIpUiWnd, // IOleInPlaceUIWindow
424: IIpFrame, // IOleInPlaceFrame
425: IIpAObj, // IOleInPlaceActiveObject
426: IStStream, // IStream
427: IEUnk // IEnumUnknown
428: } MOP;
429: //
430: // Modifiers combine with other types to indicate pointer to the type:
431: // - MIn values are passed on call, but not updated upon return
432: // - MOut values are not passed on call, but are updated upon return
433: // - MIO values are passed on call, and updated upon return.
434: //
435: // M** indicates the argument is a pointer to the type. For types
436: // which imply pointer (lpStr, pBuf, IMnk) M** indicates pointer to a pointer
437: // (as in LPSTR FAR*, IEnumClipFormat FAR* FAR*). For MOut the value pointed
438: // (i.e. the interface pointer) is ignored. MIn, MIO not supported.
439: //
440: // Interface indexes follow IFace mop to specify type of interface being
441: // marshalled. ILast specify last IID marshalled.
442: //
443: // By convention the return value is always an HRESULT.
444: //
445: // MOP is an 8-bit value; it fits in a BYTE. Example:
446: //
447: // static mopsSomeFunc[] { pBuf | MIn, uLong, IFace, IDObj, ..., NilMop };
448: //
449:
450:
451: // FNI describes how to marshal, unmarshal specific function
452: //
453: typedef int FNITYPE;
454:
455: #define FNITYPE_NilFni 0
456: #define FNITYPE_RevArg 0x01 // Arguments pushed left-to-right (pascal)
457: #define FNITYPE_Clean 0x02 // Callee cleans stack (pascal)
458: #define FNITYPE_Method 0x04 // Class method.
459: #define FNITYPE_Virtual 0x08 // Virtual function
460: #define FNITYPE_Send 0x10 // Use SendMessage (not PostMessage)
461: #define FNITYPE_NoWait 0x20 // Do not wait for reply (only when PostMessage)
462:
463: struct FAR FNI { // Static data for function marshalling
464: FNITYPE m_type; // Function description
465: struct { // For virtual function
466: const IID FAR* lpIID;// far pointer to Interface ID
467: int iMethod; // Method index
468: } m_loc; // ----
469: UINT m_cbStk; // Stack space for pushing all arguments
470: UINT m_cbStm; // Stream space for marshalling arguments
471: UINT m_cbExtStm; // Additional stream space for strings, buffers
472: BYTE FAR* m_args; // Arguments MOPs
473: };
474:
475: //
476: // Example
477: //
478: //static FNI fniSomeFunc = {
479: // FNITYPE_Method | FNITYPE_Virtual,
480: // { //interface and method Indices
481: // &_IID_ISomeIface,
482: // IFUNC_SomeFunc
483: // },
484: // 64, // Stack space
485: // 96, // Minimun Stream space
486: // 48, // Estimated extra stream space
487: // mopsSomeFunc // The mops
488: //};
489: //
490: // _IID_ISomeIface is the IID for the interface of this object,
491: // IIFACE_SomeFunc is the index of this method within the interface.
492: //
493:
494:
495: STDAPI LrpcCall(ILrpc FAR* pILrpc, FNI FAR* pfni, void FAR* pFirstArg);
496:
497: STDAPI LrpcDispatch(IStream FAR* pIStream, FNI FAR* pfni, void FAR* pObj);
498:
499: STDAPI_(BOOL) IsValidOID(OID oid);
500:
501: #endif // _OLEREM_H
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.