diff -r 000000000000 -r 094583676ce7 IMPSengine/wvotaparser/src/wvsettings.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/IMPSengine/wvotaparser/src/wvsettings.cpp Thu Dec 17 08:41:52 2009 +0200 @@ -0,0 +1,705 @@ +/* +* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* Parser for the WirelessVillage OTA settings. +* Supports only wbxml. +* +*/ + +#include +#include +#include +#include "wvsettings.h" +#include "wvsettingsdef.h" + +// CONSTANTS +const TInt KMaxStringSize = 200; +const TInt KElemAndEndTokenLength = 2; +const TInt KEndTokenLength = 1; +// --------------------------------------------------------- +// CWVSettingsParser::CWVSettingsParser() +// --------------------------------------------------------- +// +CWVSettingsParser::CWVSettingsParser(): +iListEmpty(ETrue), +iOTAVersion(EFalse), +iPassword(EFalse), +iPreferredProtocol(EFalse), +iProxyAddress(EFalse), +iProxyPort(EFalse), +iProxyUser(EFalse), +iProxyPassword(EFalse), +iRefName(EFalse), +iSAP4WaySupportedSms(EFalse), +iSAP4WaySupportedHttp(EFalse), +iSAPMobileNumber(EFalse), +iSAPURI(EFalse), +iSettingsName(EFalse), +iSMSCMobileNumber(EFalse), +iUserID(EFalse), +iSupportedVersions(EFalse), +iCommon(EFalse), +iSms(EFalse), +iHttp(EFalse), +iProxy(EFalse) + { + iDatabufferSize = 0; + iParsedBytes = 0; + } + +// --------------------------------------------------------- +// CWVSettingsParser::NewL() +// --------------------------------------------------------- +// +EXPORT_C CWVSettingsParser* CWVSettingsParser::NewL() + { + CWVSettingsParser* self = new (ELeave) CWVSettingsParser (); + CleanupStack::PushL( self ); + self->ConstructL( ); + CleanupStack::Pop(); + return self; + } + +// --------------------------------------------------------- +// CWVSettingsParser::ConstructL() +// --------------------------------------------------------- +// +void CWVSettingsParser::ConstructL() + { + iWVSupportedVersions = new (ELeave) CArrayPtrFlat(1); + iRootElement = CXmlElement::NewL (&KWVSettings, NULL); + iWVOTAVersion = HBufC::NewL(KMaxStringSize); + iWVPassword = HBufC::NewL (KMaxStringSize); + iWVPreferredProtocol = HBufC::NewL (KMaxStringSize); + iWVProxyAddress = HBufC::NewL (KMaxStringSize); + iWVProxyPort = HBufC::NewL (KMaxStringSize); + iWVProxyUser = HBufC::NewL (KMaxStringSize); + iWVRefName = HBufC::NewL (KMaxStringSize); + iWVSAPFourWaySupported1 = HBufC::NewL (KMaxStringSize); + iWVSAPFourWaySupported2 = HBufC::NewL (KMaxStringSize); + iWVSAPMobileNumber = HBufC::NewL (KMaxStringSize); + iWVSAPURI = HBufC::NewL (KMaxStringSize); + iWVSettingsName = HBufC::NewL (KMaxStringSize); + iWVSMSCMobileNumber = HBufC::NewL (KMaxStringSize); + iWVUserID = HBufC::NewL (KMaxStringSize); + iWVProxyPassword = HBufC::NewL (KMaxStringSize); + } + +// --------------------------------------------------------- +// CWVSettingsParser::~CWVSettingsParser() +// --------------------------------------------------------- +// +CWVSettingsParser::~CWVSettingsParser() + { + delete iRootElement; + delete iWVSettingsName; + delete iWVOTAVersion; + delete iWVPassword; + delete iWVPreferredProtocol; + delete iWVProxyAddress; + delete iWVProxyPort; + delete iWVProxyUser; + delete iWVRefName; + delete iWVSAPFourWaySupported1; + delete iWVSAPFourWaySupported2; + delete iWVSAPMobileNumber; + delete iWVSAPURI; + delete iWVSMSCMobileNumber; + if (iWVSupportedVersions != NULL) + { + iWVSupportedVersions->ResetAndDestroy (); + delete iWVSupportedVersions; + } + delete iWVUserID; + delete iWVProxyPassword; + } + +// --------------------------------------------------------- +// CWVSettingsParser::ParseL +// --------------------------------------------------------- +// +EXPORT_C TBool CWVSettingsParser::ParseL(TDesC8& aDataBuffer) + { + DoParseL (aDataBuffer); + CreateXmlElementTreeL (); + TBool errNotFound = Validate (); + return errNotFound; + } + +// --------------------------------------------------------- +// CWVSettingsParser::CreateXmlElementTreeL +// --------------------------------------------------------- +// +void CWVSettingsParser::CreateXmlElementTreeL () + { + /* used for the CleanupStack */ + TInt nbrOfElements = 0; + /* Create all elements and set the data */ + if (iOTAVersion) + { + CXmlElement* WVOTAVersion = CXmlElement::NewL (&KWVOTAVersion, iRootElement); + CleanupStack::PushL(WVOTAVersion); + WVOTAVersion->SetTextL(*iWVOTAVersion); + iRootElement->AppendChildL (WVOTAVersion); + nbrOfElements++; + } + if (iCommon) + { + CXmlElement* WVCommon = CXmlElement::NewL (&KWVCommon, iRootElement); + CleanupStack::PushL(WVCommon); + if (iSettingsName) + { + CXmlElement* WVSettingsName = CXmlElement::NewL (&KWVSettingsName, WVCommon); + CleanupStack::PushL(WVSettingsName); + WVSettingsName->SetTextL(*iWVSettingsName); + WVCommon->AppendChildL (WVSettingsName); + nbrOfElements++; + } + if (iRefName) + { + CXmlElement* WVRefName = CXmlElement::NewL (&KWVRefName, WVCommon); + CleanupStack::PushL(WVRefName); + WVRefName->SetTextL(*iWVRefName); + WVCommon->AppendChildL (WVRefName); + nbrOfElements++; + } + if (iSupportedVersions) + { + CXmlElement* WVSupportedVersion; + TInt nbrOfVersions = iWVSupportedVersions->Count(); + for (TInt i = 0; i < nbrOfVersions; i++) + { + WVSupportedVersion = CXmlElement::NewL (&KWVSupportedVersion, WVCommon); + CleanupStack::PushL(WVSupportedVersion); + WVSupportedVersion->SetTextL(*iWVSupportedVersions->At(i)); + WVCommon->AppendChildL (WVSupportedVersion); + nbrOfElements++; + } + } + if (iUserID) + { + CXmlElement* WVUserID = CXmlElement::NewL (&KWVUserID, WVCommon); + CleanupStack::PushL(WVUserID); + WVUserID->SetTextL(*iWVUserID); + WVCommon->AppendChildL (WVUserID); + nbrOfElements++; + } + if (iPassword) + { + CXmlElement* WVPassword = CXmlElement::NewL (&KWVPassword, WVCommon); + CleanupStack::PushL(WVPassword); + WVPassword->SetTextL(*iWVPassword); + WVCommon->AppendChildL (WVPassword); + nbrOfElements++; + } + if (iPreferredProtocol) + { + CXmlElement* WVPreferredProtocol = CXmlElement::NewL (&KWVPreferredProtocol, WVCommon); + CleanupStack::PushL(WVPreferredProtocol); + WVPreferredProtocol->SetTextL(*iWVPreferredProtocol); + WVCommon->AppendChildL (WVPreferredProtocol); + nbrOfElements++; + } + iRootElement->AppendChildL (WVCommon); + nbrOfElements++; + } //WVCommon + if (iSms) + { + CXmlElement* WVSMS = CXmlElement::NewL (&KWVSMS, iRootElement); + CleanupStack::PushL(WVSMS); + if (iSAPMobileNumber) + { + CXmlElement* WVSAPMobileNumber = CXmlElement::NewL (&KWVSAPMobileNumber, WVSMS); + CleanupStack::PushL(WVSAPMobileNumber); + WVSAPMobileNumber->SetTextL(*iWVSAPMobileNumber); + WVSMS->AppendChildL (WVSAPMobileNumber); + nbrOfElements++; + } + if (iSAP4WaySupportedSms) + { + CXmlElement* WVSAPFourWaySupported1 = CXmlElement::NewL (&KWVSAPFourWaySupported, WVSMS); + CleanupStack::PushL(WVSAPFourWaySupported1); + WVSAPFourWaySupported1->SetTextL(*iWVSAPFourWaySupported1); + WVSMS->AppendChildL (WVSAPFourWaySupported1); + nbrOfElements++; + } + if (iSMSCMobileNumber) + { + CXmlElement* WVSMSCMobileNumber = CXmlElement::NewL (&KWVSMSCMobileNumber, WVSMS); + CleanupStack::PushL(WVSMSCMobileNumber); + WVSMSCMobileNumber->SetTextL(*iWVSMSCMobileNumber); + WVSMS->AppendChildL (WVSMSCMobileNumber); + nbrOfElements++; + } + iRootElement->AppendChildL (WVSMS); + nbrOfElements++; + } // WVSMS + if (iHttp) + { + CXmlElement* WVHTTP = CXmlElement::NewL (&KWVHTTP, iRootElement); + CleanupStack::PushL(WVHTTP); + if ( iSAPURI) + { + CXmlElement* WVSAPURI = CXmlElement::NewL (&KWVSAPURI, WVHTTP); + CleanupStack::PushL(WVSAPURI); + WVSAPURI->SetTextL(*iWVSAPURI); + WVHTTP->AppendChildL (WVSAPURI); + nbrOfElements++; + } + if (iSAP4WaySupportedHttp) + { + CXmlElement* WVSAPFourWaySupported2 = CXmlElement::NewL (&KWVSAPFourWaySupported, WVHTTP); + CleanupStack::PushL(WVSAPFourWaySupported2); + WVSAPFourWaySupported2->SetTextL(*iWVSAPFourWaySupported2); + WVHTTP->AppendChildL (WVSAPFourWaySupported2); + nbrOfElements++; + } + if (iProxy) + { + CXmlElement* WVProxy = CXmlElement::NewL (&KWVProxy, WVHTTP); + CleanupStack::PushL(WVProxy); + if ( iProxyAddress) + { + CXmlElement* WVProxyAddress = CXmlElement::NewL (&KWVProxyAddress, WVProxy); + CleanupStack::PushL(WVProxyAddress); + WVProxyAddress->SetTextL(*iWVProxyAddress); + WVProxy->AppendChildL (WVProxyAddress); + nbrOfElements++; + } + if (iProxyPort) + { + CXmlElement* WVProxyPort = CXmlElement::NewL (&KWVProxyPort, WVProxy); + CleanupStack::PushL(WVProxyPort); + WVProxyPort->SetTextL(*iWVProxyPort); + WVProxy->AppendChildL (WVProxyPort); + nbrOfElements++; + } + if (iProxyUser) + { + CXmlElement* WVProxyUser = CXmlElement::NewL (&KWVProxyUser, WVProxy); + CleanupStack::PushL(WVProxyUser); + WVProxyUser->SetTextL(*iWVProxyUser); + WVProxy->AppendChildL (WVProxyUser); + nbrOfElements++; + } + if (iProxyPassword) + { + CXmlElement* WVProxyPassword = CXmlElement::NewL (&KWVProxyPassword, WVProxy); + CleanupStack::PushL(WVProxyPassword); + WVProxyPassword->SetTextL(*iWVProxyPassword); + WVProxy->AppendChildL (WVProxyPassword); + nbrOfElements++; + } + WVHTTP->AppendChildL (WVProxy); + nbrOfElements++; + } // WVProxy + iRootElement->AppendChildL (WVHTTP); + nbrOfElements++; + } // WVHTTP + //for testing + //iRootElement->WriteIntoFileL(); + CleanupStack::Pop(nbrOfElements); // elements + } + +// --------------------------------------------------------- +// CWVSettingsParser::Root () +// --------------------------------------------------------- +// +EXPORT_C CXmlElement* CWVSettingsParser::Root () + { + return iRootElement; + } + +// --------------------------------------------------------- +// CWVSettingsParser::DoParseL +// --------------------------------------------------------- +// +void CWVSettingsParser::DoParseL(TDesC8& aDataBuffer) + { + TBool done = EFalse; + TUint8* dataPtr = (TUint8*) aDataBuffer.Ptr(); + + iDatabufferSize = aDataBuffer.Size(); + + if (iDatabufferSize > 0) + { + // save the buffer's start point + TUint8* startPtr = dataPtr; + //version, public id, charset + dataPtr = dataPtr+3; + //string table + dataPtr++; + + // this is used for 4waySupported + TBool sms = EFalse; + while(!done) + { + switch (*dataPtr) + { + case (KWV_TAG_CONTENT + K_WVSETTINGS): + dataPtr++; + break; + case (KWV_TAG_CONTENT + K_WVOTAVERSION): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVOTAVersion); + iOTAVersion = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVCOMMON): + dataPtr++; + iCommon = ETrue; + break; + case(KWV_TAG_CONTENT + K_WVSETTINGSNAME): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSettingsName); + iSettingsName = ETrue; + break; + case(KWV_TAG_CONTENT + K_WVREFNAME): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVRefName); + iRefName = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVSUPPORTEDVERSION): + dataPtr = dataPtr + ReadSupportedVersionsL(dataPtr); + iSupportedVersions = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVUSERID): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVUserID); + iUserID = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVPASSWORD): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVPassword); + iPassword = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVPREFERREDPROTOCOL): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVPreferredProtocol); + iPreferredProtocol = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVSMS): + dataPtr++; + sms = ETrue; + iSms = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVSAPMOBILENUMBER): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSAPMobileNumber); + iSAPMobileNumber = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVSAPFOURWAYSUPPORTED): + // NOTE This assumes that if msg has WVSMS element, it comes always before WVHTTP element + // anyhow the specs say that... + // ...The elements in the WV settings must be sent in a same order as the + // content models of these DTD elements define them + if (sms) + { + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSAPFourWaySupported1); + sms = EFalse; + iSAP4WaySupportedSms = ETrue; + } + else + { + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSAPFourWaySupported2); + iSAP4WaySupportedHttp = ETrue; + } + break; + case (KWV_TAG_CONTENT + K_WVSMSMOBILENUMBER): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSMSCMobileNumber); + iSMSCMobileNumber = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVHTTP): + dataPtr++; + iHttp = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVSAPURI): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVSAPURI); + iSAPURI = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVPROXY): + dataPtr++; + iProxy = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVPROXYADDRESS): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVProxyAddress); + iProxyAddress = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVPROXYPORT): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVProxyPort); + iProxyPort = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVPROXYUSER): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVProxyUser); + iProxyUser = ETrue; + break; + case (KWV_TAG_CONTENT + K_WVPROXYPASSWORD): + dataPtr = dataPtr + ReadElementWithContentL(dataPtr, iWVProxyPassword); + iProxyPassword = ETrue; + break; + + case K_WVOTAVERSION: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVOTAVersion); + iOTAVersion = ETrue; + break; + case K_WVCOMMON: + dataPtr+=KElemAndEndTokenLength; + iCommon = ETrue; + break; + case K_WVSETTINGSNAME: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSettingsName); + iSettingsName = ETrue; + break; + case K_WVREFNAME: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVRefName); + iRefName = ETrue; + break; + case K_WVSUPPORTEDVERSION: + dataPtr+=KElemAndEndTokenLength; + iSupportedVersions = ETrue; + break; + case K_WVUSERID: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVUserID); + iUserID = ETrue; + break; + case K_WVPASSWORD: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVPassword); + iPassword = ETrue; + break; + case K_WVPREFERREDPROTOCOL: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVPreferredProtocol); + iPreferredProtocol = ETrue; + break; + case K_WVSMS: + dataPtr+=KElemAndEndTokenLength; + iSms = ETrue; + break; + case K_WVSAPMOBILENUMBER: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSAPMobileNumber); + iSAPMobileNumber = ETrue; + break; + case K_WVSAPFOURWAYSUPPORTED: + if (sms) + { + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSAPFourWaySupported1); + sms = EFalse; + iSAP4WaySupportedSms = ETrue; + } + else + { + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSAPFourWaySupported2); + iSAP4WaySupportedHttp = ETrue; + } + break; + case K_WVSMSMOBILENUMBER: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSMSCMobileNumber); + iSMSCMobileNumber = ETrue; + break; + case K_WVHTTP: + dataPtr+=KElemAndEndTokenLength; + iHttp = ETrue; + break; + case K_WVSAPURI: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVSAPURI); + iSAPURI = ETrue; + break; + case K_WVPROXY: + dataPtr+=KElemAndEndTokenLength; + iProxy = ETrue; + break; + case K_WVPROXYADDRESS: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVProxyAddress); + iProxyAddress = ETrue; + break; + case K_WVPROXYPORT: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVProxyPort); + iProxyPort = ETrue; + break; + case K_WVPROXYUSER: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVProxyUser); + iProxyUser = ETrue; + break; + case K_WVPROXYPASSWORD: + dataPtr = dataPtr + ReadEmptyElement (dataPtr, iWVProxyPassword); + iProxyPassword = ETrue; + break; + case KWV_END_TAG: + dataPtr++; // end tag + break; + default: + dataPtr++; + break; + }//switch + iParsedBytes = dataPtr - startPtr; + if ( iParsedBytes >= iDatabufferSize) + done = ETrue; + }//while + } // databuffer + +} + +// --------------------------------------------------------- +// CWVSettingsParser::ReadElementWithContentL +// --------------------------------------------------------- +// +TInt CWVSettingsParser::ReadElementWithContentL(TUint8* aPtr, HBufC* aDataBuffer) + { + TInt count = 0; + TInt inlineStr = 0; + // remove the element tag + aPtr++; + //next should be inline string token 0x03 + if (*aPtr == KWV_STR_I){ + aPtr++; + inlineStr++; + } + // find the end tag + TUint8* start = aPtr; + while ( *start != KWV_END_TAG && ((iParsedBytes + inlineStr + count) < iDatabufferSize)) + { + count++; + start++; + } + TInt size = 0; + if (count > KMaxStringSize) + size = KMaxStringSize; + else if (count == 0) + size = 0; + else + size = count-1; + aDataBuffer->ReAllocL(size); + TPtr16 dataPtr = aDataBuffer->Des(); + for (TInt i = 0; i < size; i++) + { + dataPtr.Append(*aPtr); + aPtr++; + } + return count + inlineStr + KElemAndEndTokenLength; + } + +// --------------------------------------------------------- +// CWVSettingsParser::ReadSupportedVersionsL +// --------------------------------------------------------- +// +TInt CWVSettingsParser::ReadSupportedVersionsL(TUint8* aPtr) + { + TInt count = 0; + TInt inlineStr = 0; + // remove the element tag + aPtr++; + //next should be inline string token 0x03 + if (*aPtr == KWV_STR_I){ + aPtr++; + inlineStr++; + } + // find the end tag + TUint8* start = aPtr; + while ( *start != KWV_END_TAG && ((iParsedBytes + inlineStr + count) < iDatabufferSize)) + { + count++; + start++; + } + TInt size = 0; + if (count > KMaxStringSize) + size = KMaxStringSize; + else if (count == 0) + size = 0; + else + size = count-1; + HBufC* version = HBufC::NewL(size); + CleanupStack::PushL(version); + TPtr16 dataPtr = version->Des(); + for (TInt i = 0; i < size ; i++) + { + dataPtr.Append(*aPtr); + aPtr++; + } + if(iListEmpty) + { + iWVSupportedVersions->AppendL(version); + iListEmpty = EFalse; + } + else + { + TInt index = iWVSupportedVersions->Count(); + iWVSupportedVersions->InsertL(index, version); + } + CleanupStack::Pop(); + return count + inlineStr + KElemAndEndTokenLength; +} + +// --------------------------------------------------------- +// CWVSettingsParser::ReadEmptyElement +// --------------------------------------------------------- +// +TInt CWVSettingsParser::ReadEmptyElement(TUint8* aPtr, HBufC* dataBuffer) +{ + TInt count = 0; + TUint8* start = aPtr; + + while ( *start != KWV_END_TAG && ((iParsedBytes + count) <= iDatabufferSize)) + { + count++; + start++; + } + if (dataBuffer) + dataBuffer = NULL; + + return count + KEndTokenLength; // also the element tag +} + +// --------------------------------------------------------- +// CWVSettingsParser::Validate () +// --------------------------------------------------------- +// +TBool CWVSettingsParser::Validate () +{ + TBool errNotFound = ETrue; + // mandatory in wvsettings + if (!iOTAVersion) + errNotFound = EFalse; + // mandatory in wvsettings + if (!iCommon) + errNotFound = EFalse; + else + { + // mandatory in wvcommon + if (!iSettingsName) + errNotFound = EFalse; + // mandatory in wvcommon + if (!iSupportedVersions) + errNotFound = EFalse; + } + if (iSms) + { + // mandatory in wvsms + if (!iSAPMobileNumber) + errNotFound = EFalse; + // mandatory in wvsms + if (!iSAP4WaySupportedSms) + errNotFound = EFalse; + if (!iSMSCMobileNumber) + // mandatory in wvsms + errNotFound = EFalse; + } + if (iHttp) + { + // mandatory in wvhttp + if (!iSAPURI) + errNotFound = EFalse; + // mandatory in wvhttp + if (!iSAP4WaySupportedHttp) + errNotFound = EFalse; + // optional in wvhttp + if (iProxy) + { + // mandatory in wvproxy + if (!iProxyAddress) + errNotFound = EFalse; + } + } + return errNotFound; + }