windows-xp/Source/XPSP1/NT/net/mmc/dialinusr/rasdial.cpp

/**********************************************************************/
/**                       Microsoft Windows/NT                       **/
/**                Copyright(c) Microsoft Corporation, 1997 - 1999 **/
/**********************************************************************/

/*
	rasdial.cpp
		Definition of CRASProfile class and CRASUser class

    FILE HISTORY:

*/
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include <sspi.h>
#include <secext.h>
#include <dsgetdc.h>
#include "resource.h"
#include "helper.h"
#include "rasdial.h"
#include "rasprof.h"
#include "sharesdo.h"

#define	_WEI_DEBUG

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

#define	ERRORCODE_NOTFOUND	ERROR_FILE_NOT_FOUND		// win32 error

CRASUserMerge::CRASUserMerge(RasEnvType type, LPCWSTR location, LPCWSTR userPath)
{
	// environment info
	m_type = type;
	m_strMachine = location;

	m_strUserPath = userPath;

	// Ip Addresses
	m_dwFramedIPAddress = 0;
	m_dwDefinedAttribMask = 0;
};

HRESULT	CRASUserMerge::HrGetDCName(CString& DcName)
{
	HRESULT	hr = S_OK;
	VARIANT	v;
	VariantInit(&v);
	CComPtr<IADs>	spIADs;
	CComPtr<IADsObjectOptions> spOps;

	USES_CONVERSION;
	CHECK_HR( hr = ADsGetObject(T2W((LPTSTR)(LPCTSTR)m_strUserPath), IID_IADs, (void**)&spIADs));
	ASSERT(spIADs.p);
 
	CHECK_HR(hr = spIADs->QueryInterface(IID_IADsObjectOptions,(void**)&spOps));
 
	CHECK_HR(hr = spOps->GetOption(ADS_OPTION_SERVERNAME,&v));

	ASSERT(V_VT(&v) == VT_BSTR);

	DcName = V_BSTR(&v);

	VariantClear(&v);
		
L_ERR:
	VariantClear(&v);
	return hr;
};


HRESULT	CRASUserMerge::HrIsInMixedDomain()
{
	HRESULT	hr = S_OK;
	VARIANT	v;
	VariantInit(&v);
	
	if(!m_strMachine.IsEmpty())	// local user, so not
		return S_FALSE;
	else
	{
		// try to use SDO
		IASDOMAINTYPE domainType;
		if((ISdoMachine*)m_spISdoServer != NULL)	// already created
		{
			if(m_spISdoServer->GetDomainType(&domainType) == S_OK)
			{
				if (domainType == DOMAIN_TYPE_MIXED)
					return S_OK;
				else
					return S_FALSE;
			}

		}

		// if for any reason, SDO doesn't provide the information, do it myself
		// Canonical Name Format
		TCHAR	szName[MAX_PATH * 2];
		ULONG	size = MAX_PATH * 2;
		CString	DomainPath;
		CString strTemp;
		CComPtr<IADs>	spIADs;
		int		i;

		USES_CONVERSION;
		CHECK_HR( hr = ADsGetObject(T2W((LPTSTR)(LPCTSTR)m_strUserPath), IID_IADs, (void**)&spIADs));
		ASSERT(spIADs.p);
		CHECK_HR( hr = spIADs->Get(L"distinguishedName", &v));

		ASSERT(V_VT(&v) == VT_BSTR);

		CHECK_HR(hr = ::TranslateName(V_BSTR(&v), NameFullyQualifiedDN, NameCanonical, szName, &size));

		VariantClear(&v);
		
		strTemp = szName;
		i  = strTemp.Find(_T('/'));

		if(i != -1)
			strTemp = strTemp.Left(i);

		// DN of the domain
		DomainPath = _T("LDAP://");
		DomainPath += strTemp;

		
		spIADs.Release();

		CHECK_HR(hr = ADsGetObject(T2W((LPTSTR)(LPCTSTR)DomainPath), IID_IADs, (void**)&spIADs));
		ASSERT(spIADs.p);
		CHECK_HR(hr = spIADs->Get(L"nTMixedDomain", &v));

		ASSERT(V_VT(&v) == VT_BOOL || V_VT(&v) == VT_I4);

		if(V_BOOL(&v))	hr = S_OK;
		else	hr = S_FALSE;
	}
L_ERR:
	VariantClear(&v);
	return hr;
}

BOOL	CRASUserMerge::IfAccessAttribute(ULONG id)
{
	if(S_OK == HrIsInMixedDomain()) // only allow dialin bit and callback policy
	{
		switch(id)
		{
		case	PROPERTY_USER_IAS_ATTRIBUTE_ALLOW_DIALIN:		// allow dialin or not
		case	PROPERTY_USER_msRADIUSCallbackNumber:			// call back number
		case	PROPERTY_USER_RADIUS_ATTRIBUTE_SERVICE_TYPE:	// call back policy
			return TRUE;
		default:
			return FALSE;
		}
	}
	else	// no restriction otherwise
		return TRUE;
}

