diff -r 6385c4c93049 -r 8e6fa1719340 pushmtm/MtmUtilSrc/WhiteListImporterWL.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pushmtm/MtmUtilSrc/WhiteListImporterWL.cpp Wed Sep 01 12:31:04 2010 +0100 @@ -0,0 +1,367 @@ +/* +* Copyright (c) 2003, 2004 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "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: Implementation of CWhiteListConverter. +* +*/ + + +// INCLUDE FILES + +#include "WhiteListImporter.h" +#include "PushMtmSettings.h" +#include "PushInitiatorList.h" +#include "PushInitiator.h" +#include "PushMtmLog.h" +#include + +// CONSTANTS + +/// Max length allowed. +LOCAL_C const TInt KMaxLength = 2048; + +/* +* Special characters. +*/ +/// ',' character. +LOCAL_C const TUint KComma = ','; +/// ';' character. +LOCAL_C const TUint KSemicolon = ';'; +/// Escape '\' character. +LOCAL_C const TUint KEscape = '\\'; + +/* +* Characters considered as EOS. +*/ +/// '\r' character. +LOCAL_C const TUint KCr = '\r'; +/// '\n' character. +LOCAL_C const TUint KLf = '\n'; + +/* +* Separator characters. +*/ +/// End-Of-String (0) character. It is a separator. +LOCAL_C const TUint KEos = 0; +/// Record separator (30) character. +LOCAL_C const TUint KRecordSeparator = 30; +/// Unit separator (31) character. +LOCAL_C const TUint KUnitSeparator = 31; + +/* +* Keywords. +*/ +/// "Ipv4" keyword. +_LIT( KIpv4, "Ipv4" ); +/// "Ipv6" keyword. +_LIT( KIpv6, "Ipv6" ); +/// "E164" keyword. +_LIT( KE164, "E164" ); +/// "Alpha" keyword. +_LIT( KAlpha, "Alpha" ); + + +// ================= MEMBER FUNCTIONS ======================= + +// --------------------------------------------------------- +// CWhiteListConverter::NewL +// --------------------------------------------------------- +// +CWhiteListConverter* CWhiteListConverter::NewL( CPushInitiatorList& aPushInitiatorList ) + { + CWhiteListConverter* converter = + new (ELeave) CWhiteListConverter( aPushInitiatorList ); + CleanupStack::PushL( converter ); + converter->ConstructL(); + CleanupStack::Pop( converter ); // converter + return converter; + } + +// --------------------------------------------------------- +// CWhiteListConverter::~CWhiteListConverter +// --------------------------------------------------------- +// +CWhiteListConverter::~CWhiteListConverter() + { + delete iConverterBuf; + delete iBuf; + iNextCh = NULL; // Only used. + iMaxCh = NULL; // Only used. + } + +// --------------------------------------------------------- +// CWhiteListConverter::Buffer2ListL +// --------------------------------------------------------- +// +void CWhiteListConverter::Buffer2ListL( const TDesC& aSource ) + { + PUSHLOG_ENTERFN("CWhiteListConverter::Buffer2ListL"); + + iSource.Assign( aSource ); + iCurCh = KRecordSeparator; // Cannot be 0, because of GetChar() + GetChar(); + while( NextLineL() ) + { + }; + + PUSHLOG_LEAVEFN("CWhiteListConverter::Buffer2ListL"); + } + +// --------------------------------------------------------- +// CWhiteListConverter::List2BufferL +// --------------------------------------------------------- +// +HBufC* CWhiteListConverter::List2BufferL() + { + PUSHLOG_ENTERFN("CWhiteListConverter::List2BufferL"); + + HBufC* newConverterBuf = KNullDesC().AllocL(); // initial zero length buffer + delete iConverterBuf; + iConverterBuf = newConverterBuf; + TPtr writableConvBuf = iConverterBuf->Des(); + writableConvBuf.SetLength(0); + TInt itemsToExport = iPushInitiatorList.Count(); + // temp buffers + TBuf<16> type; + TBuf<16> entryId; + + for ( TInt i=0; i < itemsToExport; ++i ) + { + CPushInitiator& curr = iPushInitiatorList.At(i); + switch ( curr.Type() ) + { + case CPushInitiator::ETypeIpv4: type=KIpv4; break; + case CPushInitiator::ETypeIpv6: type=KIpv6; break; + case CPushInitiator::ETypeE164: type=KE164; break; + case CPushInitiator::ETypeAlpha: type=KAlpha; break; + default: type=KE164; break; + } + entryId.Format( _L("%d"), curr.EntryID() ); + + // check available space + // 3 is required for 2 commas and 1 semicolon. + TInt newItemLength = curr.Addr().Length()+type.Length()+entryId.Length()+3; + if ( writableConvBuf.MaxLength() < writableConvBuf.Length() + newItemLength ) + { + // reallocate a greater buffer + TInt currentMaxLength = writableConvBuf.MaxLength(); + iConverterBuf = iConverterBuf->ReAllocL( currentMaxLength + newItemLength ); + writableConvBuf.Set( iConverterBuf->Des() ); // re-initialize + } + + writableConvBuf.Append( curr.Addr() ); + writableConvBuf.Append( TChar(KComma) ); + writableConvBuf.Append( type ); + writableConvBuf.Append( TChar(KComma) ); + writableConvBuf.Append( entryId ); + if ( i+1 < itemsToExport ) + { + // there are still items to add + writableConvBuf.Append( TChar(KSemicolon) ); + } + } + + HBufC* ret = iConverterBuf; // ownersip is transferred to the caller. + iConverterBuf = 0; + + PUSHLOG_LEAVEFN("CWhiteListConverter::List2BufferL"); + return ret; + } + +// --------------------------------------------------------- +// CWhiteListConverter::CWhiteListConverter +// --------------------------------------------------------- +// +CWhiteListConverter::CWhiteListConverter( CPushInitiatorList& aPushInitiatorList ) +: iPushInitiatorList( aPushInitiatorList ) + { + } + +// --------------------------------------------------------- +// CWhiteListConverter::ConstructL +// --------------------------------------------------------- +// +void CWhiteListConverter::ConstructL() + { + iBuf = new (ELeave) TText[KMaxLength]; + iMaxCh = iBuf + KMaxLength; + } + +// --------------------------------------------------------- +// CWhiteListConverter::GetChar +// --------------------------------------------------------- +// +inline void CWhiteListConverter::GetChar() + { + // Do not continue if we already reached EOS: + if ( iCurCh == KEos ) + { + return; + } + + iCurCh = iSource.Get(); + + if ( iCurCh == KCr || iCurCh == KLf ) + { + // They are considered as EOS. + iCurCh = KEos; + } + else if ( iCurCh == KEscape ) + { + // Drop the Escape character and get the next as is. + iCurCh = iSource.Get(); + } + else if ( iCurCh == KComma ) + { + // It is a Unit Separator. + iCurCh = KUnitSeparator; + } + else if ( iCurCh == KSemicolon ) + { + // It is a Record Separator. + iCurCh = KRecordSeparator; + } + } + +// --------------------------------------------------------- +// CWhiteListConverter::NextLineL +// --------------------------------------------------------- +// +TBool CWhiteListConverter::NextLineL() + { + switch( iCurCh ) + { + case KEos: + // EOS + return EFalse; + + default: + // Parse White List attributes and process them. + AttrsL(); + break; + } + + return ETrue; + } + +// --------------------------------------------------------- +// CWhiteListConverter::NextTokenL +// --------------------------------------------------------- +// +TPtrC CWhiteListConverter::NextTokenL( TUint aStopChar ) + { + iNextCh = iBuf; // Start storing token at start of buffer. + while ( iNextCh < iMaxCh ) + { + if ( iCurCh == aStopChar || iCurCh == KEos ) + { + // Stop character found - return what we have stored so far. + // This may be an empty string as well. + return TPtrC( iBuf, iNextCh - iBuf ); + } + else + { + *iNextCh = STATIC_CAST( TText16, iCurCh ); + iNextCh++; + GetChar(); + } + } + // No more space in buffer to store token. + User::Leave( KErrOverflow ); + /*NOTREACHED*/ + return TPtrC(); + } + +// --------------------------------------------------------- +// CWhiteListConverter::AttrsL +// --------------------------------------------------------- +// +void CWhiteListConverter::AttrsL() + { + CPushInitiator* newInitiator = new (ELeave) CPushInitiator; + CleanupStack::PushL( newInitiator ); + + TPtrC token; + + // Address. + token.Set( NextTokenL( KUnitSeparator ) ); + HBufC* address = token.AllocLC(); // Copy the token to a separate area. + GetChar(); + + // Address type and/or entry ID. + token.Set( NextTokenL( KRecordSeparator ) ); + HBufC* addressTypeBuf = 0; + HBufC* entryIdBuf = 0; + // check if it contains an entry ID separated with a comma (KUnitSeparator) + TInt offset = token.Locate( TChar(KUnitSeparator) ); + if ( offset == KErrNotFound ) + { + // the whole token is address type + addressTypeBuf = token.AllocLC(); // Copy the token to a separate area. + entryIdBuf = 0; + } + else + { + addressTypeBuf = token.Mid(0,offset).AllocLC(); + TInt tokenLength = token.Length(); + entryIdBuf = token.Mid((offset+1),tokenLength-(offset+1)).AllocLC(); + } + + // Convert the address type string to enum. + // addressTypeBuf must not be NULL. + CPushInitiator::TAddrType addrType = CPushInitiator::ETypeE164; + if ( !(*addressTypeBuf).Compare( KIpv4 ) ) + { + addrType = CPushInitiator::ETypeIpv4; + } + else if ( !(*addressTypeBuf).Compare( KIpv6 ) ) + { + addrType = CPushInitiator::ETypeIpv6; + } + else if ( !(*addressTypeBuf).Compare( KE164 ) ) + { + addrType = CPushInitiator::ETypeE164; + } + else if ( !(*addressTypeBuf).Compare( KAlpha ) ) + { + addrType = CPushInitiator::ETypeAlpha; + } + else + { + User::Leave( KErrCorrupt ); + } + PUSHLOG_WRITE_FORMAT2("WL Importer: <%S> <%S>",&(address->Des()), + &(addressTypeBuf->Des())); + + TUint32 entryId(0); + if ( entryIdBuf ) + { + PUSHLOG_WRITE_FORMAT("WL Importer entryIdBuf: <%S>",&(entryIdBuf->Des())); + TLex lex( *entryIdBuf ); + lex.Val( entryId, EDecimal ); + CleanupStack::PopAndDestroy( entryIdBuf ); // entryIdBuf + } + + GetChar(); + + // No more attribute to parse. + + // Add the new initiator data to the Push settings. + newInitiator->SetAddressL( *address, addrType ); + newInitiator->SetEntryID( entryId ); + CleanupStack::PopAndDestroy( 2, address ); // addressTypeBuf, address + + iPushInitiatorList.AddL( newInitiator ); + CleanupStack::Pop( newInitiator ); // newInitiator + } +