component b.cpp

经验交流,从网上下载的好东西望大家分享

	return 0;
}

HRESULT CInsideCOM::QueryInterface(REFIID riid, void** ppv)
{
	if(riid == IID_IUnknown)
		*ppv = reinterpret_cast<IUnknown*>(this);
	else if(riid == IID_ISum)
		*ppv = (ISum*)this;
	else 
	{
		*ppv = NULL;
		return E_NOINTERFACE;
	}
	AddRef();
	return S_OK;
}

HRESULT CInsideCOM::Sum(int x, int y, int* retval)
{
	ISum* pSum = 0;
	IUnknown* pUnknown = 0;
	HRESULT hr;

	COSERVERINFO ServerInfo;
	ServerInfo.dwReserved1 = 0;
	ServerInfo.pwszName = L"Guy-2031";
	ServerInfo.pAuthInfo = 0;
	ServerInfo.dwReserved2 = 0;

	MULTI_QI qi;
	qi.pIID = &IID_IUnknown;
	qi.pItf = NULL;
	qi.hr = 0;


/*
	HANDLE handle = 0;
	handle = CreateFile("\\\\Guy-2031\\C\\test.txt", GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
	if(handle != INVALID_HANDLE_VALUE)
	{
		char buffer[25];
		DWORD bytes_read = 0;
		ReadFile(handle, buffer, 25, &bytes_read, NULL);
		CloseHandle(handle);

		buffer[bytes_read] = 0;
		cout << buffer << " Read from file" << endl;
	}
	else
		cout << "access denied to file" << endl;

*/

	hr = CoImpersonateClient();
	if(FAILED(hr))
		printf("CoImpersonateClient failed %0x\n", hr);

	hr = CoCreateInstanceEx(CLSID_InsideCOM_C, NULL, CLSCTX_REMOTE_SERVER, &ServerInfo, 1, &qi);
	pUnknown = qi.pItf;

	if(FAILED(hr))
	{
		if(hr == E_ACCESSDENIED)
			printf("CoCreateInstance FAILED hr = E_ACCESSDENIED\n", hr);
		else
			printf("CoCreateInstance FAILED hr = %0x\n", hr);
		_getch();
		exit(0);
	}

		hr = CoSetProxyBlanket(pUnknown, RPC_C_AUTHN_GSS_KERBEROS, RPC_C_AUTHZ_DEFAULT, COLE_DEFAULT_PRINCIPAL, // L"GuysDomain\\B", 
			RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_DEFAULT, COLE_DEFAULT_AUTHINFO, EOAC_DEFAULT);

	display_proxy_info(pUnknown);

	cout << "Client: Calling QueryInterface() for ISum on " << pUnknown << endl;
	hr = pUnknown->QueryInterface(IID_ISum, (void**)&pSum);
	if(FAILED(hr))
	{
		printf("QueryInterface ISUm FAILED %0x\n", hr);
		_getch();
		exit(0);
	}

	cout << "Client: Calling Release() for pUnknown" << endl;
	hr = pUnknown->Release();

	cout << "Client: pSum = " << pSum << endl;


	display_proxy_info(pSum);
	_getch();

	hr = CoSetProxyBlanket(pSum, RPC_C_AUTHN_GSS_KERBEROS, RPC_C_AUTHZ_DEFAULT, COLE_DEFAULT_PRINCIPAL, // L"GuysDomain\\B", 
		RPC_C_AUTHN_LEVEL_DEFAULT, RPC_C_IMP_LEVEL_DEFAULT, COLE_DEFAULT_AUTHINFO, EOAC_DEFAULT);
	if(FAILED(hr))
			printf("CoSetProxyBlanket 2 FAILED hr = %0x\n", hr);

	display_proxy_info(pSum);
	_getch();

	int sum;
	hr = pSum->Sum(4, 9, &sum);
	if(SUCCEEDED(hr))
		cout << "Client: Calling Sum() return value is " << sum << endl;
	if(FAILED(hr))
		printf("Sum failed %0x\n", hr);

	cout << "Client: Calling Release() for pSum" << endl;
	hr = pSum->Release();

	*retval = sum;

	CoRevertToSelf();

	return S_OK;
}

class CFactory : public IClassFactory
{
public:
	// IUnknown
	ULONG __stdcall AddRef();
	ULONG __stdcall Release();
	HRESULT __stdcall QueryInterface(REFIID riid, void** ppv);

	// IClassFactory
	HRESULT __stdcall CreateInstance(IUnknown *pUnknownOuter, REFIID riid, void** ppv);
	HRESULT __stdcall LockServer(BOOL bLock);

	CFactory() : m_cRef(1) { }
	~CFactory() { }

private:
	ULONG m_cRef;
};

ULONG CFactory::AddRef()
{
	return ++m_cRef;
}

ULONG CFactory::Release()
{
	if(--m_cRef != 0)
		return m_cRef;
	delete this;
	return 0;
}