HRESULT	CRASUserMerge::SetRegistryFootPrint()
{
	if(IsFocusOnLocalUser())
	{
		RegKey	RemoteAccessParames;
		LONG	lRes = RemoteAccessParames.Create(RAS_REG_ROOT, REGKEY_REMOTEACCESS_PARAMS,
					REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, (LPCTSTR)m_strMachine);
					
		if (lRes != ERROR_SUCCESS)
			return HRESULT_FROM_WIN32(lRes);
	
		//================================================
		// save the values to the key
		DWORD regValue = REGVAL_VAL_USERSCONFIGUREDWITHMMC;
		lRes = RemoteAccessParames.SetValue(REGVAL_NAME_USERSCONFIGUREDWITHMMC, regValue);
	}

	return S_OK;
}

//====================================================
//
// CRASUserMerge::Load
//
// load RASUser object from DS
// pcwszUserPath: is the ADsPath of the DSuser object, the RASUser object is
// object contained in DSUser object
// when, the RASUser object doesn't exist, load will call
// CreateDefault to create one object for this DSUser
HRESULT CRASUserMerge::Load()
{
	// new function added for no DS machine :   weijiang 12/17/97

	USES_CONVERSION;
	
	TRACE(_T("Enter CRASUserMerge::Load()\r\n"));

	// Load is not expected to be called more than once
	ASSERT(!m_spISdoServer.p);

	VARIANT				var;
	HRESULT				hr = S_OK;
	CComPtr<ISdo>		spSdo;
	CComPtr<IUnknown>	spUnk;
	BSTR				bstrMachineName = NULL;
	BSTR				bstrUserPath = NULL;
	UINT				nServiceType = 0;
	IASDATASTORE		storeFlags;
	CComPtr<ISdo>		spIRasUser;
	
	VariantInit(&var);


	// one more function call to SDOSERver to set machine information
	// Get the user SDO

	if(m_strMachine.IsEmpty())	// focused on DS
	{
		storeFlags = DATA_STORE_DIRECTORY;

		CString sDCName;

		CHECK_HR(hr = HrGetDCName(sDCName));

		CBSTR	bstrDomainController(sDCName);
		bstrMachineName = T2BSTR((LPTSTR)(LPCTSTR)sDCName);
	}
	else	// local machine
	{
		storeFlags = DATA_STORE_LOCAL;
		bstrMachineName = T2BSTR((LPTSTR)(LPCTSTR)m_strMachine);

	}

	// connect to server
#ifdef SINGLE_SDO_CONNECTION 	// for share the same sdo connection for multiple users			
	// connection will NOT be necessary after SDO changes to RTM version.
	// connect once for each process
	CHECK_HR(hr = m_MarshalSdoServer.GetServer(&m_spISdoServer));
	{
		CWaitCursor	wc;

		// if we get the server back from the shareSDO object, we use it to connect
		if ((ISdoMachine*)m_spISdoServer)
		{
			CHECK_HR(hr = m_MarshalSdoServer.Connect());
		}
		// otherwise, we make a new connection
		else
		{
			// try to Connect the old way
			// connect everytime a user page is requested
			CHECK_HR(hr = ConnectToSdoServer(bstrMachineName, NULL, NULL, &m_spISdoServer));
		}
	}

#else
	// connect everytime a user page is requested
	CHECK_HR(hr = ConnectToSdoServer(bstrMachineName, NULL, NULL, &m_spISdoServer));
#endif

	// If for local users, only NT5 servers are allowed to configure using this apge
	if(!m_strMachine.IsEmpty())	// not focused on DS
	{
		IASOSTYPE	OSType;

		CHECK_HR(hr =  m_spISdoServer->GetOSType(&OSType));
		if(OSType != SYSTEM_TYPE_NT5_SERVER)
		{
			hr = S_FALSE;
			goto L_ERR;
		}

	}

	// find the user object
	bstrUserPath = T2BSTR((LPTSTR)(LPCTSTR)m_strUserPath);
	TracePrintf(g_dwTraceHandle,_T("SdoServer::GetUserSDO(%x, %s, %x"), storeFlags, bstrUserPath, &spUnk);
	CHECK_HR(hr = m_spISdoServer->GetUserSDO( storeFlags, bstrUserPath, &spUnk));
	TracePrintf(g_dwTraceHandle,_T(" hr = %8x\r\n"), hr);
	ASSERT(spUnk.p);

	CHECK_HR(hr = spUnk->QueryInterface(IID_ISdo, (void**)&spIRasUser));
	ASSERT(spIRasUser.p);

	// initialize the wrapper class
	CHECK_HR(hr = m_SdoWrapper.Init((ISdo*)spIRasUser));
	
	// Get All the properties

	// need to handle the case when the values don't exist

	TRACE(_T("Getting Properties\r\n"));

	m_dwDefinedAttribMask = 0;
	
	// m_dwDialinPermit

	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_IAS_ATTRIBUTE_ALLOW_DIALIN, &var));
	if(V_VT(&var) == VT_I4 || V_VT(&var) == VT_BOOL)
	{
		if(V_BOOL(&var) != 0)
			m_dwDialinPermit = 1;
		else
			m_dwDialinPermit = 0;
	}
	else
		m_dwDialinPermit = -1;	// the value is not defined in the user data, using policy to decide
	

	// FramedIPAddress
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_msRADIUSFramedIPAddress, &var));

	if(V_VT(&var) == VT_I4)
	{
		m_dwDefinedAttribMask |= RAS_USE_STATICIP;
		m_dwFramedIPAddress = V_I4(&var);
	}
	else
	{
		VariantClear(&var);
		CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_msSavedRADIUSFramedIPAddress, &var));
		if(V_VT(&var) == VT_I4)
			m_dwFramedIPAddress = V_I4(&var);
		else
			m_dwFramedIPAddress = 0;
	}

	// Service Type -- to hold if this user has callback, if this user allowed to dialin
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_RADIUS_ATTRIBUTE_SERVICE_TYPE, &var));

	if(V_VT(&var) == VT_I4)
	{
		nServiceType = V_I4(&var);
	}

	// call back number
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_msRADIUSCallbackNumber, &var));

	if(V_VT(&var) == VT_BSTR)
	{
		m_strCallbackNumber = V_BSTR(&var);
		if(nServiceType == RADUIS_SERVICETYPE_CALLBACK_FRAME && m_strCallbackNumber.IsEmpty())
			m_dwDefinedAttribMask |= RAS_CALLBACK_CALLERSET;
		else if (nServiceType == RADUIS_SERVICETYPE_CALLBACK_FRAME)
			m_dwDefinedAttribMask |= RAS_CALLBACK_SECURE;
	}
	else
	{
		if(nServiceType == RADUIS_SERVICETYPE_CALLBACK_FRAME)
			m_dwDefinedAttribMask |= RAS_CALLBACK_CALLERSET;
		else
			m_dwDefinedAttribMask |= RAS_CALLBACK_NOCALLBACK;

		VariantClear(&var);
		CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_msSavedRADIUSCallbackNumber, &var));
		if(V_VT(&var) == VT_BSTR)
			m_strCallbackNumber = V_BSTR(&var);
	}

	// calling station id
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_msNPCallingStationID, &var));
	
	if(V_VT(&var) & VT_ARRAY)
	{
		m_strArrayCallingStationId = V_ARRAY(&var);
		m_dwDefinedAttribMask |= RAS_USE_CALLERID;
	}
	else
	{
		VariantClear(&var);
		CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_msSavedNPCallingStationID, &var));
		if(V_VT(&var) & VT_ARRAY)
			m_strArrayCallingStationId = V_ARRAY(&var);
	}
	
	// framed routes
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_msRADIUSFramedRoute, &var));

	if(V_VT(&var) & VT_ARRAY)
	{
		m_strArrayFramedRoute = V_ARRAY(&var);
		m_dwDefinedAttribMask |= RAS_USE_STATICROUTES;
	}
	else
	{
		VariantClear(&var);
		CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_USER_msSavedRADIUSFramedRoute, &var));
		if(V_VT(&var) & VT_ARRAY)
			m_strArrayFramedRoute = V_ARRAY(&var);
	}
	
