// COMDispatch.h: interface for the IDispatch class.
//////////////////////////////////////////////////////////////////////
#ifndef _DISPATCH_H_20011012_BY_CDECL_
#define _DISPATCH_H_20011012_BY_CDECL_
#include <comdef.h>
#include <vector>
#define BYREF(x) GLASS::COMDispatch::ToRefParam((x))
namespace GLASS {
class COMDispatch
{
public:
typedef std::vector<_variant_t> vec_param;
typedef _variant_t PT;
// Proxy Class
class Proxy
{
public:
void SetParent(COMDispatch *p) { pDisp_ = p; }
void SetPropName(const _bstr_t &bstrName) { bstrName_ = bstrName; }
_variant_t operator=(const _variant_t &var) const
{
pDisp_->PutProperty(bstrName_, var);
return var;
}
operator _variant_t() const {
return pDisp_->GetProperty(bstrName_);
}
_variant_t operator() ()
{
vec_param vecParams;
return pDisp_->Call(bstrName_, vecParams);
}
template <typename...VARS>
_variant_t operator() (VARS...param)
{
vec_param vecParams = Param(param...);
return pDisp_->Call(bstrName_, vecParams);
}
private:
template <typename Vartype>
vec_param Param(Vartype p)
{
vec_param v;
v.push_back(p);
return std::move(v);
}
template <typename Vartype, typename...VARS>
vec_param Param(Vartype p, VARS...vs)
{
vec_param v = Param(vs...);
v.push_back(p);
return std::move(v);
}
private:
COMDispatch *pDisp_;
_bstr_t bstrName_;
};
public:
COMDispatch() : spDispatch_(NULL) { proxy_.SetParent(this); }
COMDispatch(const COMDispatch &disp) : spDispatch_(disp.spDispatch_) { proxy_.SetParent(this); }
explicit COMDispatch(const _variant_t &var) : spDispatch_(var) { proxy_.SetParent(this); }
COMDispatch(const char *) = delete;
COMDispatch(const wchar_t *) = delete;
virtual ~COMDispatch() { Release(); }
COMDispatch& operator=(const COMDispatch &disp);
COMDispatch& operator=(const _variant_t &var);
public:
_variant_t Call(const _bstr_t &bstrMethodName, vec_param &vecParams);
void PutProperty(const _bstr_t &strPropName, const _variant_t &var, bool bRef = false);
_variant_t GetProperty(const _bstr_t &strPropName);
virtual Proxy& operator[](const _bstr_t &bstrPropName);
virtual void CreateObject(const _bstr_t &bstrProgID);
virtual void Release();
public:
virtual void GetIDsOfNames(const _bstr_t &bstrMethodName, DISPID &lDispID);
protected:
virtual void Invoke(const DISPID lDispID, vec_param &vecParams, _variant_t &varRetVal,
const WORD wFlags = DISPATCH_METHOD);
public:
static _variant_t ToRefParam(_variant_t &var);
protected:
Proxy proxy_;
IDispatchPtr spDispatch_;
};
//////////////////////////////////////////////////////////////////////
// Dispatch implementation
COMDispatch& COMDispatch::operator=(const COMDispatch &disp)
{
if (this != &disp) {
spDispatch_ = disp.spDispatch_;
proxy_.SetParent(this);
}
return *this;
}
COMDispatch& COMDispatch::operator=(const _variant_t &var)
{
spDispatch_ = var;
proxy_.SetParent(this);
return *this;
}
void COMDispatch::Release()
{
if (spDispatch_ != NULL) {
spDispatch_.Release();
}
}
void COMDispatch::CreateObject(const _bstr_t &bstrProgID)
{
HRESULT hr = spDispatch_.CreateInstance((LPCSTR)bstrProgID);
if (FAILED(hr)) {
_com_raise_error(hr);
}
}
_variant_t COMDispatch::Call(const _bstr_t &bstrMethodName, vec_param &vecParams)
{
DISPID lDispID;
GetIDsOfNames(bstrMethodName, lDispID);
_variant_t varRetVal;
Invoke(lDispID, vecParams, varRetVal);
return varRetVal;
}
COMDispatch::Proxy& COMDispatch::operator[](const _bstr_t &bstrPropName)
{
proxy_.SetPropName(bstrPropName);
return proxy_;
}
void COMDispatch::PutProperty(const _bstr_t &strPropName, const _variant_t &var, bool bRef)
{
DISPID lDispID;
GetIDsOfNames(strPropName, lDispID);
vec_param vecParams;
vecParams.push_back(var);
_variant_t varRetVal;
Invoke(lDispID, vecParams, varRetVal, bRef ? DISPATCH_PROPERTYPUTREF : DISPATCH_PROPERTYPUT);
}
_variant_t COMDispatch::GetProperty(const _bstr_t &strPropName)
{
DISPID lDispID;
GetIDsOfNames(strPropName, lDispID);
vec_param vecParams;
_variant_t varRetVal;
Invoke(lDispID, vecParams, varRetVal, DISPATCH_PROPERTYGET);
return varRetVal;
}
void COMDispatch::GetIDsOfNames(const _bstr_t &bstrMethodName, DISPID &lDispID)
{
BSTR bstrMN = static_cast<BSTR>(bstrMethodName);
HRESULT hr = spDispatch_->GetIDsOfNames(IID_NULL, &bstrMN, 1, LOCALE_SYSTEM_DEFAULT, &lDispID);
if (FAILED(hr)) {
_com_raise_error(hr);
}
}
void COMDispatch::Invoke(const DISPID lDispID, vec_param &vecParams, _variant_t &varRetVal, const WORD wFlags)
{
DISPPARAMS dispparams = { 0 };
DISPID dsipid_put = DISPID_PROPERTYPUT;
if (DISPATCH_PROPERTYGET != wFlags) {
dispparams.cArgs = vecParams.size();
dispparams.rgvarg = (vecParams.size() == 0) ? NULL : &vecParams.front();
if ((DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF) & wFlags) {
dispparams.rgdispidNamedArgs = &dsipid_put;
dispparams.cNamedArgs = 1;
}
}
HRESULT hr = spDispatch_->Invoke(
lDispID,
IID_NULL,
LOCALE_USER_DEFAULT,
wFlags,
&dispparams,
DISPATCH_PROPERTYPUT == wFlags ? NULL : &varRetVal,
NULL,
NULL
);
if (FAILED(hr)) {
_com_raise_error(hr);
}
}
_variant_t COMDispatch::ToRefParam(_variant_t &var)
{
_variant_t varRet;
varRet.vt = VT_BYREF | VT_VARIANT;
varRet.pvarVal = &var;
return varRet;
}
} // end namespace
, 그리고 
부터 
까지의 정수 
를 선택하여 사전에 밥과 공유한다.
, 즉 
를 
를 계산한다.
와 
를 전송한다.
를, 밥이 
를 계산한다.
, 
이며 따라서 앨리스와 밥은 
라는 공통의 비밀 키를 공유하게 된다.
를 알 수 있다.
를 통해 
를 알아낼 수 없는 것으로 알려져 있다. 앨리스와 밥은 두 사람 만이 아는 비밀 키 
, 
가 너무 작을 경우, 도청자는 가능한 모든 조합을 다 계산해보는 방식으로 
를 구해야 한다. 이 문제를 디피-헬만 문제(Diffie-Hellman problem)로 부르며, 이 문제를 푸는 효율적인 
의 차수가 소수이거나, 인수분해하기 어려운 큰 소수를 약수로 갖도록 해야 한다. 이 때문에 
이 모두 소수인 
또는 
