diff -r 000000000000 -r bde4ae8d615e os/security/cryptomgmtlibs/securitytestfw/test/testhandler2/T_input.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/security/cryptomgmtlibs/securitytestfw/test/testhandler2/T_input.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,556 @@ +/* +* Copyright (c) 1998-2009 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: +* +*/ + + +#include +#include "t_input.h" +#include "t_errorconverter.h" + +const TUint KMaxTagLength = 80; + +EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, const TDesC8& aStart, const TDesC8& aEnd) + { + TInt pos = 0; + return Input::ParseElement(aBuf, aStart, aEnd, pos); + } + +EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, const TDesC8& aStart) + { + TInt pos = 0; + TBuf8 end; + end.Copy(aStart); + end.Insert(1, _L8("/")); + return Input::ParseElement(aBuf, aStart, end, pos); + } + +EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, + const TDesC8& aStart, + const TDesC8& aEnd, + TInt& aPos) + { + TInt err = KErrNone; + return Input::ParseElement(aBuf, aStart, aEnd, aPos, err); + } + + +// Find the portion of aBuf between aStart and aEnd, allowing for nesting +EXPORT_C TPtrC8 Input::ParseElement(const TDesC8& aBuf, + const TDesC8& aStart, + const TDesC8& aEnd, + TInt& aPos, + TInt& aError) + { + aError = KErrNone; + TInt startPos = KErrNotFound; + TInt level = 0; + do + { + TPtrC8 data = aBuf.Mid(aPos); + + // Find the first start or end tag + TInt nextStart = data.Find(aStart); + TInt nextEnd = data.Find(aEnd); + + if (nextStart == KErrNotFound && nextEnd == KErrNotFound) + { + // None found + aError = KErrNotFound; + return TPtrC8(); + } + else if (nextEnd == KErrNotFound || (nextStart != KErrNotFound && nextStart < nextEnd)) + { + // Start tag found first + ++level; + aPos += nextStart + aStart.Length(); + + if (startPos == KErrNotFound) + { + // Record position of first start tag + startPos = aPos; + } + } + else + { + // End tag found first + --level; + aPos += nextEnd + aEnd.Length(); + } + } + while (level > 0); + + if (level == -1) + { + // End tag found before start tag + aError = KErrArgument; + return TPtrC8(); + } + + ASSERT(startPos != KErrNotFound); + return aBuf.Mid(startPos, aPos - startPos - aEnd.Length()); + } + +EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, const TDesC16& aStart, const TDesC16& aEnd) + { + TInt pos = 0; + return Input::ParseElement(aBuf, aStart, aEnd, pos); + } + + +EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, + const TDesC16& aStart, + const TDesC16& aEnd, + TInt& aPos) + { + TInt err = KErrNone; + return Input::ParseElement(aBuf, aStart, aEnd, aPos, err); + } + + +EXPORT_C TPtrC16 Input::ParseElement(const TDesC16& aBuf, + const TDesC16& aStart, + const TDesC16& aEnd, + TInt& aPos, + TInt& aError) + { + aError = KErrNone; + const TInt length = aBuf.Length(); + TPtrC16 temp1 = aBuf.Right(length - aPos); + TInt elementStart = temp1.Find(aStart); + if (elementStart < 0) + { + aError = elementStart; + TPtrC16 res(KNullDesC16); + return res; + } + elementStart+= aStart.Length(); + aPos+=elementStart; + + TPtrC16 temp2 = temp1.Right(temp1.Length() - elementStart); + TInt elementEnd = temp2.Find(aEnd); + if (elementEnd < 0) + { + TPtrC16 res(KNullDesC16); + return res; + } + + aPos+=elementEnd; + aPos+=aEnd.Length(); + + TPtrC16 element = temp2.Left(elementEnd); + return element; + } + +EXPORT_C HBufC8* Input::ParseElementHexL(const TDesC8& aBuf, const TDesC8& aStart) + { + TPtrC8 data = Input::ParseElement(aBuf, aStart); + __ASSERT_ALWAYS(data.Size() % 2 == 0, User::Panic(_L("ParseElementHexL"), 1)); + TInt bytes = data.Size()/2; + HBufC8* buf = HBufC8::NewLC(bytes); + TPtr8 ptr = buf->Des(); + ptr.SetLength(bytes); + + if(bytes) + { + for (TInt i = 0 ; i < data.Length() ; i += 2) + { + TUint8 tmp; + tmp=(TUint8)(data[i]-(data[i]>'9'?('A'-10):'0')); + tmp*=16; + tmp|=(TUint8)(data[i+1]-(data[i+1]>'9'?('A'-10):'0')); + ptr[i/2] = tmp; + } + } + CleanupStack::Pop(buf); + return buf; + } + +EXPORT_C TBool Input::ParseElementBoolL(const TDesC8& aBuf, const TDesC8& aStart) + { + TPtrC8 value = Input::ParseElement(aBuf, aStart); + if( value.CompareF(_L8("ETrue")) == 0 || value.CompareF(_L8("True")) == 0 ) + { + return ETrue; + } + else if( value.CompareF(_L8("EFalse")) == 0 || value.CompareF(_L8("False")) == 0 ) + { + return EFalse; + } + //if it's neither false nor true, leave + User::Leave(KErrArgument); + return EFalse; + } + + +EXPORT_C TBool Input::GetExpectedResultL(const TDesC& aResult /* in */, TInt &aError /* out */) + { + TBool result; + CErrorConverter *errorConverter = CErrorConverter::NewLC(); + + result = errorConverter->GetExpectedResultL(aResult, aError); + CleanupStack::PopAndDestroy(errorConverter); + + return(result); + } + + +EXPORT_C TBool Input::GetExpectedResultL(const TInt &aError /* in */, HBufC*& aResult /* out */) + { + TBool result; + CErrorConverter *errorConverter = CErrorConverter::NewLC(); + + result = errorConverter->GetExpectedResultL(aError, aResult); + CleanupStack::PopAndDestroy(errorConverter); + + return(result); + } + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C void Input::ParseElementL(HBufC*& aMember, + const TDesC& aBuf, + const TDesC& aStart) + { + TInt pos = 0; + ParseElementL(aMember, aBuf, aStart, pos); + }; + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C void Input::ParseElementL(HBufC8*& aMember, + const TDesC& aBuf, + const TDesC& aStart) + { + TInt pos = 0; + ParseElementL(aMember, aBuf, aStart, pos); + }; + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C void Input::ParseElementL(HBufC*& aMember, + const TDesC& aBuf, + const TDesC& aStart, + TInt& aPos) + { + TInt error = KErrNone; + ParseElementL(aMember, aBuf, aStart, aPos, error); + }; + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C void Input::ParseElementL(HBufC8*& aMember, + const TDesC& aBuf, + const TDesC& aStart, + TInt& aPos) + { + TInt error = KErrNone; + ParseElementL(aMember, aBuf, aStart, aPos, error); + }; + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C void Input::ParseElementL(HBufC*& aMember, + const TDesC& aBuf, + const TDesC& aStart, + TInt& aPos, + TInt& aError) + { + __ASSERT_DEBUG(!aMember, User::Panic(_L("Input"), 1)); + + + TPtrC value = ParseElement(aBuf, aStart, aPos, aError); + // copy file name to unicode buffer + aMember = HBufC::NewL(value.Length()); + aMember->Des().Copy(value); + } + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C void Input::ParseElementL(HBufC8*& aMember, + const TDesC& aBuf, + const TDesC& aStart, + TInt& aPos, + TInt& aError) + { + __ASSERT_DEBUG(!aMember, User::Panic(_L("Input"), 1)); + + + TPtrC value = ParseElement(aBuf, aStart, aPos, aError); + // copy file name to narrow buffer + aMember = HBufC8::NewL(value.Length()); + aMember->Des().Copy(value); + } + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart) + { + TInt pos = 0; + return(ParseElement(aBuf, aStart, pos)); + }; + + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos) + { + TInt error = KErrNone; + return(ParseElement(aBuf, aStart, aPos, error)); + }; + + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C TPtrC Input::ParseElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos, TInt& aError) + { + // using the start tag create a matching tag terminator <\abcd> + HBufC* hend = HBufC::NewMaxLC(aStart.Length()+1); + + TPtr end = hend->Des(); + end = aStart; // copy in start tag + end.Insert(1,_L("/")); // make it into a terminator tag with same element name + // get value from element + TPtrC value = Input::ParseElement(aBuf, aStart, end, aPos, aError); + + CleanupStack::PopAndDestroy(hend); + return(value); + } + +EXPORT_C HBufC8* Input::ReadFileL(const TDesC& aFilename, RFs& aFs) + { + HBufC8* ret = ReadFileLC(aFilename, aFs); + CleanupStack::Pop(); + return ret; + } + +EXPORT_C HBufC8* Input::ReadFileL(const TDesC& aFilename, const TDesC& aPath, RFs& aFs) + { + HBufC8* ret = ReadFileLC(aFilename, aPath, aFs); + CleanupStack::Pop(); + return ret; + } + +EXPORT_C HBufC8* Input::ReadFileLC(const TDesC& aFilename, RFs& aFs) + { + RFile file; + User::LeaveIfError(file.Open(aFs, aFilename, EFileRead)); + CleanupClosePushL(file); + TInt size; + file.Size(size); + CleanupStack::PopAndDestroy();//fileClose + + HBufC8* res = HBufC8::NewLC(size); + TPtr8 p(res->Des()); + p.SetLength(size); + + RFileReadStream stream; + User::LeaveIfError(stream.Open(aFs, aFilename, EFileStream)); + CleanupClosePushL(stream); + stream.ReadL(p, size); + CleanupStack::PopAndDestroy();//streamClose + return res; + } + +EXPORT_C HBufC8* Input::ReadFileLC(const TDesC& aFilename, const TDesC& aPath, RFs& aFS) + { + TFileName fullname; + fullname.Append(aPath); + fullname.Append(aFilename); + + RFile file; + User::LeaveIfError(file.Open(aFS, fullname, EFileRead)); + CleanupClosePushL(file); + TInt size; + file.Size(size); + CleanupStack::PopAndDestroy();//fileClose + + HBufC8* res = HBufC8::NewLC(size); + TPtr8 p(res->Des()); + p.SetLength(size); + + RFileReadStream stream; + User::LeaveIfError(stream.Open(aFS, fullname, EFileStream)); + CleanupClosePushL(stream); + stream.ReadL(p, size); + CleanupStack::PopAndDestroy();//streamClose + return res; + } + +EXPORT_C void Input::ParseElementListL(const TDesC& aBuf, + const TDesC& aStart, + const TDesC& aEnd, + RPointerArray& aElements, + TInt& aPos) + { + TPtrC currentElement = ParseElement(aBuf, aStart, aEnd, aPos); + while (currentElement != KNullDesC) + { + HBufC* newElement = HBufC::NewL(currentElement.Size()); + *newElement = currentElement; + User::LeaveIfError(aElements.Append(newElement)); + currentElement.Set(ParseElement(aBuf, aStart, aEnd, aPos)); + } + } + +EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, const TDesC8& aStart, const TDesC8& aEnd) + { + TInt pos = 0; + return Input::ParseIntElement(aBuf, aStart, aEnd, pos); + } + + +EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, + const TDesC8& aStart, + const TDesC8& aEnd, + TInt& aPos) + { + TInt err = KErrNone; + return Input::ParseIntElement(aBuf, aStart, aEnd, aPos, err); + } + + +EXPORT_C TUint Input::ParseIntElement(const TDesC8& aBuf, + const TDesC8& aStart, + const TDesC8& aEnd, + TInt& aPos, + TInt& aError) + { + aError = KErrNone; + TPtrC8 temp = ParseElement(aBuf, aStart, aEnd, aPos, aError); + + TUint result = 0; + + if(aError == KErrNone) + { + TLex8 lex; + if(temp.Left(2) == _L8("0x")) + { + lex = temp.Mid(2); + aError = lex.Val(result, EHex); + } + else + { + lex = temp; + aError = lex.Val(result); + }; + + if(aError == KErrNone) + { + if(!lex.Eos()) + { + aError = KErrArgument; + result = 0; + }; + }; + }; + return(result); + } + +EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, const TDesC16& aStart, const TDesC16& aEnd) + { + TInt pos = 0; + return Input::ParseIntElement(aBuf, aStart, aEnd, pos); + } + + +EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, + const TDesC16& aStart, + const TDesC16& aEnd, + TInt& aPos) + { + TInt err = KErrNone; + return Input::ParseIntElement(aBuf, aStart, aEnd, aPos, err); + } + + +EXPORT_C TUint Input::ParseIntElement(const TDesC16& aBuf, + const TDesC16& aStart, + const TDesC16& aEnd, + TInt& aPos, + TInt& aError) + { + aError = KErrNone; + TPtrC16 temp = ParseElement(aBuf, aStart, aEnd, aPos, aError); + + TUint result = 0; + + if(aError == KErrNone) + { + TLex16 lex; + if(temp.Left(2) == _L16("0x")) + { + lex = temp.Mid(2); + aError = lex.Val(result, EHex); + } + else + { + lex = temp; + aError = lex.Val(result); + }; + + if(aError == KErrNone) + { + if(!lex.Eos()) + { + aError = KErrArgument; + result = 0; + }; + }; + }; + return(result); + } + + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart) + { + TInt pos = 0; + return(ParseIntElement(aBuf, aStart, pos)); + }; + + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos) + { + TInt error = KErrNone; + return(ParseIntElement(aBuf, aStart, aPos, error)); + }; + + +// Allocate memory on the heap and copy in the value of a tagged element +EXPORT_C TUint Input::ParseIntElement(const TDesC& aBuf, const TDesC& aStart, TInt& aPos, TInt& aError) + { + // get value from element + TPtrC temp = Input::ParseElement(aBuf, aStart, aPos, aError); + TUint result = 0; + + if(aError == KErrNone) + { + TLex16 lex; + if(temp.Left(2) == _L16("0x")) + { + lex = temp.Mid(2); + aError = lex.Val(result, EHex); + } + else + { + lex = temp; + aError = lex.Val(result); + }; + + if(aError == KErrNone) + { + if(!lex.Eos()) + { + aError = KErrArgument; + result = 0; + }; + }; + }; + + return(result); + }