HRESULT CFactory::QueryInterface(REFIID riid, void** ppv)
{
	if((riid == IID_IUnknown) || (riid == IID_IClassFactory))
		*ppv = (IClassFactory*)this;
	else
	{
		*ppv = NULL;
		return E_NOINTERFACE;
	}
	AddRef();
	return S_OK;
}

HRESULT CFactory::CreateInstance(IUnknown *pUnknownOuter, REFIID riid, void** ppv)
{
	if(pUnknownOuter != NULL)
		return CLASS_E_NOAGGREGATION;

	CInsideCOM *pInsideCOM = new CInsideCOM;
	cout << "Component: CFactory::CreateInstance() " << pInsideCOM << endl;

	if(pInsideCOM == NULL)
		return E_OUTOFMEMORY;

	// QueryInterface probably for IID_IUNKNOWN
	HRESULT hr = pInsideCOM->QueryInterface(riid, ppv);
	pInsideCOM->Release();
	return hr;
}

HRESULT CFactory::LockServer(BOOL bLock)
{
	if(bLock)
		g_cServerLocks++;
	else
		g_cServerLocks--;
	return S_OK;
}

void RegisterComponent()
{
	ITypeLib* pTypeLib;
	LoadTypeLibEx(L"Component B.exe", REGKIND_DEFAULT, &pTypeLib);
	pTypeLib->Release();
	RegisterServer("Component B.exe", CLSID_InsideCOM_B, "Inside COM+ Sample", "Component.InsideCOM_B", "Component.InsideCOM_B.1", NULL);
}

void CommandLineParameters(int argc, char** argv)
{
	RegisterComponent();
	if(argc < 2)
	{
		cout << "No parameter, but registered anyway" << endl;
		exit(false);
	}
	char* szToken = strtok(argv[1], "-/"); 
	if(_stricmp(szToken, "RegServer") == 0)
	{
		RegisterComponent();
		cout << "RegServer" << endl;
		exit(true);
	}
	if(_stricmp(szToken, "UnregServer") == 0)
	{
		UnRegisterTypeLib(LIBID_Component, 1, 0, LANG_NEUTRAL, SYS_WIN32);
		UnregisterServer(CLSID_InsideCOM_B, "Component.InsideCOM_B", "Component.InsideCOM_B.1");
		cout << "UnregServer" << endl;
		exit(true);
	}
	if(_stricmp(szToken, "Embedding") != 0)
	{
		cout << "Invalid parameter" << endl;
		exit(false);
	}
}

void main(int argc, char** argv)
{
	HRESULT hr;
	CommandLineParameters(argc, argv);

	cout << "Component: CoInitializeEx()" << endl;
	hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
	if(FAILED(hr))
		cout << "CoInitializeEx Failed" << endl;

	SEC_WINNT_AUTH_IDENTITY_W identity;
	identity.User = L"B";
	identity.UserLength = wcslen(L"B");
	identity.Domain = L"GuysDomain";
	identity.DomainLength = wcslen(L"GuysDomain");
	identity.Password = L"B";
	identity.PasswordLength = wcslen(L"B");
	identity.Flags = SEC_WINNT_AUTH_IDENTITY_UNICODE;

	SOLE_AUTHENTICATION_INFO info;
	info.dwAuthnSvc = RPC_C_AUTHN_GSS_KERBEROS;
	info.dwAuthzSvc = RPC_C_AUTHZ_NONE;
	info.pAuthInfo = &identity;
	
	SOLE_AUTHENTICATION_LIST list;
	list.cAuthInfo = 1;
	list.aAuthInfo = &info;

	SOLE_AUTHENTICATION_SERVICE service;
	service.dwAuthnSvc = RPC_C_AUTHN_GSS_KERBEROS;
	service.dwAuthzSvc = RPC_C_AUTHZ_NONE;
	service.hr = 0;
	service.pPrincipalName = L"GuysDomain\\B";

	hr = CoInitializeSecurity(0, 1, &service, NULL, RPC_C_AUTHN_LEVEL_CONNECT, RPC_C_IMP_LEVEL_DELEGATE, 
		NULL, EOAC_NONE, NULL);
	if(FAILED(hr))
	{
		printf("CoInitializeSecurity Failed = %0x\n", hr);
		_getch();
	}

	printf("CoInitializeSecurity service.hr = %0x\n", service.hr);

	IClassFactory *pClassFactory = new CFactory();

	cout << "Component: CoRegisterClassObject()" << endl;
	DWORD dwRegister;
	CoRegisterClassObject(CLSID_InsideCOM_B, pClassFactory, CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE, &dwRegister);

	g_hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	WaitForSingleObject(g_hEvent, INFINITE);

	CoRevokeClassObject(dwRegister);
	pClassFactory->Release();
	CoUninitialize();
	cout << "By Bye" << endl;
//	_getch();
}