L_ERR:
	TracePrintf(g_dwTraceHandle, _T("hr = %8x\r\n"), hr);
	VariantClear(&var);
	SysFreeString(bstrMachineName);
	SysFreeString(bstrUserPath);

	TracePrintf(g_dwTraceHandle, _T("Leave CRASUserMerge::Load(), hr = %8x\r\n"), hr);

	return hr;
}

//====================================================
// CRASUserMerge::Save
//
// save ths RASUser object

HRESULT CRASUserMerge::Save()
{
	TRACE(_T("Enter CRASUserMerge::Save()\r\n"));
	HRESULT		hr = S_OK;
	VARIANT		var;

	USES_CONVERSION;

	// restore SDO user from 
	// otherwise, we could overwrite the other properties in usrparams field
	// fix bug: 86968
	m_SdoWrapper.Commit(FALSE);
	
	VariantInit(&var);

	//==========================
	// Dialin bit
	VariantClear(&var);
	V_VT(&var) = VT_BOOL;
	switch(m_dwDialinPermit)
	{
	case	1:	// allow
	case	0:	// deny
		if(m_dwDialinPermit == 1)
			V_I4(&var) = VARIANT_TRUE; // Variant TRUE
		else
			V_I4(&var) = VARIANT_FALSE;
			
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_IAS_ATTRIBUTE_ALLOW_DIALIN, &var));
		
		break;
		
	case	-1:	// decide by policy -- remove attribute
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_IAS_ATTRIBUTE_ALLOW_DIALIN));
		break;

	default:
		ASSERT(0);	// if need to provide new code
		
	}

	//==========================
	// Service Type -- callback policy
	if(m_dwDefinedAttribMask & (RAS_CALLBACK_SECURE | RAS_CALLBACK_CALLERSET))
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = RADUIS_SERVICETYPE_CALLBACK_FRAME;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_RADIUS_ATTRIBUTE_SERVICE_TYPE, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_RADIUS_ATTRIBUTE_SERVICE_TYPE));

	//==========================
	// call back number
	if (!m_strCallbackNumber.IsEmpty() && (m_dwDefinedAttribMask & RAS_CALLBACK_SECURE))
	{
		VariantClear(&var);
		V_VT(&var) = VT_BSTR;
		V_BSTR(&var) = T2BSTR((LPTSTR)(LPCTSTR)m_strCallbackNumber);
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_msRADIUSCallbackNumber, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_msRADIUSCallbackNumber));
		
	if(S_OK != HrIsInMixedDomain())
	{
		//==========================
		// call back number
		if(!m_strCallbackNumber.IsEmpty())
		{
			VariantClear(&var);
			V_VT(&var) = VT_BSTR;
			V_BSTR(&var) = T2BSTR((LPTSTR)(LPCTSTR)m_strCallbackNumber);
			CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_msSavedRADIUSCallbackNumber, &var));
		}
		else
			CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_msSavedRADIUSCallbackNumber));

		//==========================
		// FramedIPAddress
		if(m_dwFramedIPAddress)	// need to back up the data, no matter if it's used
		{
			VariantClear(&var);
			V_VT(&var) = VT_I4;
			V_I4(&var) = m_dwFramedIPAddress;
			CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_msSavedRADIUSFramedIPAddress, &var));
		}
		else	// remove it
			CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_msSavedRADIUSFramedIPAddress));

		if(m_dwFramedIPAddress && (m_dwDefinedAttribMask & RAS_USE_STATICIP))
		{
			CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_msRADIUSFramedIPAddress, &var));
		}
		else
			CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_msRADIUSFramedIPAddress));

	}
	
	//==========================
	// calling station id
	if(S_OK != HrIsInMixedDomain())
	{
		if(m_strArrayCallingStationId.GetSize())
		{
			VariantClear(&var);
			V_VT(&var) = VT_VARIANT | VT_ARRAY;
			V_ARRAY(&var) = (SAFEARRAY*)m_strArrayCallingStationId;
			CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_msSavedNPCallingStationID, &var));
		}
		else
			CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_msSavedNPCallingStationID));

		if(m_strArrayCallingStationId.GetSize() && (m_dwDefinedAttribMask & RAS_USE_CALLERID))
		{
			CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_msNPCallingStationID, &var));
		}
		else
			CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_msNPCallingStationID));

		//==========================
		// framed routes
		if(m_strArrayFramedRoute.GetSize())
		{
			VariantClear(&var);
			V_VT(&var) = VT_VARIANT | VT_ARRAY;
			V_ARRAY(&var) = (SAFEARRAY*)m_strArrayFramedRoute;
			CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_msSavedRADIUSFramedRoute, &var));
		}
		else
			CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_msSavedRADIUSFramedRoute));
	
		if(m_strArrayFramedRoute.GetSize() && (m_dwDefinedAttribMask & RAS_USE_STATICROUTES))
		{
			CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_USER_msRADIUSFramedRoute, &var));
		}
		else
			CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_USER_msRADIUSFramedRoute));

	}
	CHECK_HR(hr = m_SdoWrapper.Commit());

	// touch the registry to make connection UI know.
	SetRegistryFootPrint();
