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

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

Windows编程

开发平台：

Visual C++

local with custom IAccessControl.cpp：源码内容
  1. // local.cpp
  2. #define _WIN32_WINNT 0x0403
  3. #define _WIN32_DCOM
  4. #include <windows.h>
  5. #include <stdio.h>
  6. #include <iaccess.h>   // IAccessControl
  7. #include <iostream.h>  // For cout
  8. #include "registry.h"  // For registry functions
  9. #include "Component IAccessControlcomponent.h" // Generated by MIDL
  11. const IID IID_IAccessControl = {0xEEDD23E0,0x8410,0x11CE,{0xA1,0xC3,0x08,0x00,0x2B,0x2B,0x8D,0x8F}};
  13. long g_cComponents = 0;
  14. long g_cServerLocks = 0;
  15. HANDLE g_hEvent;
  17. class CMyAccessControl : public IAccessControl
  18. {
  19. public:
  20. // IUnknown
  21. ULONG __stdcall AddRef();
  22. ULONG __stdcall Release();
  23. HRESULT __stdcall QueryInterface(REFIID riid, void** ppv);
  25. // IAccessControl
  26. HRESULT __stdcall GrantAccessRights(PACTRL_ACCESSW pAccessList);
  27. HRESULT __stdcall SetAccessRights(PACTRL_ACCESSW pAccessList);
  28. HRESULT __stdcall SetOwner(PTRUSTEEW pOwner, PTRUSTEEW pGroup);
  29. HRESULT __stdcall RevokeAccessRights(LPWSTR lpProperty, ULONG cTrustees, TRUSTEEW prgTrusteesp[]);
  30. HRESULT __stdcall GetAllAccessRights(LPWSTR lpProperty, PACTRL_ACCESSW_ALLOCATE_ALL_NODES* ppAccessList, PTRUSTEEW* ppOwner, PTRUSTEEW* ppGroup);
  31. HRESULT __stdcall IsAccessAllowed(PTRUSTEEW pTrustee, LPWSTR lpProperty, ACCESS_RIGHTS AccessRights, BOOL* pfAccessAllowed);
  33. private:
  34. ULONG m_cRef;
  35. };
  37. HRESULT CMyAccessControl::GrantAccessRights(PACTRL_ACCESSW pAccessList)
  38. {
  39. return E_NOTIMPL;
  40. }
  42. HRESULT CMyAccessControl::SetAccessRights(PACTRL_ACCESSW pAccessList)
  43. {
  44. return E_NOTIMPL;
  45. }
  47. HRESULT CMyAccessControl::SetOwner(PTRUSTEEW pOwner, PTRUSTEEW pGroup)
  48. {
  49. return E_NOTIMPL;
  50. }
  52. HRESULT CMyAccessControl::RevokeAccessRights(LPWSTR lpProperty, ULONG cTrustees, TRUSTEEW prgTrusteesp[])
  53. {
  54. return E_NOTIMPL;
  55. }
  57. HRESULT CMyAccessControl::GetAllAccessRights(LPWSTR lpProperty, PACTRL_ACCESSW_ALLOCATE_ALL_NODES* ppAccessList, PTRUSTEEW* ppOwner, PTRUSTEEW* ppGroup)
  58. {
  59. return E_NOTIMPL;
  60. }
  62. HRESULT CMyAccessControl::IsAccessAllowed(PTRUSTEEW pTrustee, LPWSTR lpProperty, ACCESS_RIGHTS AccessRights, BOOL* pfAccessAllowed)
  63. {
  64. if(MessageBoxW(NULL, pTrustee->ptstrName, L"Grant permission?", MB_SERVICE_NOTIFICATION | MB_SETFOREGROUND | MB_YESNO) == IDYES)
  65. *pfAccessAllowed = TRUE;
  66. else
  67. *pfAccessAllowed = FALSE;
  68. return S_OK;
  69. }
  71. ULONG CMyAccessControl::AddRef()
  72. {
  73. return ++m_cRef;
  74. }
  76. ULONG CMyAccessControl::Release()
  77. {
  78. if(--m_cRef != 0)
  79. return m_cRef;
  80. delete this;
  81. return 0;
  82. }
  84. HRESULT CMyAccessControl::QueryInterface(REFIID riid, void** ppv)
  85. {
  86. if(riid == IID_IUnknown || riid == IID_IAccessControl)
  87. *ppv = reinterpret_cast<IUnknown*>(this);
  88. else 
  89. {
  90. *ppv = NULL;
  91. return E_NOINTERFACE;
  92. }
  93. AddRef();
  94. return S_OK;
  95. }
  97. class CInsideCOM : public ISum
  98. {
  99. public:
  100. // IUnknown
  101. ULONG __stdcall AddRef();
  102. ULONG __stdcall Release();
  103. HRESULT __stdcall QueryInterface(REFIID riid, void** ppv);
  105. // ISum
  106. HRESULT __stdcall Sum(int x, int y, int* retval);
  108. CInsideCOM() : m_cRef(1) { g_cComponents++; }
  109. ~CInsideCOM() { cout << "Component: CInsideCOM::~CInsideCOM()" << endl, g_cComponents--; }
  111. private:
  112. ULONG m_cRef;
  113. };
  115. ULONG CInsideCOM::AddRef()
  116. {
  117. cout << "Component: CInsideCOM::AddRef() m_cRef = " << m_cRef + 1 << endl;
  118. return ++m_cRef;
  119. }
  121. ULONG CInsideCOM::Release()
  122. {
  123. cout << "Component: CInsideCOM::Release() m_cRef = " << m_cRef - 1 << endl;
  124. if(--m_cRef != 0)
  125. return m_cRef;
  126. SetEvent(g_hEvent); // ADD THIS!!!
  127. delete this;
  128. return 0;
  129. }
  131. HRESULT CInsideCOM::QueryInterface(REFIID riid, void** ppv)
  132. {
  133. if(riid == IID_IUnknown)
  134. {
  135. cout << "Component: CInsideCOM::QueryInterface() for IUnknown returning " << this << endl;
  136. *ppv = reinterpret_cast<IUnknown*>(this);
  137. }
  138. else if(riid == IID_ISum)
  139. {
  140. cout << "Component: CInsideCOM::QueryInterface() for ISum returning " << this << endl;
  141. *ppv = (ISum*)this;
  142. }
  143. else 
  144. {
  145. *ppv = NULL;
  146. return E_NOINTERFACE;
  147. }
  148. AddRef();
  149. return S_OK;
  150. }
  152. HRESULT CInsideCOM::Sum(int x, int y, int* retval)
  153. {
  154. HRESULT hr;
  155. IServerSecurity* pServerSecurity;
  156. hr = CoGetCallContext(IID_IServerSecurity, (void**)&pServerSecurity);
  157. if(FAILED(hr))
  158. cout << "CoGetCallContext failed" << endl;
  161. DWORD AuthnSvc;
  162. DWORD AuthzSvc;
  163. OLECHAR* ServerPrincNam;
  164. DWORD AuthnLevel;
  165. RPC_AUTHZ_HANDLE Privs;
  166. DWORD Capabilities;
  168. // AuthzSvc is ignored when using the RPC_C_AUTHN_WINNT authentication service.
  169. //                             RPC_C_AUTHN_WINNT, ignored,    Administrator, RPC_C_AUTHN_LEVEL_PKT, Thing4Administrator, EOAC_NONE
  170. hr = pServerSecurity->QueryBlanket(&AuthnSvc, &AuthzSvc, &ServerPrincNam, &AuthnLevel, NULL, &Privs, &Capabilities);
  171. //                                                                       impersonation level is never returned
  173. if(FAILED(hr))
  174. cout << "QueryBlanket failed" << endl;
  176. pServerSecurity->Release();
  178. switch(AuthnSvc)
  179. {
  180. case RPC_C_AUTHN_NONE:
  181. cout << "RPC_C_AUTHN_NONE ";
  182. break;
  183. case RPC_C_AUTHN_DCE_PRIVATE:
  184. cout << "RPC_C_AUTHN_DCE_PRIVATE ";
  185. break;
  186. case RPC_C_AUTHN_DCE_PUBLIC:
  187. cout << "RPC_C_AUTHN_DCE_PUBLIC ";
  188. break;
  189. case RPC_C_AUTHN_WINNT:
  190. cout << "RPC_C_AUTHN_WINNT ";
  191. break;
  192. case RPC_C_AUTHN_DEFAULT:
  193. cout << "RPC_C_AUTHN_DEFAULT ";
  194. break;
  195. }
  197. switch(AuthnSvc)
  198. {
  199. case RPC_C_AUTHZ_NONE:
  200. cout << "RPC_C_AUTHZ_NONE ";
  201. break;
  202. case RPC_C_AUTHZ_NAME:
  203. cout << "RPC_C_AUTHZ_NAME ";
  204. break;
  205. case RPC_C_AUTHZ_DCE:
  206. cout << "RPC_C_AUTHZ_DCE ";
  207. break;
  208. }
  210. wprintf(L"ServerPrincNam %sn", ServerPrincNam);
  212. switch(AuthnLevel)
  213. {
  214. case RPC_C_AUTHN_LEVEL_NONE:
  215. cout << "RPC_C_AUTHN_LEVEL_NONE ";
  216. break;
  217. case RPC_C_AUTHN_LEVEL_CONNECT:
  218. cout << "RPC_C_AUTHN_LEVEL_CONNECT ";
  219. break;
  220. case RPC_C_AUTHN_LEVEL_CALL:
  221. cout << "RPC_C_AUTHN_LEVEL_CALL ";
  222. break;
  223. case RPC_C_AUTHN_LEVEL_PKT:
  224. cout << "RPC_C_AUTHN_LEVEL_PKT ";
  225. break;
  226. case RPC_C_AUTHN_LEVEL_PKT_INTEGRITY:
  227. cout << "RPC_C_AUTHN_LEVEL_PKT_INTEGRITY ";
  228. break;
  229. case RPC_C_AUTHN_LEVEL_PKT_PRIVACY:
  230. cout << "RPC_C_AUTHN_LEVEL_PKT_PRIVACY ";
  231. break;
  232. }
  234. wprintf(L"Privs %sn", Privs);
  236. if(Capabilities == EOAC_NONE)
  237. cout << "EOAC_NONE" << endl;
  239. CoTaskMemFree(ServerPrincNam);
  241. cout << "Component: CInsideCOM::Sum() " << x << " + " << y << " = " << x + y << endl;
  242. *retval = x + y;
  244. return S_OK;
  245. }
  247. class CFactory : public IClassFactory
  248. {
  249. public:
  250. // IUnknown
  251. ULONG __stdcall AddRef();
  252. ULONG __stdcall Release();
  253. HRESULT __stdcall QueryInterface(REFIID riid, void** ppv);
  255. // IClassFactory
  256. HRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter, REFIID riid, void** ppv);
  257. HRESULT __stdcall LockServer(BOOL bLock);
  259. CFactory() : m_cRef(1) { }
  260. ~CFactory() { }
  262. private:
  263. ULONG m_cRef;
  264. };
  266. ULONG CFactory::AddRef()
  267. {
  268. cout << "Component: CFactory::AddRef() m_cRef = " << m_cRef + 1 << endl;
  269. return ++m_cRef;
  270. }
  272. ULONG CFactory::Release()
  273. {
  274. cout << "Component: CFactory::Release() m_cRef = " << m_cRef - 1 << endl;
  275. if(--m_cRef != 0)
  276. return m_cRef;
  277. delete this;
  278. return 0;
  279. }
  281. HRESULT CFactory::QueryInterface(REFIID riid, void** ppv)
  282. {
  283. if((riid == IID_IUnknown) || (riid == IID_IClassFactory))
  284. {
  285. cout << "Component: CFactory::QueryInteface() for IUnknown or IClassFactory " << this << endl;
  286. *ppv = (IClassFactory*)this;
  287. }
  288. else
  289. {
  290. *ppv = NULL;
  291. return E_NOINTERFACE;
  292. }
  293. AddRef();
  294. return S_OK;
  295. }
  297. HRESULT CFactory::CreateInstance(IUnknown *pUnknownOuter, REFIID riid, void** ppv)
  298. {
  299. if(pUnknownOuter != NULL)
  300. return CLASS_E_NOAGGREGATION;
  302. CInsideCOM *pInsideCOM = new CInsideCOM;
  303. cout << "Component: CFactory::CreateInstance() " << pInsideCOM << endl;
  305. if(pInsideCOM == NULL)
  306. return E_OUTOFMEMORY;
  308. // QueryInterface probably for IID_IUNKNOWN
  309. HRESULT hr = pInsideCOM->QueryInterface(riid, ppv);
  310. pInsideCOM->Release();
  311. return hr;
  312. }
  314. HRESULT CFactory::LockServer(BOOL bLock)
  315. {
  316. if(bLock)
  317. g_cServerLocks++;
  318. else
  319. g_cServerLocks--;
  320. return S_OK;
  321. }
  323. void RegisterComponent()
  324. {
  325. ITypeLib* pTypeLib;
  326. LoadTypeLibEx(L"Component IAccessControl.exe", REGKIND_DEFAULT, &pTypeLib);
  327. pTypeLib->Release();
  328. RegisterServer("Component IAccessControl.exe", CLSID_InsideCOM, "Inside COM Sample #1", "Component.InsideCOM", "Component.InsideCOM.1", NULL);
  329. }
  331. void CommandLineParameters(int argc, char** argv)
  332. {
  333. RegisterComponent();
  334. if(argc < 2)
  335. {
  336. cout << "No parameter, but registered anyway" << endl;
  337. exit(false);
  338. }
  339. char* szToken = strtok(argv[1], "-/"); 
  340. if(_stricmp(szToken, "RegServer") == 0)
  341. {
  342. RegisterComponent();
  343. cout << "RegServer" << endl;
  344. exit(true);
  345. }
  346. if(_stricmp(szToken, "UnregServer") == 0)
  347. {
  348. UnRegisterTypeLib(LIBID_Component, 1, 0, LANG_NEUTRAL, SYS_WIN32);
  349. UnregisterServer(CLSID_InsideCOM, "Component.InsideCOM", "Component.InsideCOM.1");
  350. cout << "UnregServer" << endl;
  351. exit(true);
  352. }
  353. if(_stricmp(szToken, "Embedding") != 0)
  354. {
  355. cout << "Invalid parameter" << endl;
  356. exit(false);
  357. }
  358. }
  360. void main(int argc, char** argv)
  361. {
  362. HRESULT hr;
  363. CommandLineParameters(argc, argv);
  365. cout << "Component: CoInitializeEx()" << endl;
  366. hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
  367. if(FAILED(hr))
  368. cout << "CoInitializeEx Failed" << endl;
  370. CMyAccessControl ac;
  371. hr = CoInitializeSecurity(&ac, -1, NULL, NULL, RPC_C_AUTHN_LEVEL_CONNECT, RPC_C_IMP_LEVEL_IDENTIFY, 
  372. NULL, EOAC_ACCESS_CONTROL, NULL);
  373. if(FAILED(hr))
  374. {
  375. printf("CoInitializeSecurity Failed = %0xn", hr);
  376. exit(0);
  377. }
  379. IClassFactory *pClassFactory = new CFactory();
  381. cout << "Component: CoRegisterClassObject()" << endl;
  382. DWORD dwRegister;
  383. CoRegisterClassObject(CLSID_InsideCOM, pClassFactory, CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);
  385. g_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
  386. WaitForSingleObject(g_hEvent, INFINITE);
  388. CoRevokeClassObject(dwRegister);
  389. pClassFactory->Release();
  390. CoUninitialize();
  391. }