//----------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1997. // // File: P V C D A T A. C P P // // Contents: PVC parameters // // Notes: // // Author: tongl 20 Feb, 1998 // //----------------------------------------------------------------------- #include "pch.h" #pragma hdrstop #include "arpsobj.h" #include "auniobj.h" #include "atmutil.h" #include "ncstl.h" #include "pvcdata.h" #include "ncreg.h" extern const WCHAR c_szAdapters[]; void SetPvcDwordParam(HKEY hkeyAdapterPVCId, PCWSTR pszParamName, DWORD dwParam) { HRESULT hrTmp; if (FIELD_UNSET == dwParam) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, pszParamName); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, pszParamName, dwParam); } TraceTag(ttidAtmUni, "SetPvcDword Failed on %S", pszParamName); } void SetPvcBinaryParamFromString(HKEY hkeyAdapterPVCId, PCWSTR pszParamName, PCWSTR pszData) { HRESULT hrTmp; if (!(*pszData)) // empty string { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, pszParamName); } else { // convert to binary BYTE * pbData = NULL; DWORD cbData = 0; ConvertHexStringToBinaryWithAlloc(pszData, &pbData, &cbData); // save the value hrTmp = HrRegSetBinary(hkeyAdapterPVCId, pszParamName, pbData, cbData); delete pbData; } TraceTag(ttidAtmUni, "SetPvcBinaryParamFromString Failed on %S", pszParamName); } // Load PVC settings for the current adapter from registry to first memory HRESULT CAtmUniCfg::HrLoadPVCRegistry() { HRESULT hr = S_OK; HKEY hkeyUniParam; hr = m_pnccUni->OpenParamKey(&hkeyUniParam); if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) hr = S_OK; else if(SUCCEEDED(hr)) { Assert(hkeyUniParam); // find the adapter we want to load for (UNI_ADAPTER_LIST::iterator iterAdapter = m_listAdapters.begin(); iterAdapter != m_listAdapters.end(); iterAdapter ++) { if (FIsSubstr(m_strGuidConn.c_str(), (*iterAdapter)->m_strBindName.c_str())) { // found the adapter we want to load ... // open the adapters subkey HKEY hkeyAdapters = NULL; hr = HrRegOpenKeyEx(hkeyUniParam, c_szAdapters, KEY_READ, &hkeyAdapters); if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) hr = S_OK; else if(SUCCEEDED(hr)) { Assert(hkeyAdapters); HKEY hkeyAdapterParam = NULL; hr = HrRegOpenKeyEx(hkeyAdapters, (*iterAdapter)->m_strBindName.c_str(), KEY_READ, &hkeyAdapterParam); if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) hr = S_OK; else if(SUCCEEDED(hr)) { Assert(hkeyAdapterParam); HrLoadAdapterPVCRegistry(hkeyAdapterParam, *iterAdapter); } RegSafeCloseKey(hkeyAdapterParam); } RegSafeCloseKey(hkeyAdapters); break; } } } RegSafeCloseKey(hkeyUniParam); TraceError("CAtmUniCfg::HrLoadPVCRegistry", hr); return hr; } HRESULT CAtmUniCfg::HrLoadAdapterPVCRegistry(HKEY hkeyAdapterParam, CUniAdapterInfo * pAdapterInfo) { HRESULT hr = S_OK; Assert(hkeyAdapterParam); Assert(pAdapterInfo); // there should not have been any PVC on the list Assert(pAdapterInfo->m_listPVCs.size() ==0); // open the PVC subkey and enumerate the PVCs under that HKEY hkeyAdapterPVC = NULL; hr = HrRegOpenKeyEx(hkeyAdapterParam, c_szPVC, KEY_READ, &hkeyAdapterPVC); if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) hr = S_OK; else if(SUCCEEDED(hr)) { Assert(hkeyAdapterPVC); // enumerate the sub keys, and create a CPvcInfo object for each PVC VECSTR vstrPVCIdList; hr = HrLoadSubkeysFromRegistry(hkeyAdapterPVC, &vstrPVCIdList); // now load parameters for each PVC for (VECSTR::iterator iterPvcId = vstrPVCIdList.begin(); iterPvcId != vstrPVCIdList.end(); iterPvcId ++) { HKEY hkeyAdapterPVCId = NULL; hr = HrRegOpenKeyEx(hkeyAdapterPVC, (*iterPvcId)->c_str(), KEY_READ, &hkeyAdapterPVCId); if(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) hr = S_OK; else if(SUCCEEDED(hr)) { CPvcInfo * pNewPVC = new CPvcInfo((*iterPvcId)->c_str()); if (pNewPVC) { pAdapterInfo->m_listPVCs.push_back(pNewPVC); HRESULT hrTmp = S_OK; // Get the PVC Type DWORD dwType; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szPVCType, &dwType); if (hrTmp == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND)) { pNewPVC->m_dwPVCType = PVC_CUSTOM; hrTmp = S_OK; } else if SUCCEEDED(hrTmp) { Assert( (dwType == PVC_ATMARP) || (dwType == PVC_PPP_ATM_CLIENT) || (dwType == PVC_PPP_ATM_SERVER) || (dwType == PVC_CUSTOM)); switch(dwType) { case PVC_ATMARP: pNewPVC->m_dwPVCType = PVC_ATMARP; break; case PVC_PPP_ATM_CLIENT: pNewPVC->m_dwPVCType = PVC_PPP_ATM_CLIENT; break; case PVC_PPP_ATM_SERVER: pNewPVC->m_dwPVCType = PVC_PPP_ATM_SERVER; break; default: pNewPVC->m_dwPVCType = PVC_CUSTOM; break; } } else { TraceError("Failed reading PVCType", hrTmp); hrTmp = S_OK; pNewPVC->m_dwPVCType = PVC_CUSTOM; } // set the default values for the type pNewPVC->SetDefaults(pNewPVC->m_dwPVCType); // now read any existing value from the registry // pvc name tstring strName; hrTmp = HrRegQueryString(hkeyAdapterPVCId, c_szPVCName, &strName); if SUCCEEDED(hrTmp) pNewPVC->m_strName = strName; // VPI (required), if failed, default to 0 hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szVpi, &(pNewPVC->m_dwVpi)); // VCI (required), if failed, default to 0 hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szVci, &(pNewPVC->m_dwVci)); // AAL Type DWORD dwAALType; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szAALType, &dwAALType); if SUCCEEDED(hrTmp) { switch (dwAALType) { /* $REVIEW(tongl 2/23/98): Per ArvindM, only AAL5 is supported in NT5 case AAL_TYPE_AAL0: pNewPVC->m_dwAAL = AAL_TYPE_AAL0; break; case AAL_TYPE_AAL1: pNewPVC->m_dwAAL = AAL_TYPE_AAL1; break; case AAL_TYPE_AAL34: pNewPVC->m_dwAAL = AAL_TYPE_AAL34; break; */ case AAL_TYPE_AAL5: pNewPVC->m_dwAAL = AAL_TYPE_AAL5; break; default: AssertSz(FALSE, "Invalid AAL type."); pNewPVC->m_dwAAL = AAL_TYPE_AAL5; } } // Local address tstring strCallingAddr; hrTmp = HrRegQueryString(hkeyAdapterPVCId, c_szCallingParty, &strCallingAddr); if SUCCEEDED(hrTmp) pNewPVC->m_strCallingAddr = strCallingAddr; // Destination address tstring strCalledAddr; hrTmp = HrRegQueryString(hkeyAdapterPVCId, c_szCalledParty, &strCalledAddr); if SUCCEEDED(hrTmp) pNewPVC->m_strCalledAddr = strCalledAddr; // Flags DWORD dwFlags; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szFlags, &dwFlags); if SUCCEEDED(hrTmp) pNewPVC->m_dwFlags = dwFlags; // Quality Info // TransmitPeakCellRate DWORD dwTransmitPeakCellRate; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szTransmitPeakCellRate, &dwTransmitPeakCellRate); if SUCCEEDED(hrTmp) pNewPVC->m_dwTransmitPeakCellRate = dwTransmitPeakCellRate*c_iCellSize/c_iKbSize; // TransmitAvgCellRate DWORD dwTransmitAvgCellRate; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szTransmitAvgCellRate, &dwTransmitAvgCellRate); if SUCCEEDED(hrTmp) pNewPVC->m_dwTransmitAvgCellRate = dwTransmitAvgCellRate*c_iCellSize/c_iKbSize; // TransmitByteBurstLength DWORD dwTransmitByteBurstLength; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szTransmitByteBurstLength, &dwTransmitByteBurstLength); if SUCCEEDED(hrTmp) pNewPVC->m_dwTransmitByteBurstLength = dwTransmitByteBurstLength; // TransmitMaxSduSize DWORD dwTransmitMaxSduSize; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szTransmitMaxSduSize, &dwTransmitMaxSduSize); if SUCCEEDED(hrTmp) pNewPVC->m_dwTransmitMaxSduSize = dwTransmitMaxSduSize; // TransmitServiceCategory DWORD dwTransmitServiceCategory; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szTransmitServiceCategory, &dwTransmitServiceCategory); if SUCCEEDED(hrTmp) { switch(dwTransmitServiceCategory) { case ATM_SERVICE_CATEGORY_CBR: pNewPVC->m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_CBR; break; case ATM_SERVICE_CATEGORY_VBR: pNewPVC->m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_VBR; break; case ATM_SERVICE_CATEGORY_UBR: pNewPVC->m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_UBR; break; case ATM_SERVICE_CATEGORY_ABR: pNewPVC->m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_ABR; break; default: AssertSz(FALSE, "Invalid service category."); pNewPVC->m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_UBR; } } // ReceivePeakCellRate DWORD dwReceivePeakCellRate; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szReceivePeakCellRate, &dwReceivePeakCellRate); if SUCCEEDED(hrTmp) pNewPVC->m_dwReceivePeakCellRate = dwReceivePeakCellRate*c_iCellSize/c_iKbSize; // ReceiveAvgCellRate DWORD dwReceiveAvgCellRate; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szReceiveAvgCellRate, &dwReceiveAvgCellRate); if SUCCEEDED(hrTmp) pNewPVC->m_dwReceiveAvgCellRate = dwReceiveAvgCellRate*c_iCellSize/c_iKbSize; // ReceiveByteBurstLength DWORD dwReceiveByteBurstLength; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szReceiveByteBurstLength, &dwReceiveByteBurstLength); if SUCCEEDED(hrTmp) pNewPVC->m_dwReceiveByteBurstLength = dwReceiveByteBurstLength; // ReceiveMaxSduSize DWORD dwReceiveMaxSduSize; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szReceiveMaxSduSize, &dwReceiveMaxSduSize); if SUCCEEDED(hrTmp) pNewPVC->m_dwReceiveMaxSduSize = dwReceiveMaxSduSize; // ReceiveServiceCategory DWORD dwReceiveServiceCategory; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szReceiveServiceCategory, &dwReceiveServiceCategory); if SUCCEEDED(hrTmp) { switch(dwReceiveServiceCategory) { case ATM_SERVICE_CATEGORY_CBR: pNewPVC->m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_CBR; break; case ATM_SERVICE_CATEGORY_VBR: pNewPVC->m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_VBR; break; case ATM_SERVICE_CATEGORY_UBR: pNewPVC->m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_UBR; break; case ATM_SERVICE_CATEGORY_ABR: pNewPVC->m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_ABR; break; default: AssertSz(FALSE, "Invalid service category."); pNewPVC->m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_UBR; } } // Local BLLI & BHLI DWORD dwLocalLayer2Protocol; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szLocalLayer2Protocol, &dwLocalLayer2Protocol); if SUCCEEDED(hrTmp) pNewPVC->m_dwLocalLayer2Protocol = dwLocalLayer2Protocol; DWORD dwLocalUserSpecLayer2; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szLocalUserSpecLayer2, &dwLocalUserSpecLayer2); if SUCCEEDED(hrTmp) pNewPVC->m_dwLocalUserSpecLayer2 = dwLocalUserSpecLayer2; DWORD dwLocalLayer3Protocol; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szLocalLayer3Protocol, &dwLocalLayer3Protocol); if SUCCEEDED(hrTmp) pNewPVC->m_dwLocalLayer3Protocol = dwLocalLayer3Protocol; DWORD dwLocalUserSpecLayer3; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szLocalUserSpecLayer3, &dwLocalUserSpecLayer3); if SUCCEEDED(hrTmp) pNewPVC->m_dwLocalUserSpecLayer3 = dwLocalUserSpecLayer3; DWORD dwLocalLayer3IPI; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szLocalLayer3IPI, &dwLocalLayer3IPI); if SUCCEEDED(hrTmp) pNewPVC->m_dwLocalLayer3IPI = dwLocalLayer3IPI; BYTE * pbLocalSnapId = NULL; DWORD cbLocalSnapId = 0; hrTmp = HrRegQueryBinaryWithAlloc(hkeyAdapterPVCId, c_szLocalSnapId, &pbLocalSnapId, &cbLocalSnapId); if ( SUCCEEDED(hrTmp) && (cbLocalSnapId >0) && (cbLocalSnapId <= c_nSnapIdMaxBytes)) { ConvertBinaryToHexString(pbLocalSnapId, cbLocalSnapId, &(pNewPVC->m_strLocalSnapId)); MemFree(pbLocalSnapId); } DWORD dwLocalHighLayerInfoType; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szLocalHighLayerInfoType, &dwLocalHighLayerInfoType); if SUCCEEDED(hrTmp) pNewPVC->m_dwLocalHighLayerInfoType = dwLocalHighLayerInfoType; BYTE * pbLocalHighLayerInfo = NULL; DWORD cbLocalHighLayerInfo = 0; hrTmp = HrRegQueryBinaryWithAlloc(hkeyAdapterPVCId, c_szLocalHighLayerInfo, &pbLocalHighLayerInfo, &cbLocalHighLayerInfo); if ( SUCCEEDED(hrTmp) && (cbLocalHighLayerInfo >0) && (cbLocalHighLayerInfo <= c_nHighLayerInfoMaxBytes)) { ConvertBinaryToHexString(pbLocalHighLayerInfo, cbLocalHighLayerInfo, &(pNewPVC->m_strLocalHighLayerInfo)); MemFree(pbLocalHighLayerInfo); } // Destination BLLI and BHLI DWORD dwDestnLayer2Protocol; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szDestnLayer2Protocol, &dwDestnLayer2Protocol); if SUCCEEDED(hrTmp) pNewPVC->m_dwDestnLayer2Protocol = dwDestnLayer2Protocol; DWORD dwDestnUserSpecLayer2; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szDestnUserSpecLayer2, &dwDestnUserSpecLayer2); if SUCCEEDED(hrTmp) pNewPVC->m_dwDestnUserSpecLayer2 = dwDestnUserSpecLayer2; DWORD dwDestnLayer3Protocol; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szDestnLayer3Protocol, &dwDestnLayer3Protocol); if SUCCEEDED(hrTmp) pNewPVC->m_dwDestnLayer3Protocol = dwDestnLayer3Protocol; DWORD dwDestnUserSpecLayer3; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szDestnUserSpecLayer3, &dwDestnUserSpecLayer3); if SUCCEEDED(hrTmp) pNewPVC->m_dwDestnUserSpecLayer3 = dwDestnUserSpecLayer3; DWORD dwDestnLayer3IPI; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szDestnLayer3IPI, &dwDestnLayer3IPI); if SUCCEEDED(hrTmp) pNewPVC->m_dwDestnLayer3IPI = dwDestnLayer3IPI; BYTE * pbDestnSnapId = NULL; DWORD cbDestnSnapId = 0; hrTmp = HrRegQueryBinaryWithAlloc(hkeyAdapterPVCId, c_szDestnSnapId, &pbDestnSnapId, &cbDestnSnapId); if ( SUCCEEDED(hrTmp) && (cbDestnSnapId >0) && (cbDestnSnapId <= c_nSnapIdMaxBytes)) { ConvertBinaryToHexString(pbDestnSnapId, cbDestnSnapId, &(pNewPVC->m_strDestnSnapId)); MemFree(pbDestnSnapId); } DWORD dwDestnHighLayerInfoType; hrTmp = HrRegQueryDword(hkeyAdapterPVCId, c_szDestnHighLayerInfoType, &dwDestnHighLayerInfoType); if SUCCEEDED(hrTmp) pNewPVC->m_dwDestnHighLayerInfoType = dwDestnHighLayerInfoType; BYTE * pbDestnHighLayerInfo = NULL; DWORD cbDestnHighLayerInfo = 0; hrTmp = HrRegQueryBinaryWithAlloc(hkeyAdapterPVCId, c_szDestnHighLayerInfo, &pbDestnHighLayerInfo, &cbDestnHighLayerInfo); if ( SUCCEEDED(hrTmp) && (cbDestnHighLayerInfo >0) && (cbDestnHighLayerInfo <= c_nHighLayerInfoMaxBytes)) { ConvertBinaryToHexString(pbDestnHighLayerInfo, cbDestnHighLayerInfo, &(pNewPVC->m_strDestnHighLayerInfo)); MemFree(pbDestnHighLayerInfo); } // Now initialize the "Old" values pNewPVC->ResetOldValues(); } } RegSafeCloseKey(hkeyAdapterPVCId); } } RegSafeCloseKey(hkeyAdapterPVC); TraceError("CAtmUniCfg::HrLoadAdapterPVCRegistry", hr); return hr; } // Save PVC specific settings to registry HRESULT CAtmUniCfg::HrSaveAdapterPVCRegistry(HKEY hkeyAdapterParam, CUniAdapterInfo * pAdapterInfo) { HRESULT hr = S_OK; Assert(hkeyAdapterParam); Assert(pAdapterInfo); // open the PVC subkey and enumerate the PVCs under that HKEY hkeyAdapterPVC = NULL; DWORD dwDisposition; hr = HrRegCreateKeyEx(hkeyAdapterParam, c_szPVC, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyAdapterPVC, &dwDisposition); if(SUCCEEDED(hr)) { Assert(hkeyAdapterPVC); if (dwDisposition == REG_OPENED_EXISTING_KEY) { // clean up deleted PVCs HRESULT hrTmp = S_OK; // enumerate the sub keys, and create a CPvcInfo object for each PVC VECSTR vstrPVCIdList; hrTmp = HrLoadSubkeysFromRegistry(hkeyAdapterPVC, &vstrPVCIdList); if SUCCEEDED(hrTmp) { for (VECSTR::iterator iterPvcId = vstrPVCIdList.begin(); iterPvcId != vstrPVCIdList.end(); iterPvcId ++) { BOOL fFound = FALSE; for (PVC_INFO_LIST::iterator iterPvcInfo = pAdapterInfo->m_listPVCs.begin(); iterPvcInfo != pAdapterInfo->m_listPVCs.end(); iterPvcInfo ++) { if ((*iterPvcInfo)->m_fDeleted) continue; if (**iterPvcId == (*iterPvcInfo)->m_strPvcId) { fFound = TRUE; break; } } if (!fFound) { hrTmp = HrRegDeleteKeyTree(hkeyAdapterPVC, (*iterPvcId)->c_str()); } } } } // save new or updated pvcs for (PVC_INFO_LIST::iterator iterPvcInfo = pAdapterInfo->m_listPVCs.begin(); iterPvcInfo != pAdapterInfo->m_listPVCs.end(); iterPvcInfo ++) { if ((*iterPvcInfo)->m_fDeleted) continue; HRESULT hrTmp = S_OK; // Create the subkey HKEY hkeyAdapterPVCId = NULL; hrTmp = HrRegCreateKeyEx(hkeyAdapterPVC, (*iterPvcInfo)->m_strPvcId.c_str(), REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hkeyAdapterPVCId, &dwDisposition); if(SUCCEEDED(hrTmp)) { Assert(hkeyAdapterPVCId); // PVC type hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szPVCType, (*iterPvcInfo)->m_dwPVCType); if SUCCEEDED(hr) hr = hrTmp; // pvc name hrTmp = HrRegSetString(hkeyAdapterPVCId, c_szPVCName, (*iterPvcInfo)->m_strName); if SUCCEEDED(hr) hr = hrTmp; // VPI hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szVpi, (*iterPvcInfo)->m_dwVpi); if SUCCEEDED(hr) hr = hrTmp; // VCI hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szVci, (*iterPvcInfo)->m_dwVci); if SUCCEEDED(hr) hr = hrTmp; // AAL Type hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szAALType, (*iterPvcInfo)->m_dwAAL); if SUCCEEDED(hr) hr = hrTmp; // Local address hrTmp = HrRegSetString(hkeyAdapterPVCId, c_szCallingParty, (*iterPvcInfo)->m_strCallingAddr); if SUCCEEDED(hr) hr = hrTmp; // Destination address hrTmp = HrRegSetString(hkeyAdapterPVCId, c_szCalledParty, (*iterPvcInfo)->m_strCalledAddr); if SUCCEEDED(hr) hr = hrTmp; // Flags if (FIELD_UNSET == (*iterPvcInfo)->m_dwFlags) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szFlags); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szFlags, (*iterPvcInfo)->m_dwFlags); } if SUCCEEDED(hrTmp) hr = hrTmp; // Quality Info // TransmitPeakCellRate if (FIELD_UNSET == (*iterPvcInfo)->m_dwTransmitPeakCellRate) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szTransmitPeakCellRate); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szTransmitPeakCellRate, (*iterPvcInfo)->m_dwTransmitPeakCellRate*c_iKbSize/c_iCellSize); } if SUCCEEDED(hrTmp) hr = hrTmp; // TransmitAvgCellRate if (FIELD_UNSET == (*iterPvcInfo)->m_dwTransmitAvgCellRate) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szTransmitAvgCellRate); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szTransmitAvgCellRate, (*iterPvcInfo)->m_dwTransmitAvgCellRate*c_iKbSize/c_iCellSize); } if SUCCEEDED(hrTmp) hr = hrTmp; // TransmitByteBurstLength if (FIELD_UNSET == (*iterPvcInfo)->m_dwTransmitByteBurstLength) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szTransmitByteBurstLength); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szTransmitByteBurstLength, (*iterPvcInfo)->m_dwTransmitByteBurstLength); } if SUCCEEDED(hrTmp) hr = hrTmp; // TransmitMaxSduSize if (FIELD_UNSET == (*iterPvcInfo)->m_dwTransmitMaxSduSize) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szTransmitMaxSduSize); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szTransmitMaxSduSize, (*iterPvcInfo)->m_dwTransmitMaxSduSize); } if SUCCEEDED(hrTmp) hr = hrTmp; // TransmitServiceCategory hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szTransmitServiceCategory, (*iterPvcInfo)->m_dwTransmitServiceCategory); if SUCCEEDED(hrTmp) hr = hrTmp; // ReceivePeakCellRate if (FIELD_UNSET == (*iterPvcInfo)->m_dwReceivePeakCellRate) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szReceivePeakCellRate); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szReceivePeakCellRate, (*iterPvcInfo)->m_dwReceivePeakCellRate*c_iKbSize/c_iCellSize); } if SUCCEEDED(hrTmp) hr = hrTmp; // ReceiveAvgCellRate if (FIELD_UNSET == (*iterPvcInfo)->m_dwReceiveAvgCellRate) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szReceiveAvgCellRate); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szReceiveAvgCellRate, (*iterPvcInfo)->m_dwReceiveAvgCellRate*c_iKbSize/c_iCellSize); } if SUCCEEDED(hrTmp) hr = hrTmp; // ReceiveByteBurstLength if (FIELD_UNSET == (*iterPvcInfo)->m_dwReceiveByteBurstLength) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szReceiveByteBurstLength); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szReceiveByteBurstLength, (*iterPvcInfo)->m_dwReceiveByteBurstLength); } if SUCCEEDED(hrTmp) hr = hrTmp; // ReceiveMaxSduSize if (FIELD_UNSET == (*iterPvcInfo)->m_dwReceiveMaxSduSize) { // delete the value hrTmp = HrRegDeleteValue(hkeyAdapterPVCId, c_szReceiveMaxSduSize); } else { // save the value hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szReceiveMaxSduSize, (*iterPvcInfo)->m_dwReceiveMaxSduSize); } if SUCCEEDED(hrTmp) hr = hrTmp; // ReceiveServiceCategory hrTmp = HrRegSetDword(hkeyAdapterPVCId, c_szReceiveServiceCategory, (*iterPvcInfo)->m_dwReceiveServiceCategory); if SUCCEEDED(hrTmp) hr = hrTmp; // Local BLLI & BHLI SetPvcDwordParam(hkeyAdapterPVCId, c_szLocalLayer2Protocol, (*iterPvcInfo)->m_dwLocalLayer2Protocol); SetPvcDwordParam(hkeyAdapterPVCId, c_szLocalUserSpecLayer2, (*iterPvcInfo)->m_dwLocalUserSpecLayer2); SetPvcDwordParam(hkeyAdapterPVCId, c_szLocalLayer3Protocol, (*iterPvcInfo)->m_dwLocalLayer3Protocol); SetPvcDwordParam(hkeyAdapterPVCId, c_szLocalUserSpecLayer3, (*iterPvcInfo)->m_dwLocalUserSpecLayer3); SetPvcDwordParam(hkeyAdapterPVCId, c_szLocalLayer3IPI, (*iterPvcInfo)->m_dwLocalLayer3IPI); SetPvcBinaryParamFromString(hkeyAdapterPVCId, c_szLocalSnapId, (*iterPvcInfo)->m_strLocalSnapId.c_str()); SetPvcDwordParam(hkeyAdapterPVCId, c_szLocalHighLayerInfoType, (*iterPvcInfo)->m_dwLocalHighLayerInfoType); SetPvcBinaryParamFromString(hkeyAdapterPVCId, c_szLocalHighLayerInfo, (*iterPvcInfo)->m_strLocalHighLayerInfo.c_str()); // Destination BLLI and BHLI info SetPvcDwordParam(hkeyAdapterPVCId, c_szDestnLayer2Protocol, (*iterPvcInfo)->m_dwDestnLayer2Protocol); SetPvcDwordParam(hkeyAdapterPVCId, c_szDestnUserSpecLayer2, (*iterPvcInfo)->m_dwDestnUserSpecLayer2); SetPvcDwordParam(hkeyAdapterPVCId, c_szDestnLayer3Protocol, (*iterPvcInfo)->m_dwDestnLayer3Protocol); SetPvcDwordParam(hkeyAdapterPVCId, c_szDestnUserSpecLayer3, (*iterPvcInfo)->m_dwDestnUserSpecLayer3); SetPvcDwordParam(hkeyAdapterPVCId, c_szDestnLayer3IPI, (*iterPvcInfo)->m_dwDestnLayer3IPI); SetPvcBinaryParamFromString(hkeyAdapterPVCId, c_szDestnSnapId, (*iterPvcInfo)->m_strDestnSnapId.c_str()); SetPvcDwordParam(hkeyAdapterPVCId, c_szDestnHighLayerInfoType, (*iterPvcInfo)->m_dwDestnHighLayerInfoType); SetPvcBinaryParamFromString(hkeyAdapterPVCId, c_szDestnHighLayerInfo, (*iterPvcInfo)->m_strDestnHighLayerInfo.c_str()); } RegSafeCloseKey(hkeyAdapterPVCId); } } RegSafeCloseKey(hkeyAdapterPVC); TraceError("CAtmUniCfg::HrSaveAdapterPVCRegistry", hr); return hr; } // load adapter PVC parameters from first memory to second memory HRESULT CAtmUniCfg::HrLoadAdapterPVCInfo() { HRESULT hr = HRESULT_FROM_WIN32(ERROR_NO_MATCH); delete m_pSecondMemoryAdapterInfo; m_pSecondMemoryAdapterInfo = NULL; for(UNI_ADAPTER_LIST::iterator iterAdapter = m_listAdapters.begin(); iterAdapter != m_listAdapters.end(); iterAdapter++) { if (FIsSubstr(m_strGuidConn.c_str(), (*iterAdapter)->m_strBindName.c_str())) { // enabled LAN adapter if ((*iterAdapter)->m_BindingState == BIND_ENABLE) { m_pSecondMemoryAdapterInfo = new CUniAdapterInfo; if (m_pSecondMemoryAdapterInfo == NULL) { continue; } *m_pSecondMemoryAdapterInfo = **iterAdapter; hr = S_OK; } } } AssertSz((S_OK == hr), "Can not raise UI on a disabled or non-exist adapter !"); TraceError("CAtmUniCfg::HrLoadAdapterInfo", hr); return hr; } // save adapter PVC parameters from second memory to first memory HRESULT CAtmUniCfg::HrSaveAdapterPVCInfo() { HRESULT hr = HRESULT_FROM_WIN32(ERROR_NO_MATCH); for(UNI_ADAPTER_LIST::iterator iterAdapter = m_listAdapters.begin(); iterAdapter != m_listAdapters.end(); iterAdapter++) { if(m_pSecondMemoryAdapterInfo->m_strBindName == (*iterAdapter)->m_strBindName) { // The card can not get unbound while in the properties UI ! Assert((*iterAdapter)->m_BindingState == BIND_ENABLE); Assert(m_pSecondMemoryAdapterInfo->m_BindingState == BIND_ENABLE); **iterAdapter = *m_pSecondMemoryAdapterInfo; hr = S_OK; break; } } AssertSz((S_OK == hr), "Adapter in second memory not found in first memory!"); TraceError("CAtmUniCfg::HrSaveAdapterInfo", hr); return hr; } // CPvcInfo CPvcInfo::CPvcInfo(PCWSTR pszPvcId) { m_strPvcId = pszPvcId; m_fDeleted = FALSE; } CPvcInfo::~CPvcInfo() { } // copy operator CPvcInfo & CPvcInfo::operator=(const CPvcInfo & info) { Assert(this != &info); Assert(m_strPvcId == info.m_strPvcId); if (this == &info) return *this; m_fDeleted = info.m_fDeleted; m_dwPVCType = info.m_dwPVCType; m_dwOldPVCType = info.m_dwOldPVCType; m_strName = info.m_strName; m_strOldName = info.m_strOldName; m_dwVpi = info.m_dwVpi; m_dwOldVpi = info.m_dwOldVpi; m_dwVci = info.m_dwVci; m_dwOldVci = info.m_dwOldVci; m_dwAAL = info.m_dwAAL; m_dwOldAAL = info.m_dwOldAAL; m_strCallingAddr = info.m_strCallingAddr; m_strOldCallingAddr = info.m_strOldCallingAddr; m_strCalledAddr = info.m_strCalledAddr; m_strOldCalledAddr = info.m_strOldCalledAddr; m_dwFlags = info.m_dwFlags; m_dwTransmitPeakCellRate = info.m_dwTransmitPeakCellRate; m_dwOldTransmitPeakCellRate = info.m_dwOldTransmitPeakCellRate; m_dwTransmitAvgCellRate = info.m_dwTransmitAvgCellRate; m_dwOldTransmitAvgCellRate = info.m_dwOldTransmitAvgCellRate; m_dwTransmitByteBurstLength = info.m_dwTransmitByteBurstLength; m_dwOldTransmitByteBurstLength = info.m_dwOldTransmitByteBurstLength; m_dwTransmitMaxSduSize = info.m_dwTransmitMaxSduSize; m_dwOldTransmitMaxSduSize = info.m_dwOldTransmitMaxSduSize; m_dwTransmitServiceCategory = info.m_dwTransmitServiceCategory; m_dwOldTransmitServiceCategory = info.m_dwOldTransmitServiceCategory; m_dwReceivePeakCellRate = info.m_dwReceivePeakCellRate; m_dwOldReceivePeakCellRate = info.m_dwOldReceivePeakCellRate; m_dwReceiveAvgCellRate = info.m_dwReceiveAvgCellRate; m_dwOldReceiveAvgCellRate = info.m_dwOldReceiveAvgCellRate; m_dwReceiveByteBurstLength = info.m_dwReceiveByteBurstLength; m_dwOldReceiveByteBurstLength = info.m_dwOldReceiveByteBurstLength; m_dwReceiveMaxSduSize = info.m_dwReceiveMaxSduSize; m_dwOldReceiveMaxSduSize = info.m_dwOldReceiveMaxSduSize; m_dwReceiveServiceCategory = info.m_dwReceiveServiceCategory; m_dwOldReceiveServiceCategory = info.m_dwOldReceiveServiceCategory; // BLLI & BHLI m_dwLocalLayer2Protocol = info.m_dwLocalLayer2Protocol; m_dwOldLocalLayer2Protocol = info.m_dwOldLocalLayer2Protocol; m_dwLocalUserSpecLayer2 = info.m_dwLocalUserSpecLayer2; m_dwOldLocalUserSpecLayer2 = info.m_dwOldLocalUserSpecLayer2; m_dwLocalLayer3Protocol = info.m_dwLocalLayer3Protocol; m_dwOldLocalLayer3Protocol = info.m_dwOldLocalLayer3Protocol; m_dwLocalUserSpecLayer3 = info.m_dwLocalUserSpecLayer3; m_dwOldLocalUserSpecLayer3 = info.m_dwOldLocalUserSpecLayer3; m_dwLocalLayer3IPI = info.m_dwLocalLayer3IPI; m_dwOldLocalLayer3IPI = info.m_dwOldLocalLayer3IPI; m_strLocalSnapId = info.m_strLocalSnapId; m_strOldLocalSnapId = info.m_strOldLocalSnapId; m_dwLocalHighLayerInfoType = info.m_dwLocalHighLayerInfoType; m_dwOldLocalHighLayerInfoType = info.m_dwOldLocalHighLayerInfoType; m_strLocalHighLayerInfo = info.m_strLocalHighLayerInfo; m_strOldLocalHighLayerInfo = info.m_strOldLocalHighLayerInfo; // Destination BLLI and BHLI info m_dwDestnLayer2Protocol = info.m_dwDestnLayer2Protocol; m_dwOldDestnLayer2Protocol = info.m_dwOldDestnLayer2Protocol; m_dwDestnUserSpecLayer2 = info.m_dwDestnUserSpecLayer2; m_dwOldDestnUserSpecLayer2 = info.m_dwOldDestnUserSpecLayer2; m_dwDestnLayer3Protocol = info.m_dwDestnLayer3Protocol; m_dwOldDestnLayer3Protocol = info.m_dwOldDestnLayer3Protocol; m_dwDestnUserSpecLayer3 = info.m_dwDestnUserSpecLayer3; m_dwOldDestnUserSpecLayer3 = info.m_dwOldDestnUserSpecLayer3; m_dwDestnLayer3IPI = info.m_dwDestnLayer3IPI; m_dwOldDestnLayer3IPI = info.m_dwOldDestnLayer3IPI; m_strDestnSnapId = info.m_strDestnSnapId; m_strOldDestnSnapId = info.m_strOldDestnSnapId; m_dwDestnHighLayerInfoType = info.m_dwDestnHighLayerInfoType; m_dwOldDestnHighLayerInfoType = info.m_dwOldDestnHighLayerInfoType; m_strDestnHighLayerInfo = info.m_strDestnHighLayerInfo; m_strOldDestnHighLayerInfo = info.m_strOldDestnHighLayerInfo; return *this; } void CPvcInfo::SetDefaults(PVCType type) { m_dwPVCType = type; m_fDeleted = FALSE; m_strName = (PWSTR) SzLoadIds(IDS_PVC_UNSPECIFIED_NAME); m_dwAAL = AAL_TYPE_AAL5; m_dwVpi = 0; m_dwVci = FIELD_UNSET; SetTypeDefaults(type); ResetOldValues(); } void CPvcInfo::SetTypeDefaults(PVCType type) { // set more specific defaults for each type m_dwPVCType = type; switch (m_dwPVCType) { case PVC_ATMARP: SetDefaultsForAtmArp(); break; case PVC_PPP_ATM_CLIENT: SetDefaultsForPPPOut(); break; case PVC_PPP_ATM_SERVER: SetDefaultsForPPPIn(); break; case PVC_CUSTOM: SetDefaultsForCustom(); break; } } void CPvcInfo::SetDefaultsForAtmArp() { m_dwPVCType = PVC_ATMARP; // addresses m_strCallingAddr = c_szDefaultCallingAtmAddr; m_strCalledAddr = c_szEmpty; // Flags m_dwFlags = 2; // Quality Info m_dwTransmitPeakCellRate = FIELD_UNSET; m_dwTransmitAvgCellRate = FIELD_UNSET; m_dwTransmitByteBurstLength = c_dwDefTransmitByteBurstLength; m_dwTransmitMaxSduSize = c_dwDefTransmitMaxSduSize; m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_UBR; m_dwReceivePeakCellRate = FIELD_UNSET; m_dwReceiveAvgCellRate = FIELD_UNSET; m_dwReceiveByteBurstLength = c_dwDefTransmitByteBurstLength; m_dwReceiveMaxSduSize = c_dwDefTransmitMaxSduSize; m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_UBR; // Local BLLI & BHLI m_dwLocalLayer2Protocol = 12; m_dwLocalUserSpecLayer2 = 0; m_dwLocalLayer3Protocol = FIELD_ABSENT; m_dwLocalUserSpecLayer3 = 0; m_dwLocalLayer3IPI = 0; m_strLocalSnapId = c_szEmpty; m_dwLocalHighLayerInfoType = FIELD_ABSENT; m_strLocalHighLayerInfo = c_szEmpty; // Destination BLLI and BHLI info m_dwDestnLayer2Protocol = 12; m_dwDestnUserSpecLayer2 = 0; m_dwDestnLayer3Protocol = FIELD_ABSENT; m_dwDestnUserSpecLayer3 = 0; m_dwDestnLayer3IPI = 0; m_strDestnSnapId = c_szEmpty; m_dwDestnHighLayerInfoType = FIELD_ABSENT; m_strDestnHighLayerInfo = c_szEmpty; } void CPvcInfo::SetDefaultsForPPPOut() { m_dwPVCType = PVC_PPP_ATM_CLIENT; // addresses m_strCallingAddr = c_szEmpty; m_strCalledAddr = c_szDefaultCalledAtmAddr; // Flags m_dwFlags = 4; // Quality Info m_dwTransmitPeakCellRate = FIELD_UNSET; m_dwTransmitAvgCellRate = FIELD_UNSET; m_dwTransmitByteBurstLength = FIELD_UNSET; m_dwTransmitMaxSduSize = 4096; m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_UBR; m_dwReceivePeakCellRate = FIELD_UNSET; m_dwReceiveAvgCellRate = FIELD_UNSET; m_dwReceiveByteBurstLength = FIELD_UNSET; m_dwReceiveMaxSduSize = 4096; m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_UBR; // Local BLLI & BHLI m_dwLocalLayer2Protocol = FIELD_ABSENT; m_dwLocalUserSpecLayer2 = 0; m_dwLocalLayer3Protocol = FIELD_ABSENT; m_dwLocalUserSpecLayer3 = 0; m_dwLocalLayer3IPI = 0; m_strLocalSnapId = c_szEmpty; m_dwLocalHighLayerInfoType = FIELD_ABSENT; m_strLocalHighLayerInfo = c_szEmpty; // Destination BLLI and BHLI info m_dwDestnLayer2Protocol = FIELD_ABSENT; m_dwDestnUserSpecLayer2 = 0; m_dwDestnLayer3Protocol = 11; m_dwDestnUserSpecLayer3 = 0; m_dwDestnLayer3IPI = 207; m_strDestnHighLayerInfo = c_szEmpty; m_dwDestnHighLayerInfoType = FIELD_ABSENT; m_strDestnHighLayerInfo = c_szEmpty; } void CPvcInfo::SetDefaultsForPPPIn() { m_dwPVCType = PVC_PPP_ATM_SERVER; // addresses m_strCallingAddr = c_szEmpty; m_strCalledAddr = c_szEmpty; // Flags m_dwFlags = 2; // Quality Info m_dwTransmitPeakCellRate = FIELD_UNSET; m_dwTransmitAvgCellRate = FIELD_UNSET; m_dwTransmitByteBurstLength = FIELD_UNSET; m_dwTransmitMaxSduSize = 4096; m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_UBR; m_dwReceivePeakCellRate = FIELD_UNSET; m_dwReceiveAvgCellRate = FIELD_UNSET; m_dwReceiveByteBurstLength = FIELD_UNSET; m_dwReceiveMaxSduSize = 4096; m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_UBR; // Local BLLI & BHLI m_dwLocalLayer2Protocol = FIELD_ABSENT; m_dwLocalUserSpecLayer2 = 0; m_dwLocalLayer3Protocol = 11; m_dwLocalUserSpecLayer3 = 0; m_dwLocalLayer3IPI = 207; m_strLocalSnapId = c_szEmpty; m_dwLocalHighLayerInfoType = FIELD_ABSENT; m_strLocalHighLayerInfo = c_szEmpty; // Destination BLLI and BHLI info m_dwDestnLayer2Protocol = FIELD_ABSENT; m_dwDestnUserSpecLayer2 = 0; m_dwDestnLayer3Protocol = FIELD_ABSENT; m_dwDestnUserSpecLayer3 = 0; m_dwDestnLayer3IPI = 0; m_strDestnSnapId = c_szEmpty; m_dwDestnHighLayerInfoType = FIELD_ABSENT; m_strDestnHighLayerInfo = c_szEmpty; } void CPvcInfo::SetDefaultsForCustom() { m_dwPVCType = PVC_CUSTOM; // addresses m_strCallingAddr = c_szEmpty; m_strCalledAddr = c_szEmpty; // Flags m_dwFlags = FIELD_UNSET; // Quality Info m_dwTransmitPeakCellRate = FIELD_UNSET; m_dwTransmitAvgCellRate = FIELD_UNSET; m_dwTransmitByteBurstLength = FIELD_UNSET; m_dwTransmitMaxSduSize = FIELD_UNSET; m_dwTransmitServiceCategory = ATM_SERVICE_CATEGORY_UBR; m_dwReceivePeakCellRate = FIELD_UNSET; m_dwReceiveAvgCellRate = FIELD_UNSET; m_dwReceiveByteBurstLength = FIELD_UNSET; m_dwReceiveMaxSduSize = FIELD_UNSET; m_dwReceiveServiceCategory = ATM_SERVICE_CATEGORY_UBR; // Local BLLI & BHLI m_dwLocalLayer2Protocol = FIELD_ANY; m_dwLocalUserSpecLayer2 = 0; m_dwLocalLayer3Protocol = FIELD_ANY; m_dwLocalUserSpecLayer3 = 0; m_dwLocalLayer3IPI = 0; m_strLocalSnapId = c_szEmpty; m_dwLocalHighLayerInfoType = FIELD_ANY; m_strLocalHighLayerInfo = c_szEmpty; // Destination BLLI and BHLI info m_dwDestnLayer2Protocol = FIELD_ANY; m_dwDestnUserSpecLayer2 = 0; m_dwDestnLayer3Protocol = FIELD_ANY; m_dwDestnUserSpecLayer3 = 0; m_dwDestnLayer3IPI = 0; m_strDestnSnapId = c_szEmpty; m_dwDestnHighLayerInfoType = FIELD_ANY; m_strDestnHighLayerInfo = c_szEmpty; } void CPvcInfo::ResetOldValues() { m_dwOldPVCType = m_dwPVCType; m_strOldName = m_strName; m_dwOldVpi = m_dwVpi; m_dwOldVci = m_dwVci; m_dwOldAAL = m_dwAAL; m_strOldCallingAddr = m_strCallingAddr; m_strOldCalledAddr = m_strCalledAddr; // Quality Info m_dwOldTransmitPeakCellRate = m_dwTransmitPeakCellRate; m_dwOldTransmitAvgCellRate = m_dwTransmitAvgCellRate; m_dwOldTransmitByteBurstLength = m_dwTransmitByteBurstLength; m_dwOldTransmitMaxSduSize = m_dwTransmitMaxSduSize; m_dwOldTransmitServiceCategory = m_dwTransmitServiceCategory; m_dwOldReceivePeakCellRate = m_dwReceivePeakCellRate; m_dwOldReceiveAvgCellRate = m_dwReceiveAvgCellRate; m_dwOldReceiveByteBurstLength = m_dwReceiveByteBurstLength; m_dwOldReceiveMaxSduSize = m_dwReceiveMaxSduSize; m_dwOldReceiveServiceCategory = m_dwReceiveServiceCategory; // Local BLLI & BHLI m_dwOldLocalLayer2Protocol = m_dwLocalLayer2Protocol; m_dwOldLocalUserSpecLayer2 = m_dwLocalUserSpecLayer2; m_dwOldLocalLayer3Protocol = m_dwLocalLayer3Protocol; m_dwOldLocalUserSpecLayer3 = m_dwLocalUserSpecLayer3; m_dwOldLocalLayer3IPI = m_dwLocalLayer3IPI; m_strOldLocalSnapId = m_strLocalSnapId; m_dwOldLocalHighLayerInfoType = m_dwLocalHighLayerInfoType; m_strOldLocalHighLayerInfo = m_strLocalHighLayerInfo; // Destination BLLI and BHLI info m_dwOldDestnLayer2Protocol = m_dwDestnLayer2Protocol; m_dwOldDestnUserSpecLayer2 = m_dwDestnUserSpecLayer2; m_dwOldDestnLayer3Protocol = m_dwDestnLayer3Protocol; m_dwOldDestnUserSpecLayer3 = m_dwDestnUserSpecLayer3; m_dwOldDestnLayer3IPI = m_dwDestnLayer3IPI; m_strOldDestnSnapId = m_strDestnSnapId; m_dwOldDestnHighLayerInfoType = m_dwDestnHighLayerInfoType; m_strOldDestnHighLayerInfo = m_strDestnHighLayerInfo; } // CUniAdapterInfo CUniAdapterInfo & CUniAdapterInfo::operator=(const CUniAdapterInfo & info) { Assert(this != &info); if (this == &info) return *this; // the adapter's binding state m_strBindName = info.m_strBindName; m_BindingState = info.m_BindingState; m_fDeleted = info.m_fDeleted; FreeCollectionAndItem(m_listPVCs); for (PVC_INFO_LIST::iterator iterPVCInfo = info.m_listPVCs.begin(); iterPVCInfo != info.m_listPVCs.end(); iterPVCInfo ++) { CPvcInfo * pNewPvc = new CPvcInfo((*iterPVCInfo)->m_strPvcId.c_str()); if (pNewPvc == NULL) { continue; } *pNewPvc = **iterPVCInfo; m_listPVCs.push_back(pNewPvc); } return *this; } void CUniAdapterInfo::SetDefaults(PCWSTR pszBindName) { m_strBindName = pszBindName; m_BindingState = BIND_UNSET; FreeCollectionAndItem(m_listPVCs); m_fDeleted = FALSE; }