L_ERR:
	VariantClear(&var);

	TRACE(_T("Leave CRASUserMerge::Save()\r\n"));

	return hr;
}



// to detect if driver level support 128 bit encryption, 
HRESULT	CRASProfileMerge::GetRasNdiswanDriverCaps(RAS_NDISWAN_DRIVER_INFO *pInfo)
{
    HANDLE		hConn;
    RAS_NDISWAN_DRIVER_INFO	pDriverInfo;

	DWORD	dwErr = RasRpcConnectServer((LPTSTR)(LPCTSTR)m_strMachineName, &hConn);

	if (dwErr != NOERROR)
		return HRESULT_FROM_WIN32(dwErr);

	dwErr = RasGetNdiswanDriverCaps(hConn, pInfo);

	RasRpcDisconnectServer(hConn);

	return HRESULT_FROM_WIN32(dwErr);
}





#define	EAP_TLS_ID		13

// EAP type list -- !!! Need to implement
HRESULT	CRASProfileMerge::GetEapTypeList(
											CStrArray&			EapTypes,
											CDWArray&			EapIds,
											CDWArray&			EAPTypeKeys,
											AuthProviderArray*	pProvList)
{
	HRESULT		hr = S_OK;
	
#ifndef __EAPLIST_USES_SDO__
	AuthProviderArray	__tmpArray;
	CString*	pStr = NULL;
	DWORD		dwID;
	DWORD		dwKey;
    int			i;

	if(!pProvList)	// if not provided
		pProvList = &__tmpArray;

	CHECK_HR(hr = GetEapProviders(m_strMachineName, pProvList));

	// fill in the buffers for name, Id, and keys
	
	for(i = 0; i < pProvList->GetSize(); i++)
	{
		AuthProviderData* pProv = &(pProvList->ElementAt(i));
			
		try
		{
			pStr = new CString(pProv->m_stTitle);
			dwID = _ttol(pProv->m_stKey);
			dwKey = pProv->m_fSupportsEncryption;

			// put the above to the arrays
			EapIds.Add(dwID);
			EAPTypeKeys.Add(dwKey);
			EapTypes.Add(pStr);
		}
		catch(CMemoryException&)
		{
			EapIds.DeleteAll();
			EAPTypeKeys.DeleteAll();
			EapTypes.DeleteAll();
			CHECK_HR(hr = E_OUTOFMEMORY);
		}
	}

#else
	ASSERT(m_spIDictionary.p);

	VARIANT	vNames;
	VARIANT	vIds;
	int		j, count;

	VariantInit(&vNames);
	VariantInit(&vIds);

	CString*	pStr = NULL;
	DWORD		dwKey = 0;


	CHECK_HR(hr = m_spIDictionary->EnumAttributeValues((ATTRIBUTEID)PROPERTY_PROFILE_msNPAllowedEapType, &vIds,  &vNames));

	ASSERT(V_VT(&vNames) & VT_ARRAY);
	ASSERT(V_VT(&vIds) & VT_ARRAY);

	EAPTypeKeys.DeleteAll();

	try{
		EapTypes = (SAFEARRAY*)V_ARRAY(&vNames);
		EapIds = (SAFEARRAY*)V_ARRAY(&vIds);
	}
	catch(CMemoryException&)
	{
		hr = E_OUTOFMEMORY;
	}

	ASSERT(EapIds.GetSize() == EapTypes.GetSize()); 	// they need to be in pairs
	count = EapTypes.GetSize();

	if(EapIds.GetSize() != count)
		hr = E_FAIL;

	// remove the leading charater for EapKey and put the key into a separate array
	for(j = 0; j < count; j++)
	{
		CString*	pStr = EapTypes.GetAt(j);

		ASSERT(pStr);
		pStr->TrimLeft();
		pStr->TrimRight();

		dwKey = (pStr->GetAt(0) == _T('1'));

		int i = pStr->Find(_T(':'));

		if(i != -1)
			*pStr = pStr->Mid(i + 1);

		EAPTypeKeys.Add(dwKey);

		// append TLS string with RAS specific
		if(EapIds.GetAt(j) == EAP_TLS_ID)
		{	
			CString	str;
			str.LoadString(IDS_RASSPECIFIC);
			*pStr += str;
		}
	}

#endif
L_ERR:
	return hr;
}

	// Medium Type list -- !! Need to implement
