/**********************************************************************/ /** Microsoft Windows/NT **/ /** Copyright(c) Microsoft Corporation, 1997 - 1999 **/ /**********************************************************************/ /* rasdial.cpp Definition of CRASProfile class and CRASUser class FILE HISTORY: */ ////////////////////////////////////////////////////////////////////// #include "stdafx.h" #include #include #include #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 spIADs; CComPtr 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 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 spSdo; CComPtr spUnk; BSTR bstrMachineName = NULL; BSTR bstrUserPath = NULL; UINT nServiceType = 0; IASDATASTORE storeFlags; CComPtr 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; }