开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
MyMoniker.cpp
资源名称：COM+编程技术内幕(源码).rar　[点击查看]
上传用户：bjlvip
上传日期：2010-02-08
资源大小：744k
文件大小：10k
源码类别：

Windows编程

开发平台：

Visual C++

MyMoniker.cpp：源码内容
  1. // MyMoniker.cpp
  2. #define _WIN32_DCOM
  3. #include <windows.h>
  4. #include <iostream.h>
  5. #include <stdio.h>
  6. #include "registry.h"
  8. const CLSID CLSID_MarvelousMoniker = {0x10000022,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01}};
  10. long g_cComponents = 0;
  11. long g_cServerLocks = 0;
  13. class CMarvyMoniker : public IMoniker, public IClassActivator
  14. {
  15. friend class CClassObject;
  16. public:
  17. // IUnknown
  18. ULONG __stdcall AddRef();
  19. ULONG __stdcall Release();
  20. HRESULT __stdcall QueryInterface(REFIID riid, void** ppv);
  22. // IPersist
  23. HRESULT __stdcall GetClassID(CLSID* pClassID);
  25. // IPersistStream
  26. HRESULT __stdcall IsDirty();
  27. HRESULT __stdcall Load(IStream* pStm);
  28. HRESULT __stdcall Save(IStream* pStm, BOOL fClearDirty);
  29. HRESULT __stdcall GetSizeMax(ULARGE_INTEGER *pcbSize);
  31. // IMoniker
  32. HRESULT __stdcall BindToObject(IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riidResult, void **ppvResult);
  33. HRESULT __stdcall BindToStorage(IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, void **ppvObj);
  34. HRESULT __stdcall Reduce(IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced);
  35. HRESULT __stdcall ComposeWith(IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite);
  36. HRESULT __stdcall Enum(BOOL fForward, IEnumMoniker **ppenumMoniker);
  37. HRESULT __stdcall IsEqual(IMoniker *pmkOtherMoniker);
  38. HRESULT __stdcall Hash(DWORD *pdwHash);
  39. HRESULT __stdcall IsRunning(IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning);
  40. HRESULT __stdcall GetTimeOfLastChange(IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pFileTime);
  41. HRESULT __stdcall Inverse(IMoniker **ppmk);
  42. HRESULT __stdcall CommonPrefixWith(IMoniker *pmkOther, IMoniker **ppmkPrefix);
  43. HRESULT __stdcall RelativePathTo(IMoniker *pmkOther, IMoniker **ppmkRelPath);
  44. HRESULT __stdcall GetDisplayName(IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName);
  45. HRESULT __stdcall ParseDisplayName(IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut);
  46. HRESULT __stdcall IsSystemMoniker(DWORD *pdwMksys);
  48. // IClassActivator
  49. HRESULT __stdcall GetClassObject(REFCLSID pClassID, DWORD dwClsContext, LCID locale, REFIID riid, void** ppv);
  51. CMarvyMoniker();
  52. CMarvyMoniker(REFCLSID clsid, COSERVERINFO* pCSI);
  53. ~CMarvyMoniker();
  55. private:
  56. ULONG m_cRef;
  57. wchar_t m_hostname[255];
  58. CLSID m_clsid;
  59. COSERVERINFO m_CoServerInfo;
  60. };
  62. CMarvyMoniker::CMarvyMoniker(REFCLSID clsid, COSERVERINFO* pCSI)
  63. {
  64. CMarvyMoniker();
  65. m_clsid = clsid;
  66. m_CoServerInfo.pwszName = wcscpy(m_hostname, pCSI->pwszName);
  67. }
  69. CMarvyMoniker::CMarvyMoniker() : m_cRef(1)
  70. {
  71. g_cComponents++;
  72. m_CoServerInfo.dwReserved1 = 0;
  73. m_CoServerInfo.pwszName = 0;
  74. m_CoServerInfo.pAuthInfo = 0;
  75. m_CoServerInfo.dwReserved2 = 0;
  76. }
  78. CMarvyMoniker::~CMarvyMoniker()
  79. {
  80. g_cComponents--;
  81. }
  83. HRESULT CMarvyMoniker::GetClassObject(REFCLSID pClassID, DWORD dwClsContext, LCID locale, REFIID riid, void** ppv)
  84. {
  85. wprintf(L"IClassActivator::GetClassObject connecting to %sn", m_CoServerInfo.pwszName);
  87. HRESULT hr = CoGetClassObject(pClassID, CLSCTX_SERVER, &m_CoServerInfo, riid, ppv);
  88. if(FAILED(hr))
  89. printf("CoCreateInstance failed %0xn", hr);
  90. return hr;
  91. }
  93. HRESULT CMarvyMoniker::GetClassID(CLSID* pClassID)
  94. {
  95. *pClassID = CLSID_MarvelousMoniker;
  96. return S_OK;
  97. }
  99. HRESULT CMarvyMoniker::IsDirty()
  100. {
  101. return S_FALSE;
  102. }
  104. HRESULT CMarvyMoniker::Load(IStream* pStm)
  105. {
  106. return E_NOTIMPL;
  107. }
  109. HRESULT CMarvyMoniker::Save(IStream* pStm, BOOL fClearDirty)
  110. {
  111. return E_NOTIMPL;
  112. }
  114. HRESULT CMarvyMoniker::GetSizeMax(ULARGE_INTEGER *pcbSize)
  115. {
  116. return E_NOTIMPL;
  117. }
  119. HRESULT CMarvyMoniker::BindToObject(IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riidResult, void **ppvResult)
  120. {
  121. // This catches the recursive call by the class moniker
  122. if(riidResult == IID_IClassActivator)
  123. {
  124. *ppvResult = (IClassActivator*)this;
  125. return S_OK;
  126. }
  128. // An AddRef a day keeps the doctor away
  129. AddRef();
  131. IMoniker* pClassMoniker;
  132. HRESULT hr = CreateClassMoniker(m_clsid, &pClassMoniker);
  133. if(FAILED(hr))
  134. return hr;
  136. // Bind the class moniker
  137. hr = pClassMoniker->BindToObject(pbc, (IMoniker*)this, riidResult, ppvResult);
  138. pClassMoniker->Release();
  139. return hr;
  140. }
  142. HRESULT CMarvyMoniker::BindToStorage(IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid, void **ppvObj)
  143. {
  144. return MK_E_NOSTORAGE;
  145. }
  147. HRESULT CMarvyMoniker::Reduce(IBindCtx *pbc, DWORD dwReduceHowFar, IMoniker **ppmkToLeft, IMoniker **ppmkReduced)
  148. {
  149. *ppmkReduced = (IMoniker*)this;
  150. return MK_S_REDUCED_TO_SELF;
  151. }
  153. HRESULT CMarvyMoniker::ComposeWith(IMoniker *pmkRight, BOOL fOnlyIfNotGeneric, IMoniker **ppmkComposite)
  154. {
  155. if(fOnlyIfNotGeneric)
  156. {
  157. *ppmkComposite = NULL;
  158. return MK_E_NEEDGENERIC;
  159. }
  160. return CreateGenericComposite((IMoniker*)this, pmkRight, ppmkComposite);
  161. }
  163. HRESULT CMarvyMoniker::Enum(BOOL fForward, IEnumMoniker **ppenumMoniker)
  164. {
  165. *ppenumMoniker = NULL;
  166. return S_OK;
  167. }
  169. HRESULT CMarvyMoniker::IsEqual(IMoniker *pmkOtherMoniker)
  170. {
  171. return E_NOTIMPL;
  172. }
  174. HRESULT CMarvyMoniker::Hash(DWORD *pdwHash)
  175. {
  176. return E_NOTIMPL;
  177. }
  179. HRESULT CMarvyMoniker::IsRunning(IBindCtx *pbc, IMoniker *pmkToLeft, IMoniker *pmkNewlyRunning)
  180. {
  181. return E_NOTIMPL;
  182. }
  184. HRESULT CMarvyMoniker::GetTimeOfLastChange(IBindCtx *pbc, IMoniker *pmkToLeft, FILETIME *pFileTime)
  185. {
  186. return MK_E_UNAVAILABLE;
  187. }
  189. HRESULT CMarvyMoniker::Inverse(IMoniker **ppmk)
  190. {
  191. return CreateAntiMoniker(ppmk);
  192. }
  194. HRESULT CMarvyMoniker::CommonPrefixWith(IMoniker *pmkOther, IMoniker **ppmkPrefix)
  195. {
  196. return E_NOTIMPL;
  197. }
  199. HRESULT CMarvyMoniker::RelativePathTo(IMoniker *pmkOther, IMoniker **ppmkRelPath)
  200. {
  201. return MonikerRelativePathTo((IMoniker*)this, pmkOther, ppmkRelPath, TRUE);
  202. }
  204. HRESULT CMarvyMoniker::GetDisplayName(IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR *ppszDisplayName)
  205. {
  206. *ppszDisplayName = (wchar_t*)CoTaskMemAlloc(512);
  207. wchar_t ppsz[39];
  208. StringFromGUID2(m_clsid, ppsz, 39);
  209. ppsz[37] = 0;
  210. swprintf(*ppszDisplayName, L"host:%s!clsid:%s", m_hostname, wcstok(ppsz, L"{"));
  211. return S_OK;
  212. }
  214. HRESULT CMarvyMoniker::ParseDisplayName(IBindCtx *pbc, IMoniker *pmkToLeft, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
  215. {
  216. return E_NOTIMPL;
  217. }
  219. HRESULT CMarvyMoniker::IsSystemMoniker(DWORD *pdwMksys)
  220. {
  221. *pdwMksys = MKSYS_NONE;
  222. return S_OK;
  223. }
  225. ULONG CMarvyMoniker::AddRef()
  226. {
  227. cout << "Moniker::AddRef() m_cRef = " << m_cRef + 1 << endl;
  228. return ++m_cRef;
  229. }
  231. ULONG CMarvyMoniker::Release()
  232. {
  233. cout << "Moniker::Release() m_cRef = " << m_cRef - 1 << endl;
  234. if(--m_cRef != 0)
  235. return m_cRef;
  236. delete this;
  237. return 0;
  238. }
  240. HRESULT CMarvyMoniker::QueryInterface(REFIID riid, void** ppv)
  241. {
  242. if(riid == IID_IUnknown)
  243. {
  244. cout << "Moniker::QueryInterface() for IUnknown" << endl;
  245. *ppv = reinterpret_cast<IUnknown*>(this);
  246. }
  247. else if(riid == IID_IMoniker)
  248. {
  249. cout << "Moniker::QueryInterface() for IMoniker" << endl;
  250. *ppv = (IMoniker*)this;
  251. }
  252. else 
  253. {
  254. *ppv = NULL;
  255. return E_NOINTERFACE;
  256. }
  257. AddRef();
  258. return S_OK;
  259. }
  261. class CClassObject : public IParseDisplayName
  262. {
  263. public:
  264. // IUnknown
  265. ULONG __stdcall AddRef();
  266. ULONG __stdcall Release();
  267. HRESULT __stdcall QueryInterface(REFIID riid, void** ppv);
  269. // IParseDisplayName
  270. HRESULT __stdcall ParseDisplayName(IBindCtx *pbc, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut);
  272. CClassObject() : m_cRef(1) { }
  273. ~CClassObject() { }
  275. private:
  276. ULONG m_cRef;
  277. };
  279. ULONG CClassObject::AddRef()
  280. {
  281. return ++m_cRef;
  282. }
  284. ULONG CClassObject::Release()
  285. {
  286. if(--m_cRef != 0)
  287. return m_cRef;
  288. delete this;
  289. return 0;
  290. }
  292. HRESULT CClassObject::QueryInterface(REFIID riid, void** ppv)
  293. {
  294. if(riid == IID_IUnknown)
  295. *ppv = (IUnknown*)this;
  296. else if(riid == IID_IParseDisplayName)
  297. {
  298. cout << "CClassObject::QueryInterface() for IParseDisplayName" << endl;
  299. *ppv = (IParseDisplayName*)this;
  300. }
  301. else
  302. {
  303. *ppv = NULL;
  304. return E_NOINTERFACE;
  305. }
  306. AddRef();
  307. return S_OK;
  308. }
  310. HRESULT CClassObject::ParseDisplayName(IBindCtx *pbc, LPOLESTR pszDisplayName, ULONG *pchEaten, IMoniker **ppmkOut)
  311. {
  312. // Instantiate the moniker
  313. CMarvyMoniker* pCMarvyMoniker = new CMarvyMoniker();
  315. // Parse and check display name
  316. // It must have the following format:
  317. // host:hostname!clsid:????????-????-????-????-????????????
  318. if(_wcsicmp(wcstok(pszDisplayName, L":"), L"host") == 0)
  319. {
  320. pCMarvyMoniker->m_CoServerInfo.pwszName = wcscpy(pCMarvyMoniker->m_hostname, wcstok(NULL, L"!"));
  321. if(_wcsicmp(wcstok(NULL, L":"), L"clsid") == 0)
  322. {
  323. wchar_t clsid_with_braces[39] = L"{";
  324. wcscat(wcscat(clsid_with_braces, wcstok(NULL, L"!")), L"}");
  325. CLSIDFromString(clsid_with_braces, &pCMarvyMoniker->m_clsid);
  326. }
  327. }
  329. // Get IMoniker* to return to caller
  330. pCMarvyMoniker->QueryInterface(IID_IMoniker, (void**)ppmkOut);
  331. pCMarvyMoniker->Release();
  333. // Indicate that we have digested the entire display name.
  334. *pchEaten = (ULONG)wcslen(pszDisplayName);
  335. return S_OK;
  336. }
  338. HRESULT __stdcall DllCanUnloadNow()
  339. {
  340. cout << "Moniker: DllCanUnloadNow() " << (g_cServerLocks == 0 && g_cComponents == 0 ? "Yes" : "No") << endl;
  341. if(g_cServerLocks == 0 && g_cComponents == 0)
  342. return S_OK;
  343. else
  344. return S_FALSE;
  345. }
  347. HRESULT __stdcall DllGetClassObject(REFCLSID clsid, REFIID riid, void** ppv)
  348. {
  349. cout << "Moniker: DllGetClassObject" << endl;
  351. if(clsid != CLSID_MarvelousMoniker)
  352. return CLASS_E_CLASSNOTAVAILABLE;
  354. CClassObject* pClassObject = new CClassObject;
  355. if(pClassObject == NULL)
  356. return E_OUTOFMEMORY;
  358. // QueryInterface probably for IClassFactory
  359. HRESULT hr = pClassObject->QueryInterface(riid, ppv);
  360. pClassObject->Release();
  361. return hr;
  362. }
  364. HRESULT __stdcall DllRegisterServer()
  365. {
  366. // The progid "Host" must be registered in order for the moniker to work
  367. return RegisterServer("moniker.dll", CLSID_MarvelousMoniker, "Marvelous Moniker", "Host", "Host", NULL);
  368. }
  370. HRESULT __stdcall DllUnregisterServer()
  371. {
  372. return UnregisterServer(CLSID_MarvelousMoniker, "Host", "Host");
  373. }
  375. HRESULT __stdcall CreateMarvelousMoniker(REFCLSID clsid, COSERVERINFO* pCSI, IMoniker** ppMoniker)
  376. {
  377. CMarvyMoniker *pCMarvyMoniker = new CMarvyMoniker(clsid, pCSI);
  378. if(pCMarvyMoniker == NULL)
  379. return E_OUTOFMEMORY;
  381. HRESULT hr = pCMarvyMoniker->QueryInterface(IID_IMoniker, (void**)ppMoniker);
  382. pCMarvyMoniker->Release();
  383. return hr;
  384. }