HRESULT	CRASProfileMerge::GetPortTypeList(CStrArray& Names, CDWArray& MediumIds)
{
	TRACE(_T("Enter CRASProfileMerge::GetPortTypeList\n"));
	ASSERT(m_spIDictionary.p);

	VARIANT	vNames;
	VARIANT	vIds;

	VariantInit(&vNames);
	VariantInit(&vIds);

	HRESULT		hr = S_OK;

	CHECK_HR(hr = m_spIDictionary->EnumAttributeValues((ATTRIBUTEID)PROPERTY_PROFILE_msNPAllowedPortTypes, &vIds, &vNames));

	ASSERT(V_VT(&vNames) & VT_ARRAY);
	ASSERT(V_VT(&vIds) & VT_ARRAY);

	try{
		Names = (SAFEARRAY*)V_ARRAY(&vNames);
		MediumIds = (SAFEARRAY*)V_ARRAY(&vIds);
	}
	catch(CMemoryException&)
	{
		hr = E_OUTOFMEMORY;
	}

	ASSERT(MediumIds.GetSize() == Names.GetSize());   	// they need to be in pairs
	if(MediumIds.GetSize() != Names.GetSize())
		hr = E_FAIL;

L_ERR:
	TRACE(_T("Leave CRASProfileMerge::GetPortTypeList\n"));
	return hr;
}
	
