/** * Convert a string to Hexadecimal * * @param aData String descriptor * @param aDes Descriptor where Hex value is stored * * @return N/A * * @leave System wide error */ void CT_DataVerify::ConvertString2HexL( const TDesC8& aData, TDes8& aDes ) { TBuf8<DataVerify::KCharlength> charBuf; // Check that buffer is even number if( ( aData.Length() % DataVerify::KCharlength ) != 0 ) { User::Leave( KErrBadDescriptor ); } // Go through the data and convert it two characters at a time // buffer overflow does not occur because buffer is checked to be even number first for( TInt i = 0, limit = aData.Length()-DataVerify::KCharlength; i <= limit; i+=DataVerify::KCharlength ) { // Clean char buffer first charBuf.Delete( 0, charBuf.Length() ); // Add KCharlength characters into buffer for ( TInt j = 0; j < DataVerify::KCharlength; j++ ) { charBuf.Append( aData[i+j] ); } TUint number; TLex8 converter = TLex8( charBuf ); // Two characters together represent a hex number in MD5 checksum User::LeaveIfError( converter.Val( number, EHex ) ); aDes.Append( number ); } }
// ----------------------------------------------------------------------------- // CSdpConnectionField::ParseIP6AddressL // Parses IP6 address and checks that it is valid // ----------------------------------------------------------------------------- // HBufC8* CSdpConnectionField::ParseIP6AddressL( TInt aPos, TInetAddr& aAddr, const TDesC8& aAddress, TInt& aTTL, TUint& aNumberOfAddresses ) const { HBufC8* address = NULL; if ( aAddr.IsMulticast() ) { // Multicast address - CAN contain one extra attribute, // number of addresses if ( aPos != aAddress.Length() ) { // Validity check for number strings TBool digit = SdpUtil::IsDigit( aAddress.Mid( aPos + 1, aAddress.Length() - aPos - 1 ) ); if ( !digit ) { User::Leave( KErrSdpCodecConnectionField ); } User::LeaveIfError( TLex8( aAddress.Mid( aPos + 1, aAddress.Length() - aPos - 1 ) ).Val( aNumberOfAddresses, EDecimal ) ); __ASSERT_ALWAYS( aNumberOfAddresses > 0, User::Leave( KErrSdpCodecConnectionField ) ); } else { aNumberOfAddresses = 1; } aTTL = KErrNotFound; // IP6 does not use TTL address = aAddress.Left( aPos ).AllocL(); } else { // Unicast address - cannot contain any multicast TTLs etc. if ( aPos == aAddress.Length() ) { address = aAddress.AllocL(); aTTL = KErrNotFound; aNumberOfAddresses = 1; } else { User::Leave( KErrSdpCodecConnectionField ); } } return address; }
// ----------------------------------------------------------------------------- // CSdpOriginField::Get63Msbs // Returns a maximum of 63 bits of information from the descriptor containing a // decimal number. // ----------------------------------------------------------------------------- // TInt64 CSdpOriginField::Get63Msbs( const TDesC8& aDecimalValue ) const { // The maximum amount of digits in a decimal number, that is guaranteed to // fit into 63 bits, is 18. Even if all the 18 digits are 9, the decimal // number is 999999999999999999. const TInt64 KMaxAmountOfDecimalDigits = 18; TInt64 value( 0 ); TPtrC8 msbPart = aDecimalValue.Left( KMaxAmountOfDecimalDigits ); TLex8( msbPart ).Val( value ); return value; }
TBool CSmfCredMgrClientSymbian::isPluginAuthenticatedL(QString PluginID) { CBufFlat* buf = CBufFlat::NewL(KMinBufSize); CleanupStack::PushL(buf); RBufWriteStream stream(*buf); CleanupClosePushL(stream); TPtr idPtr(qt_QString2HBufC(PluginID)->Des()); SmfUtils::ExternalizeDesL(idPtr, stream); stream.CommitL(); // to get the data from server, we create a space. HBufC8* retBuf = HBufC8::NewL(32); CleanupStack::PushL(retBuf); TPtr8 bufPtr = buf->Ptr(0); TPtr8 flag(retBuf->Des()); TIpcArgs args; args.Set(0, &bufPtr); args.Set(1, &flag); iSession.RequestService(ECheckPluginAuthentication, args); TLex8 iLex = TLex8(flag); TInt value = 0; iLex.Val(value); CleanupStack::PopAndDestroy(retBuf); CleanupStack::PopAndDestroy(&stream); CleanupStack::PopAndDestroy(buf); if (value) { RDebug::Printf("flag returned is ETrue"); return ETrue; } else { RDebug::Printf("flag returned is EFalse"); return EFalse; } }
OMX_ERRORTYPE CBellagioOpenMaxSymbianLoader::GetRolesOfComponent(OMX_STRING compName, OMX_U32 *pNumRoles, OMX_U8 **roles) { TInt index = 0; index = GetInfoIndex(compName); if (index < 0) { return OMX_ErrorComponentNotFound; } TLex8 lexer = TLex8((componentInfos[index])->OpaqueData()); lexer.Val((TUint32 &)(*pNumRoles), EDecimal); if((*pNumRoles) == 0) { return OMX_ErrorNone; } // check if client is asking only for the number of roles if (roles == NULL) { return OMX_ErrorNone; } // TODO We copy only one role here and there might be several of those TBuf8<257> role; TBufC8<1> endOfString((TText8*)"\0"); role.Append((componentInfos[index])->DataType()); role.Append(endOfString); strcpy((char*)roles[0], (char*)role.Ptr()); return OMX_ErrorNone; }
// ----------------------------------------------------------------------------- // CSdpRepeatField::ConstructL // Symbian 2nd phase constructor can leave. // ----------------------------------------------------------------------------- // void CSdpRepeatField::ConstructL(const TDesC8& aText) { iPool = SdpCodecStringPool::StringPoolL(); RArray <TPtrC8> lines; lines = SdpUtil::DivideToLinesL(aText, KErrSdpCodecRepeatField); CleanupClosePushL(lines); RArray<TPtrC8> repeatArray; repeatArray = SdpUtil::GetElementsFromLineL(lines[0], KErrSdpCodecRepeatField); CleanupClosePushL(repeatArray); const TDesC8& repeatName = iPool.StringF(SdpCodecStringConstants::ERepeat, SdpCodecStringConstants::Table).DesC(); __ASSERT_ALWAYS(lines.Count() == 1 && repeatArray.Count() >= 3 && repeatName.CompareF(repeatArray[0]) == 0, User::Leave(KErrSdpCodecRepeatField)); // repeat interval __ASSERT_ALWAYS(TLex8(repeatArray[1]).Peek() != '0', User::Leave(KErrSdpCodecRepeatField)); iRepeatInterval = TSdpTypedTime::DecodeL(repeatArray[1]); // active duration iActiveDuration = TSdpTypedTime::DecodeL(repeatArray[2]); if (repeatArray.Count() > 3) { for (TInt i = 3; i < repeatArray.Count(); i++) { User::LeaveIfError(iTimeOffsets.Append( TSdpTypedTime::DecodeL(repeatArray[i]))); } } CleanupStack::PopAndDestroy(2); // lines, repeatArray __TEST_INVARIANT; }
// --------------------------------------------------------------------------- // CSdpMediaField::ParseMediaL // --------------------------------------------------------------------------- // void CSdpMediaField::ParseMediaL() { iElementArray = iSdpCodecParseUtil->FirstLineArrayElementL(iPool, SdpCodecStringConstants::EMedia, KErrSdpCodecMediaField); __ASSERT_ALWAYS (iElementArray.Count() >= 4, User::Leave(KErrSdpCodecMediaField)); RStringF media = iPool.OpenFStringL(iElementArray[1]); CleanupClosePushL(media); SetMediaL(media); CleanupStack::Pop();//media media.Close(); iProtocol = iPool.OpenFStringL(iElementArray[3]); TInt lineEndPosition = iElementArray[2].Locate('/'); TUint port; if(lineEndPosition == KErrNotFound) { User::LeaveIfError( TLex8(iElementArray[2]).Val(port, EDecimal)); SetPortL(port); } else { User::LeaveIfError(TLex8( (iElementArray[2]).Left(lineEndPosition)).Val(port, EDecimal)); SetPortL(port); User::LeaveIfError(TLex8( (iElementArray[2]).Mid(lineEndPosition +1)).Val(port, EDecimal)); SetPortCountL(port); } __ASSERT_ALWAYS(SdpUtil::IsTokenCharWithOptionalSlash(iElementArray[3]), User::Leave(KErrArgument)); //iProtocol = iPool.OpenFStringL(iElementArray[3]); TInt length = 0; TInt i; for(i=4; i<iElementArray.Count(); i++) { length += iElementArray[i].Length(); if(i + 1 <iElementArray.Count()) { length += KSPStr().Length(); } } HBufC8* value = HBufC8::NewLC(length); TPtr8 ptr(value->Des()); for(i=4; i<iElementArray.Count(); i++) { ptr.Append(iElementArray[i]); if(i + 1 <iElementArray.Count()) { ptr.Append(KSPStr); } } SetFormatListL(*value); CleanupStack::Pop();//value delete value; iElementArray.Reset(); if (iSdpCodecParseUtil->LineArray().Count() > 0) { iSdpCodecParseUtil->LineArray().Remove(0); } }
// ----------------------------------------------------------------------------- // CSdpConnectionField::ParseIP4AddressL // Parses IP4 address and checks that it is valid // ----------------------------------------------------------------------------- // HBufC8* CSdpConnectionField::ParseIP4AddressL( TInt aPos, TInetAddr& aAddr, const TDesC8& aAddress, TInt& aTTL, TUint& aNumberOfAddresses ) const { HBufC8* address = NULL; if ( aAddr.IsMulticast() ) { // Multicast address - MUST contain TTL and possibly // number of addresses if ( aPos != aAddress.Length() ) { TInt pos2 = aAddress.Right( aAddress.Length() - aPos - 1 ).Locate( KSlashChar ); if ( pos2 != KErrNotFound ) { pos2 += aPos + 1; // Validity check for number strings TBool digit = SdpUtil::IsDigit( aAddress.Mid( aPos + 1, pos2 - aPos - 1 ) ); digit = digit && SdpUtil::IsDigit( aAddress.Mid( pos2 + 1, aAddress.Length() - pos2 - 1 ) ); if ( !digit ) { User::Leave( KErrSdpCodecConnectionField ); } // TTL & number of addresses User::LeaveIfError( TLex8( aAddress.Mid( aPos + 1, pos2 - aPos - 1 ) ).Val( aTTL ) ); User::LeaveIfError( TLex8( aAddress.Mid( pos2 + 1, aAddress.Length() - pos2 - 1 ) ).Val( aNumberOfAddresses, EDecimal ) ); __ASSERT_ALWAYS( aTTL >= 0 && aTTL <= 255 && aNumberOfAddresses > 0, User::Leave( KErrSdpCodecConnectionField ) ); } else { // Validity check for number strings TBool digit = SdpUtil::IsDigit( aAddress.Mid( aPos + 1, aAddress.Length() - aPos - 1 ) ); if ( !digit ) { User::Leave( KErrSdpCodecConnectionField ); } // Plain TTL User::LeaveIfError( TLex8( aAddress.Mid( aPos + 1, aAddress.Length() - aPos - 1 ) ).Val( aTTL ) ); aNumberOfAddresses = 1; __ASSERT_ALWAYS( aTTL >= 0 && aTTL <= 255, User::Leave( KErrSdpCodecConnectionField ) ); } address = aAddress.Left( aPos ).AllocL(); } else { User::Leave( KErrSdpCodecConnectionField ); } } else { // Unicast address - cannot contain any multicast TTLs etc. if ( aPos == aAddress.Length() ) { address = aAddress.AllocL(); aTTL = KErrNotFound; aNumberOfAddresses = 1; } else { User::Leave( KErrSdpCodecConnectionField ); } } return address; }
void CActionSet::PerformAction(TRequestStatus& aStatus) { __UHEAP_MARK; TRequestStatus* status = &aStatus; iResult = EFalse; HBufC8* pkcs12Pwd = 0; // default value is NULL to avoid RVCT warning // C2874W: set may be used before being set CPBEncryptSet* set = 0; if (iKdf == 0) { CleanupStack::PushL(pkcs12Pwd); set = CPBEncryptSet::NewLC(*iPasswd, iCipher); } else { // if supply KDF, must also supply salt len and iteration count ASSERT(iSaltLenBytes != 0 && iIterCount != 0); CPBEncryptParms* ep = CPBEncryptParms::NewLC(); ep->SetCipher(iCipher); TInt saltLenBytes; TInt r = TLex8(*iSaltLenBytes).Val(saltLenBytes); ASSERT(r == KErrNone); ep->ResizeSaltL(saltLenBytes); TInt iterCount; r = TLex8(*iIterCount).Val(iterCount); ASSERT(r == KErrNone); ep->SetIterations(iterCount); CleanupStack::PushL((CBase*)0); CleanupStack::Pop((CBase*)0); if (*iKdf == _L8("PKCS#5")) { ep->SetKdf(CPBEncryptParms::EKdfPkcs5); set = CPBEncryptSet::NewL(*iPasswd, *ep); } else if (*iKdf == _L8("PKCS#12")) { pkcs12Pwd = PKCS12KDF::GeneratePasswordLC(*iPasswd); ep->SetKdf(CPBEncryptParms::EKdfPkcs12); set = CPBEncryptSet::NewL(*pkcs12Pwd, *ep); CleanupStack::Pop(pkcs12Pwd); } else User::Panic(_L("Unrec KDF"), 0); CleanupStack::PopAndDestroy(ep); // encryption could leak here, but for reservation above CleanupStack::PushL(pkcs12Pwd); CleanupStack::PushL(set); } CPBEncryptor* encryptor = set->NewEncryptLC(); HBufC8* ciphertextTemp = HBufC8::NewLC(encryptor->MaxFinalOutputLength(iInput->Length())); TPtr8 ciphertext = ciphertextTemp->Des(); encryptor->ProcessFinalL(*iInput, ciphertext); TBuf<128> newPwdTemp(*iPasswd); newPwdTemp.Append('a'); TBuf8<128> newPwdTemp8; TPBPassword newPassword(KNullDesC); if (pkcs12Pwd == 0) new(&newPassword) TPBPassword(newPwdTemp); else { HBufC8* newPwd = PKCS12KDF::GeneratePasswordLC(newPwdTemp); newPwdTemp8.Copy(*newPwd); new(&newPassword) TPBPassword(newPwdTemp8); CleanupStack::PopAndDestroy(newPwd); } set->ChangePasswordL(newPassword); //create a mem buffer store CBufStore* store = CBufStore::NewLC(100); RStoreWriteStream write; //write the encrypted master key to a stream TStreamId keyStreamId = write.CreateLC(*store); write << set->EncryptedMasterKey(); write.CommitL(); CleanupStack::PopAndDestroy(); //CreateLC() //write the encryption data to another stream TStreamId dataStreamId = write.CreateLC(*store); set->EncryptionData().ExternalizeL(write); write.CommitL(); CleanupStack::PopAndDestroy(); //CreateLC() //prepare to read the streams back in, creating a new TPBEncryptionData RStoreReadStream read; read.OpenLC(*store, dataStreamId); //read in Encryption data CPBEncryptionData* data = CPBEncryptionData::NewL(read); CleanupStack::PopAndDestroy(); //OpenLC() CleanupStack::PushL(data); //read in encrypted master key read.OpenLC(*store, keyStreamId); HBufC8* encryptedMasterKey = HBufC8::NewLC(read, 10000); //some large number //create a new set encryption class CPBEncryptSet* set2 = CPBEncryptSet::NewLC(*data, *encryptedMasterKey, newPassword); HBufC8* plaintextTemp = HBufC8::NewLC(ciphertext.Length()); TPtr8 plaintext = plaintextTemp->Des(); CPBDecryptor* decryptor = set2->NewDecryptLC(); decryptor->Process(ciphertext, plaintext); //this Mid call is due to get rid of the decrypted padding at the end if(plaintext.Mid(0,iInput->Length()) == *iInput) { iResult = ETrue; } CleanupStack::PopAndDestroy(decryptor); CleanupStack::PopAndDestroy(plaintextTemp); CleanupStack::PopAndDestroy(set2); CleanupStack::PopAndDestroy(encryptedMasterKey); CleanupStack::PopAndDestroy(1); //OpenLC CleanupStack::PopAndDestroy(data); CleanupStack::PopAndDestroy(store); CleanupStack::PopAndDestroy(ciphertextTemp); CleanupStack::PopAndDestroy(encryptor); CleanupStack::PopAndDestroy(set); CleanupStack::PopAndDestroy(pkcs12Pwd); User::RequestComplete(status, KErrNone); iActionState = CTestAction::EPostrequisite; __UHEAP_MARKEND; }