//====================================================
//
// CRASProfileMerge::Load
//
// pcwszRelativePath -- the relative name for the profile object
//
HRESULT CRASProfileMerge::Load()
{
	TRACE(_T("Enter CRASProfileMerge::Load()\r\n"));

	// ==
	ASSERT(m_spIProfile.p);
	ASSERT(m_spIDictionary.p);

	VARIANT		var;
	HRESULT		hr = S_OK;

	// Init the flags to NULL, each bit of the flag is used tell if a particular
	// attribute is defined
	m_dwAttributeFlags = 0;

	VariantInit(&var);
	
	//==================================================
	// constraints dialog

	/*
	// Constraints Dialog
		PROPERTY_PROFILE_msNPTimeOfDay
		PROPERTY_PROFILE_msNPCalledStationId
		PROPERTY_PROFILE_msNPAllowedPortTypes
		PROPERTY_PROFILE_msRADIUSIdleTimeout
		PROPERTY_PROFILE_msRADIUSSessionTimeout
	*/

	// Sessions Allowed
	CHECK_HR(hr = m_SdoWrapper.Init(PROPERTY_PROFILE_ATTRIBUTES_COLLECTION, m_spIProfile, m_spIDictionary));

	// Time Of Day
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msNPTimeOfDay, &var));

	if(V_VT(&var) & VT_ARRAY)
	{
		m_strArrayTimeOfDay = V_ARRAY(&var);
		m_dwAttributeFlags |= PABF_msNPTimeOfDay;
	}
	else
		m_strArrayTimeOfDay.DeleteAll();

	// called station id
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msNPCalledStationId, &var));

	if(V_VT(&var) & VT_ARRAY)
	{
		m_strArrayCalledStationId = V_ARRAY(&var);
		m_dwAttributeFlags |= PABF_msNPCalledStationId;
	}
	else
		m_strArrayCalledStationId.DeleteAll();

	// allowed port types
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msNPAllowedPortTypes, &var));
	if(V_VT(&var) & VT_ARRAY)
	{
		m_dwArrayAllowedPortTypes = V_ARRAY(&var);
		m_dwAttributeFlags |= PABF_msNPAllowedPortTypes;
	}
	else
		m_dwArrayAllowedPortTypes.DeleteAll();

	// idle timeout
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRADIUSIdleTimeout, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwIdleTimeout = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRADIUSIdleTimeout;
	}
	else
		m_dwIdleTimeout = RAS_DEF_IDLETIMEOUT;

	// session time out
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRADIUSSessionTimeout, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwSessionTimeout = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRADIUSSessionTimeout;
	}
	else
		m_dwSessionTimeout = RAS_DEF_SESSIONTIMEOUT;
	
	//============================================
	// networking
	/*
	// Networking Dialog
		PROPERTY_PROFILE_msRADIUSFramedIPAddress
	*/

	// framedIPAddress -- ip address assignment poilcy
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRADIUSFramedIPAddress, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwFramedIPAddress = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRADIUSFramedIPAddress;
	}
	else
		m_dwFramedIPAddress = RAS_DEF_IPADDRESSPOLICY;

	// filters
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRASFilter, &var));
#ifdef	FILTERS_AS_BSTR	
	if(V_VT(&var) == VT_BSTR)
	{
		m_cbstrFilters.AssignBSTR(V_BSTR(&var));
		m_dwAttributeFlags |= PAFB_msRASFilter;
	}
#else	// SAFEARRAY of UI1
	if(V_VT(&var) & VT_ARRAY)
	{
		CBYTEArray ba((SAFEARRAY*)V_ARRAY(&var));

		DWORD i = ba.GetSize();
		if(i > 0)
		{
			PBYTE	pByte = (PBYTE)malloc(i);
			if(pByte == NULL)
				CHECK_HR(hr = E_OUTOFMEMORY);	// jmp to error handling here

			DWORD j = i;
			ba.GetBlob(pByte, &i);
			ASSERT( i == j);	
			m_cbstrFilters.AssignBlob((const char *)pByte, i);
			
			free(pByte);
			
			if((BSTR)m_cbstrFilters == NULL)
				CHECK_HR(hr = E_OUTOFMEMORY);
				
			m_nFiltersSize = i;
			m_dwAttributeFlags |= PAFB_msRASFilter;
		}
	}
#endif

	else
	{
		m_cbstrFilters.Clean();
		m_nFiltersSize = 0;
	}



	//==============================================
	// multilink

	/*
	// Multilink Dialog
		PROPERTY_PROFILE_msRADIUSPortLimit
		PROPERTY_PROFILE_msRASBapLinednLimit
		PROPERTY_PROFILE_msRASBapLinednTime
		PROPERTY_PROFILE_msRASBapRequired
	*/

	// port limit
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRADIUSPortLimit, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwPortLimit = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRADIUSPortLimit;
	}
	else
		m_dwPortLimit = RAS_DEF_PORTLIMIT;

	// BAP required
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRASBapRequired, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwBapRequired = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRASBapRequired;
	}
	else
		m_dwBapRequired = RAS_DEF_BAPREQUIRED;

	// line down limit
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRASBapLinednLimit, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwBapLineDnLimit = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRASBapLinednLimit;
	}
	else
		m_dwBapLineDnLimit = RAS_DEF_BAPLINEDNLIMIT;

	// line down time
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRASBapLinednTime, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwBapLineDnTime = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRASBapLinednTime;
	}
	else
		m_dwBapLineDnTime = RAS_DEF_BAPLINEDNTIME;

	//==================================
	// authentication

	/*
	// Authentication Dialog
		PROPERTY_PROFILE_msNPAuthenticationType
		PROPERTY_PROFILE_msNPAllowedEapType
	*/

	// authentication type
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msNPAuthenticationType, &var));
	if(V_VT(&var) & VT_ARRAY)
	{
		m_dwArrayAuthenticationTypes = V_ARRAY(&var);
		m_dwAttributeFlags |= PABF_msNPAuthenticationType;
	}
	else
		m_dwArrayAuthenticationTypes.DeleteAll();

	// eap type
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msNPAllowedEapType, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwEapType = V_I4(&var);
		m_dwAttributeFlags |= PABF_msNPAllowedEapType;
	}
	else
		m_dwEapType = RAS_DEF_EAPTYPE;

	//=====================================
	// encryptioin

	/*
	// Encryption Dialog
		PROPERTY_PROFILE_msRASAllowEncryption
		PROPERTY_PROFILE_msRASEncryptionType
	*/

	// encryption type
	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRASEncryptionType, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwEncryptionType = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRASEncryptionType;
	}
	else
		m_dwEncryptionType = RAS_DEF_ENCRYPTIONTYPE;

	VariantClear(&var);
	CHECK_HR(hr = m_SdoWrapper.GetProperty(PROPERTY_PROFILE_msRASAllowEncryption, &var));
	if(V_VT(&var) == VT_I4)
	{
		m_dwEncryptionPolicy = V_I4(&var);
		m_dwAttributeFlags |= PABF_msRASAllowEncryption;
	}
	else
		m_dwEncryptionPolicy = RAS_DEF_ENCRYPTIONPOLICY;

	// specail code for error path
L_ERR:
	VariantClear(&var);
	TRACE(_T("Leave CRASProfileMerge::Load()\r\n"));

	return hr;
}

//====================================================
//	
// CRASProfile::Save
//
//

HRESULT CRASProfileMerge::Save()
{

	TRACE(_T("Enter CRASProfileMerge::Save()\r\n"));

	// ==
	ASSERT(m_spIProfile.p);
	ASSERT(m_spIDictionary.p);

	VARIANT		var;
	HRESULT		hr = S_OK;

	VariantInit(&var);
	

	USES_CONVERSION;


	//==================================================
	// constraints dialog

	/*
	// Constraints Dialog
		PROPERTY_PROFILE_msNPTimeOfDay
		PROPERTY_PROFILE_msNPCalledStationId
		PROPERTY_PROFILE_msNPAllowedPortTypes
		PROPERTY_PROFILE_msRADIUSIdleTimeout
		PROPERTY_PROFILE_msRADIUSSessionTimeout
	*/


	// idleTimeout
	if (m_dwAttributeFlags & PABF_msRADIUSIdleTimeout)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwIdleTimeout;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRADIUSIdleTimeout, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRADIUSIdleTimeout));

	// sessionTimeout
	if (m_dwAttributeFlags & PABF_msRADIUSSessionTimeout)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwSessionTimeout;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRADIUSSessionTimeout, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRADIUSSessionTimeout));

	// timeOfDay -- multivalue
	if (m_dwAttributeFlags & PABF_msNPTimeOfDay)
	{
		VariantClear(&var);
		V_VT(&var) =  VT_VARIANT | VT_ARRAY;
		V_ARRAY(&var) = (SAFEARRAY*)m_strArrayTimeOfDay;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msNPTimeOfDay, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msNPTimeOfDay));

	// calledStationId -- multivalue
	if (m_dwAttributeFlags & PABF_msNPCalledStationId)
	{
		VariantClear(&var);
		V_VT(&var) =  VT_VARIANT | VT_ARRAY;
		V_ARRAY(&var) = (SAFEARRAY*)m_strArrayCalledStationId;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msNPCalledStationId, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msNPCalledStationId));

	// allowedPortTypes
	if (m_dwAttributeFlags & PABF_msNPAllowedPortTypes)
	{
		VariantClear(&var);
		V_VT(&var) =  VT_VARIANT | VT_ARRAY;
		V_ARRAY(&var) = (SAFEARRAY*)m_dwArrayAllowedPortTypes;

		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msNPAllowedPortTypes, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msNPAllowedPortTypes));


	//==================================
	// authentication

	/*
	// Authentication Dialog
		PROPERTY_PROFILE_msNPAuthenticationType
		PROPERTY_PROFILE_msNPAllowedEapType
	*/

	// authentication type -- must
	VariantClear(&var);
	if (m_dwAttributeFlags & PABF_msNPAuthenticationType)
	{
		VariantClear(&var);
		V_VT(&var) =  VT_VARIANT | VT_ARRAY;
		V_ARRAY(&var) = (SAFEARRAY*)m_dwArrayAuthenticationTypes;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msNPAuthenticationType, &var));
	}
	else
	{
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msNPAllowedEapType));
	}

	if(m_dwArrayAuthenticationTypes.Find(RAS_AT_EAP) != -1)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwEapType;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msNPAllowedEapType, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msNPAllowedEapType));

	//=====================================
	// encryptioin

	/*
	// Encryption Dialog
		PROPERTY_PROFILE_msRASAllowEncryption
		PROPERTY_PROFILE_msRASEncryptionType
	*/

	// encryption type -- must
	if (m_dwAttributeFlags & PABF_msRASEncryptionType)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwEncryptionType;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRASEncryptionType, &var));
	}
	else
	{
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRASEncryptionType));
	}

	if (m_dwAttributeFlags & PABF_msRASAllowEncryption)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwEncryptionPolicy;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRASAllowEncryption, &var));
	}
	else
	{
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRASAllowEncryption));
	}

	//=====================================
	// networking

	/*
	// Networking Dialog
		PROPERTY_PROFILE_msRADIUSFramedIPAddress
	*/

	// framedIPAddress -- ip address assignment poilcy, must
	if (m_dwAttributeFlags & PABF_msRADIUSFramedIPAddress)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwFramedIPAddress;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRADIUSFramedIPAddress, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRADIUSFramedIPAddress));
	
	// RAS filter
	if ((BSTR)m_cbstrFilters && m_nFiltersSize > 0)
	{
		VariantClear(&var);
#ifdef	FILTERS_AS_BSTR	
		V_VT(&var) = VT_BSTR;
		V_BSTR(&var) = (BSTR)m_cbstrFilters;
#else	// SAFEARRAY OF UI1
		{
			CBYTEArray	ba;

			ba.AssignBlob((PBYTE)(BSTR)m_cbstrFilters, m_nFiltersSize);
			V_VT(&var) = VT_ARRAY | VT_UI1;
			V_ARRAY(&var) = (SAFEARRAY*)ba;
		}
#endif
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRASFilter, &var));
		VariantInit(&var);	// the CBSTR will clean the memory
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRASFilter));
	

	//=====================================
	// multilink

	/*
	// Multilink Dialog
		PROPERTY_PROFILE_msRADIUSPortLimit
		PROPERTY_PROFILE_msRASBapLinednLimit
		PROPERTY_PROFILE_msRASBapLinednTime
		PROPERTY_PROFILE_msRASBapRequired
	*/


	//port limit
	if (m_dwAttributeFlags & PABF_msRADIUSPortLimit)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwPortLimit;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRADIUSPortLimit, &var));
	}
	else
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRADIUSPortLimit));


	// BAP
	if (m_dwAttributeFlags & PABF_msRASBapRequired)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwBapRequired;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRASBapRequired, &var));
	}
	else
	{
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRASBapRequired));
	}


	// line down limit
	if (m_dwAttributeFlags & PABF_msRASBapLinednLimit)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwBapLineDnLimit;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRASBapLinednLimit, &var));
	}
	else
	{
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRASBapLinednLimit));
	}

	// line down time
	if (m_dwAttributeFlags & PABF_msRASBapLinednTime)
	{
		VariantClear(&var);
		V_VT(&var) = VT_I4;
		V_I4(&var) = m_dwBapLineDnTime;
		CHECK_HR(hr = m_SdoWrapper.PutProperty(PROPERTY_PROFILE_msRASBapLinednTime, &var));
	}
	else
	{
		CHECK_HR(hr = m_SdoWrapper.RemoveProperty(PROPERTY_PROFILE_msRASBapLinednTime));
	}

	// specail code for error path
L_ERR:
	VariantClear(&var);
	TRACE(_T("Leave CRASProfileMerge::Save()\r\n"));

	return hr;
}