void CMultipleArray::SendAndRecvL(TInt aExtraSocksToJoin)
{
TRequestStatus stat;
TBuf8<50> Data;
// set up data buffers
HBufC8 * writebuf = HBufC8::NewMaxLC( iPacketSize[aExtraSocksToJoin] );
HBufC8 * readbuf = HBufC8::NewMaxLC( iPacketSize[aExtraSocksToJoin] );
TPtr8 ptrWritebuf = writebuf->Des();
TPtr8 ptrReadbuf = readbuf->Des();
TInt recvCount = 0;
// Send / Recv TCP
if (iProtocol[aExtraSocksToJoin] == KProtocolInetTcp)
{
for (TInt i = 0; i < iPackets[aExtraSocksToJoin]; i++)
{
iQoSStep->iQoSSuite->Log( _L("Sending TCP data, %d packets of %d bytes = %d"),
iPackets[aExtraSocksToJoin], iPacketSize[aExtraSocksToJoin], iPackets[aExtraSocksToJoin] * iPacketSize[aExtraSocksToJoin]);
// initialise data
Data.Format(_L8("TCP-packet:%d helloworld"),i);
ptrWritebuf.Repeat( Data );
// write data
GetSocketHandle(aExtraSocksToJoin)->Write(ptrWritebuf, stat);
User::WaitForRequest(stat);
if (stat!=KErrNone)
{
iQoSStep->iQoSSuite->Log(_L("Failed to write tcp data to destination: return value = <%d>"), stat);
User::Leave(stat.Int());
}
// read data
GetSocketHandle(aExtraSocksToJoin)->Read(ptrReadbuf, stat);
User::WaitForRequest(stat); //, TimerStatus);
if (stat!=KErrNone)
{
iQoSStep->iQoSSuite->Log(_L("Failed to read tcp data from destination: return value = <%d>"), stat);
User::Leave(stat.Int());
}
// compare the data
if (ptrWritebuf.Compare( ptrReadbuf ) != 0)
{
iQoSStep->iQoSSuite->Log(_L("Data written to and read from destination address do not match in size"));
// return Fail;
}
recvCount+=ptrReadbuf.Length();
}
CleanupStack::PopAndDestroy(2); // writebuf and readbuf
}
// Send / Recv UDP
if (iProtocol[aExtraSocksToJoin] == KProtocolInetUdp)
{
iQoSStep->iQoSSuite->Log( _L("Send Udp Data, %d packets of %d bytes = %d"),
iPackets[aExtraSocksToJoin], iPacketSize[aExtraSocksToJoin], iPackets[aExtraSocksToJoin] * iPacketSize[aExtraSocksToJoin]);
for (TInt i = 0; i < iPackets[aExtraSocksToJoin]; i++)
{
// initialise data
Data.Format(_L8("UDP-packet:%d helloworld"),i);
ptrWritebuf.Repeat( Data );
// write data
GetSocketHandle(aExtraSocksToJoin)->Send(ptrWritebuf, 0, stat);
User::WaitForRequest(stat);
if (stat!=KErrNone)
{
iQoSStep->iQoSSuite->Log(_L("Failed to write udp data to destination: return value = <%d>"), stat);
User::Leave(stat.Int());
}
GetSocketHandle(aExtraSocksToJoin)->Recv(ptrReadbuf, 0, stat);
User::WaitForRequest(stat);
if (stat!=KErrNone)
{
iQoSStep->iQoSSuite->Log(_L("Failed to read udp data from destination: return value = <%d>"), stat);
User::Leave(stat.Int());
}
// compare the data
if (ptrWritebuf.Compare( ptrReadbuf ) != 0 )
{
iQoSStep->iQoSSuite->Log(_L("Data written to and read from destination address do not match in sizevalue"));
// return Fail;
}
recvCount += ptrReadbuf.Length();
}
// get rid of the old buffers
CleanupStack::PopAndDestroy(2); // writebuf and readbuf
}
// check the total received (95 per cent is allowable for us)
if (recvCount*iPacketSize[aExtraSocksToJoin] < (0.95*(iPackets[aExtraSocksToJoin]*iPacketSize[aExtraSocksToJoin])))
{
iQoSStep->iQoSSuite->Log(_L("The total packets received is less than 95 per cent of the overall packets sent"));
// return Fail;
}
}
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;
}
void CRFC3984Encode::FragmentNaluL(
TDes8 & aBuffer,
TUint32 /*aTimeStamp*/,
TUint32 & aMarkerBit,
TInt & aNalCount,
TInt aStartIndex,
TInt aSize,
TUint16 aDON )
{
TInt index = 0;
TInt fragsPacketized = 0;
TUint8 headerByte = 0; // FU-A packet header byte (contains F, NRI, Type Fields)
TUint8 fragHeaderByte = 0;
TInt length = 0;
// maximum size of fragment, 4 is to cater for DON field in FU-B
TInt fragMaxSize = iMaxPacketSize - 4;
TInt fragSize = 0; // size of fragment
HBufC8 * pBuffer = NULL;
// index keeps track of indexes in the buffer
index = aStartIndex;
// length of data packetized, the code decrements this after each fragment is made
length = aSize;
while ( length > 0 )
{
// Actually should be based on (PacketizationMode == INTERLEAVED && fragsPacketized == 0)
TBool fuB = EFalse;
headerByte = aBuffer[aStartIndex] & ( 0x07 << 5 ); // Extracting F and NRI bits
// taking lower 5 type bits and putting into fragHeader
fragHeaderByte = aBuffer[aStartIndex] & 0x1f;
if ( fragsPacketized == 0 )
{
fragHeaderByte |= (0x1 << 7); // setting start bit
}
if ( length <= fragMaxSize )
{
fragHeaderByte |= ( 0x1 << 6 ); // setting end byte
aMarkerBit = 1;
}
else
{
aMarkerBit = 0;
}
if ( fragsPacketized == 0 ) // skipping payload header byte for FU packets
{
index += 1;
length -= 1;
}
fragSize = ( length > fragMaxSize ) ? fragMaxSize+2 : length+2; // 2 bytes for headers
if( !fuB )
{
headerByte |= PACKET_FU_A;
}
else
{
fragSize += 2; // for additional DON field
headerByte |= PACKET_FU_B;
}
// allocating memory for fragmented NAL unit
pBuffer = HBufC8::NewLC(fragSize);
TPtr8 pDes = pBuffer->Des(); //new (ELeave) TBuf8<size>;
pDes.Append( &headerByte, 1 ); // appending FU-A packet header byte
pDes.Append( &fragHeaderByte, 1 ); // appending Fragment header
if ( fuB )
{
// writing DON in network byte order
TUint16 val = ByteOrder::Swap16( aDON );
TUint8* ptrByte = reinterpret_cast<TUint8*>( &val );
pDes.Append( ptrByte, 2 );
}
TPtr8 pStart = aBuffer.MidTPtr( index ); // pStart contains the data pointer
if ( !fuB )
{
pDes.Append( pStart.Ptr(), fragSize-2 ); // copying data
index += Min( length, fragMaxSize );
length -= ( fragSize-2 );
}
else
{
// copying data, subtracting DON and header size from total size to copy
pDes.Append( pStart.Ptr( ), fragSize-4 );
index += Min( length, fragMaxSize );
length -= ( fragSize-4 );
}
// inserting into the payloadized NAL unit buffer for retreival
iPayloadizedBuffers.InsertL( pBuffer, iNalCount );
iNalCount++;
CleanupStack::Pop( pBuffer );
pBuffer = NULL; // ownership transferred
fragsPacketized++; // to count the number of fragments
} // end while()
aNalCount = iNalCount;
}
void eapol_am_wlan_authentication_symbian_c::read_configureL(
const TDesC& aDbName,
const TDesC& aTableName,
eap_config_string field,
const u32_t /*field_length*/,
eap_variable_data_c * const data)
{
EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
EAP_TRACE_DEBUG(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("eapol_am_wlan_authentication_symbian_c::read_configureL(): %s, this = 0x%08x => 0x%08x\n"),
(m_is_client == true) ? "client": "server",
this,
dynamic_cast<abs_eap_base_timer_c *>(this)));
EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, TRACE_FLAGS_DEFAULT, "returns: eapol_am_wlan_authentication_symbian_c::read_configureL()");
// Open database
RDbNamedDatabase db;
TInt error = db.Open(m_session, aDbName);
EAP_TRACE_DEBUG(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("eapol_am_wlan_authentication_symbian_c::read_configureL(): db.Open(), error = %d\n"),
error));
User::LeaveIfError(error);
CleanupClosePushL(db);
// Create a buffer for the ascii strings - initialised with the argument
HBufC8* asciibuf = HBufC8::NewLC(128);
TPtr8 asciiString = asciibuf->Des();
asciiString.Copy(reinterpret_cast<const unsigned char *>(field));
// Buffer for unicode parameter
HBufC* unicodebuf = HBufC::NewLC(128);
TPtr unicodeString = unicodebuf->Des();
// Convert to unicode
unicodeString.Copy(asciiString);
// Now do the database query
HBufC* buf = HBufC::NewLC(KMaxSqlQueryLength);
TPtr sqlStatement = buf->Des();
_LIT(KSQLQueryRow, "SELECT %S FROM %S");
sqlStatement.Format( KSQLQueryRow, &unicodeString, &aTableName );
RDbView view;
User::LeaveIfError(view.Prepare(db, TDbQuery(sqlStatement), TDbWindow::EUnlimited));
CleanupClosePushL(view);
User::LeaveIfError(view.EvaluateAll());
if (view.FirstL())
{
eap_status_e status(eap_status_process_general_error);
view.GetL();
switch (view.ColType(1))
{
case EDbColText:
{
unicodeString = view.ColDes(1);
// Convert to 8-bit
asciiString.Copy(unicodeString);
if (asciiString.Size() > 0)
{
status = data->set_copy_of_buffer(asciiString.Ptr(), asciiString.Size());
if (status != eap_status_ok)
{
User::Leave(m_am_tools->convert_eapol_error_to_am_error(
EAP_STATUS_RETURN(m_am_tools, status)));
}
}
else
{
// Empty field. Do nothing...data remains invalid and the stack knows what to do hopefully.
break;
}
}
break;
case EDbColUint32:
{
TUint value;
value = view.ColUint32(1);
status = data->set_copy_of_buffer((const unsigned char *) &value, sizeof(value));
if (status != eap_status_ok)
{
User::Leave(m_am_tools->convert_eapol_error_to_am_error(
EAP_STATUS_RETURN(m_am_tools, status)));
}
}
break;
default:
EAP_TRACE_DEBUG(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("ERROR: read_configureL: Unexpected column type.\n")));
User::Panic(_L("EAPOL"), 1);
}
}
else
{
// Could not find parameter
EAP_TRACE_DEBUG(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("ERROR: read_configureL: Could not find configuration parameter.\n")));
User::Leave(m_am_tools->convert_eapol_error_to_am_error(
EAP_STATUS_RETURN(m_am_tools, eap_status_not_found)));
}
// Close database
CleanupStack::PopAndDestroy(&view);
CleanupStack::PopAndDestroy(buf);
CleanupStack::PopAndDestroy(unicodebuf);
CleanupStack::PopAndDestroy(asciibuf);
CleanupStack::PopAndDestroy(&db);
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
}
EXPORT_C TInt CMTPTypeOpaqueData::NextWriteChunk(TPtr8& aChunk)
{
aChunk.Set(NULL, 0, 0);
return KErrNotReady;
}
/**
@SYMTestCaseID PDS-SQL-UT-4151
@SYMTestCaseDesc Measures the performance of inserting multiple records
into the Music Player MPX database. This test is based on
a real Music Player Harvesting use case
@SYMTestPriority Medium
@SYMTestActions Reads SQL transactions from a file and executes them.
Records the time for executing each statement
@SYMTestExpectedResults All statements should be executed without error and
performance measurements logged
@SYMDEF DEF142306
*/
void RunTest()
{
//Open the file with the sql statements
_LIT(KSqlFileName,"z:\\test\\t_sqlperformance4.sql");
RFile sqlFile;
TInt err = sqlFile.Open(TheFs, KSqlFileName, EFileRead);
TEST2(err, KErrNone);
TInt fileLen = 0;
err = sqlFile.Size(fileLen);
TEST2(err, KErrNone);
HBufC8* sqlBuf = HBufC8::New(fileLen);
TEST(sqlBuf != NULL);
TPtr8 sql = sqlBuf->Des();
err = sqlFile.Read(sql);
sqlFile.Close();
TEST2(err, KErrNone);
TEST2(sql.Length(), fileLen);
//Open main database
err = TheDbC.Open(TheDbFileName, &TheSqlConfigString);
TEST2(err, KErrNone);
TheTest.Printf(_L("Beginning INSERTS...\n"));
const TInt KRecordCount = 6544;
TInt recordCount = 0;
TInt insertCnt = 0;
TInt updateCnt = 0;
TInt selectCnt = 0;
TInt trnCnt = 0;
TInt totalTime = 0;
TInt insertTrnCnt = 0;
TInt updateTrnCnt = 0;
TInt selectTrnCnt = 0;
for(;sql.Length()>0;)
{
TInt eolPos = sql.Locate(TChar('\n'));
if(eolPos < 0)
{
break;//No more SQL statements
}
TInt stmtLength = eolPos;
while (stmtLength > 0 && (sql[stmtLength-1] == '\r'))
{
--stmtLength; //Reduce length to remove carriage return characters from the end of the statement string
}
TPtrC8 sqlStmt8(sql.Ptr(), stmtLength);
TPtrC8 ptr = sql.Mid(eolPos + 1);//"eolPos + 1" - first character after '\n'
sql.Set(const_cast <TUint8*> (ptr.Ptr()), ptr.Length(), ptr.Length());
++recordCount;
//Convert to 16 bit query string
TBuf<1024> query;
query.Copy(sqlStmt8);
//Execute the statement
TInt start = User::FastCounter();
err = TheDbC.Exec(query);
TInt end = User::FastCounter();
TEST(err >= 0);
//Get the execution time for that statement
TInt duration = GetDuration(start, end);
totalTime += duration;
if(query == KBeginTransaction)
{
TheTest.Printf(_L("Execute Statement - BEGIN: %d us\n"), duration);
}
else if(query == KCommitTransaction)
{
++trnCnt;
TheTest.Printf(_L("Execute Statement - COMMIT: %d us, Trn#%d, \"INSERT\" count: %d, \"UPDATE\" count: %d, \"SELECT\" count: %d\n"),
duration, trnCnt, insertTrnCnt, updateTrnCnt, selectTrnCnt);
insertTrnCnt = updateTrnCnt = selectTrnCnt = 0;
}
else
{
TPtrC queryType(query.Ptr(), 6);
TheTest.Printf(_L("Execute Statement - %S: %d us\n"),&queryType, duration);
if(queryType.FindF(_L("INSERT")) >= 0)
{
++insertCnt;
++insertTrnCnt;
}
else if(queryType.FindF(_L("UPDATE")) >= 0)
{
++updateCnt;
++updateTrnCnt;
}
else if(queryType.FindF(_L("SELECT")) >= 0)
{
++selectCnt;
++selectTrnCnt;
}
}
}
delete sqlBuf;
TheDbC.Close();
TheTest.Printf(_L("Total time to process Songs: %d us\n"), totalTime);
TheTest.Printf(_L("Transactions count: %d, \"INSERT\" count: %d, \"UPDATE\" count: %d, \"SELECT\" count: %d\n"),
trnCnt, insertCnt, updateCnt, selectCnt);
TEST2(recordCount, KRecordCount);
}
// ---------------------------------------------------------
// CNSmlCmdsBase::ProcessStatusCmdL
// Handles Status command from a server.
// ---------------------------------------------------------
EXPORT_C void CNSmlCmdsBase::ProcessStatusCmdL( SmlStatus_t* aStatus )
{
//msgRef
if ( !aStatus->msgRef )
{
return;
}
if ( !aStatus->msgRef->content )
{
return;
}
TPtr8 msgRef( (TUint8*) aStatus->msgRef->content, aStatus->msgRef->length, aStatus->msgRef->length );
TrimRightSpaceAndNull( msgRef );
if ( msgRef.Length() == 0 )
{
return;
}
//cmd
if ( !aStatus->cmd )
{
return;
}
if ( !aStatus->cmd->content )
{
return;
}
TPtr8 cmd( (TUint8*) aStatus->cmd->content, aStatus->cmd->length, aStatus->cmd->length );
TrimRightSpaceAndNull( cmd );
if ( cmd.Length() == 0 )
{
return;
}
//cmdRef
HBufC8* cmdRef = NULL;
if ( !aStatus->cmdRef )
{
if ( cmd == KNSmlAgentSyncHdr )
{
cmdRef = HBufC8::NewLC( KNSmlAgentSyncHdrCmdID.iTypeLength );
*cmdRef = KNSmlAgentSyncHdrCmdID;
}
else
{
return;
}
}
else
if ( !aStatus->cmdRef->content )
{
if ( cmd == KNSmlAgentSyncHdr )
{
cmdRef = HBufC8::NewLC( KNSmlAgentSyncHdrCmdID.iTypeLength );
*cmdRef = KNSmlAgentSyncHdrCmdID;
}
else
{
return;
}
}
else
{
TPtr8 cmdRefPtr ( (TUint8*) aStatus->cmdRef->content, aStatus->cmdRef->length, aStatus->cmdRef->length );
TrimRightSpaceAndNull( cmdRefPtr );
if ( cmdRefPtr.Length() == 0 )
{
if ( cmd == KNSmlAgentSyncHdr )
{
cmdRef = HBufC8::NewLC( KNSmlAgentSyncHdrCmdID.iTypeLength );
*cmdRef = KNSmlAgentSyncHdrCmdID;
}
else
{
return;
}
}
else
{
cmdRef = HBufC8::NewLC( cmdRefPtr.Length() );
*cmdRef = cmdRefPtr;
}
}
// Status code
TPtr8 statusCode( (TUint8*) aStatus->data->content, aStatus->data->length, aStatus->data->length );
TrimRightSpaceAndNull( statusCode );
if ( statusCode.Length() == 0 )
{
CleanupStack::PopAndDestroy(); //cmdRef
return;
}
TLex8 lexicalStatus( statusCode );
TInt numericStatus;
if ( lexicalStatus.Val (numericStatus ) != KErrNone )
{
CleanupStack::PopAndDestroy(); //cmdRef
return;
}
TInt entryID = 0;
TBool statusIsMatching;
statusIsMatching = iResponseController->MatchStatusElement( msgRef, *cmdRef , numericStatus, entryID );
if ( !statusIsMatching )
{
}
else
{
// chal element is stored for later use
if ( aStatus->chal )
{
if ( aStatus->chal->meta )
{
if ( aStatus->chal->meta->content && aStatus->chal->meta->contentType == SML_PCDATA_EXTENSION && aStatus->chal->meta->extension == SML_EXT_METINF )
{
SmlMetInfMetInf_t* metInf;
metInf = (SmlMetInfMetInf_t*) aStatus->chal->meta->content;
if ( metInf->type )
{
if ( metInf->type->content )
{
TPtr8 chalType( (TUint8*) metInf->type->content, metInf->type->length, metInf->type->length );
TrimRightSpaceAndNull( chalType );
if ( chalType.Length() > 0 )
{
iResponseController->SetChalTypeL( entryID, chalType );
}
}
}
if ( metInf->format )
{
if ( metInf->format->content )
{
TPtr8 chalFormat( (TUint8*) metInf->format->content, metInf->format->length, metInf->format->length );
TrimRightSpaceAndNull( chalFormat );
if ( chalFormat.Length() > 0 )
{
iResponseController->SetChalFormatL( entryID, chalFormat );
}
else
{
iResponseController->SetChalFormatL( entryID, KNSmlAgentChrFormat );
}
}
else
{
iResponseController->SetChalFormatL( entryID, KNSmlAgentChrFormat );
}
}
else
{
iResponseController->SetChalFormatL( entryID, KNSmlAgentChrFormat );
}
if ( metInf->nextnonce )
{
if ( metInf->nextnonce->content )
{
TPtr8 chalNextNonce( (TUint8*) metInf->nextnonce->content, metInf->nextnonce->length, metInf->nextnonce->length );
TrimRightSpaceAndNull( chalNextNonce );
if ( chalNextNonce.Length() > 0 )
{
iResponseController->SetChalNextNonceL( entryID, chalNextNonce );
}
}
}
}
}
}
}
CleanupStack::PopAndDestroy(); //cmdRef
if ( statusIsMatching )
{
iAgent->CheckServerStatusCodeL( entryID );
}
}
void CIkev1Dialog::StoreUserNameL(TPtr8 aUserName)
{
/*--------------------------------------------------------------------
*
* Store specified user name into cache file (used as init value in
* the next user name specific dialog).
* User name shall be encrypted (DES) before stored into cache file.
*
*---------------------------------------------------------------------*/
if (aUserName.Length() == 0)
{
User::Leave(KErrArgument);
}
//
// Allocate buffer for file header and encrypted key
//
HBufC8* HeaderBfr = HBufC8::NewLC(aUserName.Length() + sizeof(TUserNameFileHdr) + 32);
TUserNameFileHdr* FileHeader = (TUserNameFileHdr*)HeaderBfr->Ptr();
//
// Get random data values for salt and IV.
//
TPtr8 ptr((TUint8*)FileHeader, sizeof(TUserNameFileHdr));
ptr.SetLength(sizeof(TUserNameFileHdr));
TRandom::RandomL(ptr);
FileHeader->iFileId = USER_NAME_FILE_ID;
//
// Build encryption key from just created salt data and fixed
// secret passphrase using MD5 hash
//
TBuf8<16> EncryptionKey;
TPtr8 SaltPtr((TUint8*)FileHeader->iSalt, 8, 8);
User::LeaveIfError(CIkev1Dialog::BuildEncryptionKey(SaltPtr, EncryptionKey));
//
// Encrypt user name data with just created key.
// Because DES is used as encryption algorithm, the eight first
// octets of created encryption octets is used as encryption key.
//
TInt EncrLth = 0;
EncrLth = SymmetricCipherL((TUint8*)aUserName.Ptr(),
((TUint8*)FileHeader + sizeof(TUserNameFileHdr)),
aUserName.Length(), FileHeader->iIV, (TUint8*)EncryptionKey.Ptr(), ETrue);
if ( EncrLth )
{
//
// Write encrypted data into user name file
//
RFile NameFile;
TBuf<128> Ppath;
User::LeaveIfError(iFs.PrivatePath(Ppath));
Ppath.Append(USER_NAME_CACHE_FILE);
TInt err = iFs.CreatePrivatePath(EDriveC);
if (err != KErrNone &&
err != KErrAlreadyExists)
{
User::Leave(err);
}
User::LeaveIfError(NameFile.Replace(iFs, Ppath, EFileShareAny|EFileWrite));
TPtrC8 EncryptedData((TUint8*)FileHeader, sizeof(TUserNameFileHdr) + EncrLth);
NameFile.Write(EncryptedData);
NameFile.Close();
}
CleanupStack::PopAndDestroy(); // Delete encryption buffer
}
/**
Called when the INIT property is changed and once on the construction of the object. Extracts
the message from the INIT property, notifies both the observer by calling the
MLbsSuplPushRecObserver::OnSuplInit function and the sender by setting the ACK property.
Then it resubscribes for the INIT property to listen for next messages.
@see CSuplPushImpl
@see MLbsSuplPushRecObserver::OnSuplInit
@see CActive::RunL
*/
void CLbsSuplPushRecChannel::RunL()
{
LBSLOG(ELogP1, "CLbsSuplPushRecChannel::RunL() Begin\n");
if(iStatus==KErrNone)
{
iInitProperty.Subscribe(iStatus);
SetActive();
TPckgBuf<TInt> length;
TInt err = RProperty::Get(iPropOwnerSecureId, iInitPropKey, length);
//The INIT propery has been defined but not set yet.
if(err==KErrNone && length.Length()==0)
{
LBSLOG(ELogP1, "CLbsSuplPushRecChannel::RunL() - err==KErrNone && length.Length()==0 End\n");
return;
}
//Can't do anything here, just resubscribe
if(err!=KErrOverflow || length()<=0)
{
//The property must be set in the correct value.
__ASSERT_DEBUG(0, User::Invariant());
LBSLOG(ELogP1, "CLbsSuplPushRecChannel::RunL() - err!=KErrOverflow || length()<=0 End\n");
return;
}
TInt len = length() + 2*sizeof(TInt);
HBufC8* msg = HBufC8::New(len);
//Not enough memory to handle the message, just resubscribe
if(msg==0)
{
LBSLOG(ELogP1, "CLbsSuplPushRecChannel::RunL() - msg==0 End\n");
return;
}
TPtr8 ptr = msg->Des();
err = RProperty::Get(iPropOwnerSecureId, iInitPropKey, ptr);
if(err!=KErrNone || ptr.Length()!=len)
{
delete msg;
//Unexpected environment error or the length of the message is not equal the length declared in
//the header.
__ASSERT_DEBUG(0, User::Invariant());
LBSLOG(ELogP1,
"CLbsSuplPushRecChannel::RunL() RProperty::Get(iPropOwnerSecureId, iInitPropKey, ptr)|| ptr.Length()!=len End\n");
return;
}
TPckgBuf<TInt> reqId;
reqId.Copy(msg->Mid(sizeof(TInt), sizeof(TInt)));
if(reqId()<=0)
{
delete msg;
//Message is corrupted, the reqId must be > 0.
__ASSERT_DEBUG(0, User::Invariant());
LBSLOG(ELogP1, "CLbsSuplPushRecChannel::RunL() - reqId()<=0 End\n");
return;
}
TInt ackId = 0;
err = RProperty::Get(iPropOwnerSecureId, iAckPropKey, ackId);
if(err!=KErrNone || ackId<0)
{
delete msg;
if(ackId<0)
{
RProperty::Set(iPropOwnerSecureId, iAckPropKey, 0);
}
//Unexpected environment error or wrong ackId, it must be > 0.
__ASSERT_DEBUG(0, User::Invariant());
LBSLOG(ELogP1,
"CLbsSuplPushRecChannel::RunL() - RProperty::Get(iPropOwnerSecureId, iAckPropKey, ackId)!=KErrNone || ackId<0 End\n");
return;
}
//We notify the observer only if message was not delivered before
if(ackId!=reqId())
{
TLbsSuplPushRequestId reqIdUnsgn = reqId();
TPtrC8 msgPtr = msg->Right(length());
err = RProperty::Set(iPropOwnerSecureId, iAckPropKey, reqId());
//Unexpected environment error.
__ASSERT_DEBUG(err==KErrNone, User::Invariant());
iObserver.OnSuplInit(iChannel, reqIdUnsgn , msgPtr);
LBSLOG(ELogP9, "<-S MLbsSuplPushRecObserver::OnSuplInit() SuplPush\n");
LBSLOG2(ELogP9, " > TLbsSuplPushChannel aChannel = %d\n", iChannel);
LBSLOG2(ELogP9, " > TLbsSuplPushRequestId aReqId = %d\n", reqIdUnsgn);
}
delete msg;
}
else
{
iInitProperty.Subscribe(iStatus);
SetActive();
}
LBSLOG(ELogP1, "CLbsSuplPushRecChannel::RunL() End\n");
}
//
// Completion callback.
//
void CIoqueueCallback::RunL()
{
pj_ioqueue_t *ioq = ioqueue_;
Type cur_type = type_;
type_ = TYPE_NONE;
if (cur_type == TYPE_READ) {
//
// Completion of asynchronous RecvFrom()
//
/* Clear op_key (save it to temp variable first!) */
pj_ioqueue_op_key_t *op_key = pending_data_.read_.op_key_;
pending_data_.read_.op_key_ = NULL;
// Handle failure condition
if (iStatus != KErrNone) {
if (cb_.on_read_complete) {
cb_.on_read_complete( key_, op_key,
-PJ_RETURN_OS_ERROR(iStatus.Int()));
}
return;
}
HandleReadCompletion();
/* Call callback */
if (cb_.on_read_complete) {
cb_.on_read_complete(key_, op_key, aBufferPtr_.Length());
}
} else if (cur_type == TYPE_ACCEPT) {
//
// Completion of asynchronous Accept()
//
/* Clear op_key (save it to temp variable first!) */
pj_ioqueue_op_key_t *op_key = pending_data_.read_.op_key_;
pending_data_.read_.op_key_ = NULL;
// Handle failure condition
if (iStatus != KErrNone) {
if (pending_data_.accept_.new_sock_)
*pending_data_.accept_.new_sock_ = PJ_INVALID_SOCKET;
if (cb_.on_accept_complete) {
cb_.on_accept_complete( key_, op_key, PJ_INVALID_SOCKET,
-PJ_RETURN_OS_ERROR(iStatus.Int()));
}
return;
}
CPjSocket *pjNewSock = HandleAcceptCompletion();
// Call callback.
if (cb_.on_accept_complete) {
cb_.on_accept_complete( key_, op_key, (pj_sock_t)pjNewSock,
PJ_SUCCESS);
}
}
ioq->eventCount++;
}
///////////////////////////////////////////////////////////////////
// GetStartPositionOfLogElem
// This function calculates the start position of a log element.
// As input parameter it has the position of the first byte
// after the element.
///////////////////////////////////////////////////////////////////
TInt CEventViewer::GetStartPositionOfLogElem(TUint32 aPositionOfLogElemEnd,
TUint32* aPositionOfLogElem)
{
// Set base for the most recent log element trailer
TPtr8 logFileBuf (iLogFileBuf->Des()); // Log file in memory
TUint32 logElemTrailerPos = aPositionOfLogElemEnd - LOG_ELEM_TRAILER_LTH;
if (iWrappingOccured && logElemTrailerPos <= iCurrFileHeader.iPositionOfNextFree)
{
return KErrNotFound;
}
TPtr8 elemTrailer (const_cast<TUint8*>(logFileBuf.Ptr())+ logElemTrailerPos, // Data ptr
LOG_ELEM_TRAILER_LTH, // Data length
LOG_ELEM_TRAILER_LTH); // Max length
// Convert the TPtr8 parameter to TUint8* format
TLogElemTrailer* elemTrailerPtr = (TLogElemTrailer*) elemTrailer.Ptr();
// Copy the packet format trailer parameters to unpacked object
iLogElemTrailer.iEndMark1 = elemTrailerPtr->GetEndMark1();
iLogElemTrailer.iEndMark2 = elemTrailerPtr->GetEndMark2();
iLogElemTrailer.iEventLength = elemTrailerPtr->GetEventLength();
// Check the validity of trailer
if (iLogElemTrailer.iEndMark1 != END_MARK_1
||
iLogElemTrailer.iEndMark2 != END_MARK_2
||
iLogElemTrailer.iEventLength > aPositionOfLogElemEnd +
EVENTLOG_FILE_HEADER_LTH)
{
return KErrGeneral;
}
// Set position for the current log element
TUint32 logElemPos = aPositionOfLogElemEnd - iLogElemTrailer.iEventLength;
if (iWrappingOccured && logElemPos < iCurrFileHeader.iPositionOfNextFree)
{
return KErrNotFound;
}
TPtr8 logElem (const_cast<TUint8*>(logFileBuf.Ptr())+ logElemPos, // Data ptr
iLogElemTrailer.iEventLength, // Data length
iLogElemTrailer.iEventLength);
// Convert the TPtr8 parameter to TUint8* format
TLogElem* logElemPtr = (TLogElem*) logElem.Ptr();
// Copy the event number and event length parameters
// from packed format log element to unpacked object
iUnpackedLogElem.iEventLength = logElemPtr->GetEventLength();
iUnpackedLogElem.iEventNumber = logElemPtr->GetEventNumber();
// Verify the extracted data
if (iUnpackedLogElem.iEventNumber > iCurrFileHeader.iCurrEventNumber
||
iUnpackedLogElem.iEventLength != iLogElemTrailer.iEventLength)
{
return KErrGeneral;
}
*aPositionOfLogElem = logElemPos;
return KErrNone;
}
// -----------------------------------------------------------------------------
// CBSBrandHandler::ReadStreamL()
// -----------------------------------------------------------------------------
//
MBSElement* CBSBrandHandler::ReadStreamL( const TDesC8& aId, RFileReadStream& aStream,
TBool aAllowEmptyId /* = EFalse */ )
{
TRACE( T_LIT( "CBSBrandHandler::ReadStreamL BEGIN"));
TBSElementType type = (TBSElementType)aStream.ReadInt16L();
MBSElement* returnValue = NULL;
TInt idSize = aStream.ReadInt16L();
HBufC8* elementId = HBufC8::NewLC( idSize );
TPtr8 elementIdPtr = elementId->Des();
if( idSize == 0 && aAllowEmptyId )
{
// we don't read empty ID
}
else
{
aStream.ReadL( elementIdPtr, idSize );
elementIdPtr.SetLength( idSize );// Set length
}
TBool match = EFalse;
if( aAllowEmptyId || ( 0 == elementIdPtr.Compare( aId ) ) )
{
match = ETrue;
}
TPtrC8 idPtrC( *elementId );// idPtrC creation moved here so it will be updated correctly.
if( elementId->Length() == 0 )
{
CleanupStack::PopAndDestroy( elementId );
elementId = NULL;
idPtrC.Set( KNullDesC8 );
}
switch( type )
{
case EBSInt:
{
TInt intData = aStream.ReadInt16L();
TRACE( T_LIT( "CBSBrandHandler::ReadStreamL type INT"));
if( match )
{
// Codescanner warning: neglected to put variable on cleanup stack (id:35)
// This method cannot leave after this line
returnValue = BSElementFactory::CreateBSElementL( idPtrC, // CSI: 35 # See above
EBSInt,
intData );
}
break;
}
case EBSText:
case EBSFile: // flow through
{
TInt textSize = aStream.ReadInt16L();
HBufC* textData = HBufC::NewLC( textSize );
TPtr textPtr = textData->Des();
aStream.ReadL( textPtr, textSize );
TRACE( T_LIT( "CBSBrandHandler::ReadStreamL type TEXT/ FILE"));
if( match )
{
// Codescanner warning: neglected to put variable on cleanup stack (id:35)
// This method cannot leave after this line
returnValue = BSElementFactory::CreateBSElementL( idPtrC, // CSI: 35 # See above
type,
*textData );
}
CleanupStack::PopAndDestroy( textData );
break;
}
case EBSList:
{
RBSObjOwningPtrArray<MBSElement> listData;
CleanupClosePushL( listData );
TInt count = aStream.ReadInt16L();
for( TInt i = 0; i < count; i++ )
{
MBSElement* subElement = ReadStreamL( KNullDesC8, aStream, ETrue );
CleanupDeletePushL( subElement );
listData.AppendL( subElement );
CleanupStack::Pop(); // subElement
}
if( match )
{
// Codescanner warning: neglected to put variable on cleanup stack (id:35)
// This method cannot leave after this line
returnValue = BSElementFactory::CreateBSElementL( idPtrC, // CSI: 35 # See above
EBSList,
listData );
}
CleanupStack::Pop(); // listData
break;
}
case EBSBuffer:
{
TInt bufferSize = aStream.ReadInt16L();
HBufC8* buffeData = HBufC8::NewLC( bufferSize );
TPtr8 bufferPtr = buffeData->Des();
aStream.ReadL( bufferPtr, bufferSize );
if( match )
{
// Codescanner warning: neglected to put variable on cleanup stack (id:35)
// This method cannot leave after this line
returnValue = BSElementFactory::CreateBSElementL( idPtrC, // CSI: 35 # See above
EBSBuffer,
*buffeData );
}
CleanupStack::PopAndDestroy( buffeData );
break;
}
case EBSBitmap:
{
TInt length = aStream.ReadInt16L();
HBufC8* fileId = HBufC8::NewLC( length );
TPtr8 fileIdPtr = fileId->Des();
aStream.ReadL( fileIdPtr, length );
TInt bitmapId = aStream.ReadInt16L();
TInt maskId = aStream.ReadInt16L();
TInt skinId = aStream.ReadInt16L();
TInt skinMaskId = aStream.ReadInt16L();
TRACE( T_LIT( "CBSBrandHandler::ReadStreamL type BITMAP .. bitmap ID is [%d]"), bitmapId);
if( match )
{
CBSBitmap* bitmap = CBSBitmap::NewLC( bitmapId,
maskId,
skinId,
skinMaskId,
fileIdPtr );
// Codescanner warning: neglected to put variable on cleanup stack (id:35)
// This method cannot leave after this line
returnValue = BSElementFactory::CreateBSElementL( idPtrC, // CSI: 35 # See above
EBSBitmap,
bitmap );
CleanupStack::Pop( bitmap );
}
CleanupStack::PopAndDestroy( fileId );
break;
}
default:
{
TRACE( T_LIT( "CBSBrandHandler::ReadStreamL type DEFAULT : corrupt"));
User::Leave( KErrCorrupt );
break;
}
}
if( elementId )
{
CleanupStack::PopAndDestroy( elementId );
}
TRACE( T_LIT( "CBSBrandHandler::ReadStreamL END"));
return returnValue;
}
EXPORT_C TInt CHTTPResponse::LocateField(THttpHeaderField aField,
TInt aStartIndex) const
{
// Content-Type is a special case; it appears to always be at the first
// byte of the header, and doesn't have any encoding of the field name -
// just straight into the Field Value at byte 0. This is an assumption
// however, since the WSP spec is not explicit - could it possibly be just
// the NWSS GW's implementation of WSP that does this?
if ( (aStartIndex == 0) && (aField == EHttpContentType) )
{
return aStartIndex; // the content-type field value position - ie. 0
}
// Deal with other Field Names, (Possibly including Content-Type if the
// start index is offset into the header? Note that this is not likely to
// occur though, with the abbreviated encoding.)
TInt respLength = iResponse->Length();
TPtr8 respChars = iResponse->Des();
for (TInt index = aStartIndex; index < respLength; index++)
{
// Examine the byte at this position in the header
TUint8 byteCode = respChars[index];
// Expect byteCode to be a Field Name code (unless the search is at
// position zero, which has a missing content-type field name). Check
// for the search field, remembering to clear the top bit
if ( ( (byteCode & 0x7f) == aField) && (index != 0) )
{
// Got it - return the next position to locate the field value,
// checking for potential overrun
if (index < respLength - 1)
{
// Advance 1 to the header field value
++index;
return index;
}
else
{
return KErrNotFound;
}
}
else
{
// Check that we aren't dealing with the Content-Type field
// (expected at position 0), since it doesn't use a field type
if (index != 0)
{
// WSP Spec Section 8.4.1.1 - Field Names
//
// If the byte is an alphanumeric, then it must be a field name that doesn't have
// a WSP encoding. In this circumstance, we can't handle the field, and must
// therefore skip over it
if ((byteCode >= 32) && (byteCode <= 127))
{
// Hit the start of a Header Name string - this will be assumed
// continuous until the NUL is found or until the end
// of the header is hit (which would be an error)
while ( (respChars[index] != 0) && (index < respLength - 1) )
++index;
}
// WSP Spec Section 8.4.1.2 - Field Values
//
// Now examine the field value by advancing one place. If that advance takes us off
// the end of the buffer, then (a) the WSP is invalid, and (b) the field is not found!
++index;
if (index == respLength)
return KErrNotFound;
}
// Read the next byte at this position in the header
byteCode = respChars[index];
// Codes 0-30 represent that number of following data octets, so
// they should be skipped
if (byteCode == 0) // 0 data octets follow !???? : (Strange but true)
{
// __DEBUGGER();
}
else if (byteCode <= 30)
{
index += byteCode;
}
else
{
// Code 31 indicates that the following bytes make a UIntVar,
// which indicates the number of data octets after it. The
// UIntVar itself could be composed of upto 5 bytes
if (byteCode == 31)
{
// Copy a full 5 bytes from the header - note that actually
// fewer might have been used; the UIntVar to Int
// converter function returns the exact number that were
// used.
TInt value = 0;
TInt consumed = ParseUIntVar(respChars.Mid(index + 1), value);
if( consumed < KErrNone )
return KErrCorrupt;
// Advance to the last byte of data in this header
index += consumed + value;
}
else
// Codes 32-127 are alphanumerics representing a text
// string, up to a NUL termination
if (byteCode <= 127)
// Hit the start of a string - this will be assumed
// continuous until the NUL is found or until the end
// of the header is hit (which would be an error)
while ( (respChars[index] != 0) && (index < respLength - 1) )
++index;
}
}
}
// This return only occurs if the search ran off the end of the header
return KErrNotFound;
}
EXPORT_C TBool CHTTPResponse::CharSet(TPtrC8& aDesc) const
{
// __LOG_ENTER(_L("CHTTPResponse::CharSet"));
// Find the byte index in the header for the content type value
TInt index = LocateField(EHttpContentType);
TUint8 byteCode = 0;
TInt paramByteCode = KErrNotFound;
TInt valueByteCode1 = KErrNotFound;
TInt charsetCode = 0;
// Read the byte code, unless KErrNotFound was returned
if (index != KErrNotFound)
{
TPtr8 respChars = iResponse->Des();
TInt respLength = iResponse->Length();
// If the byteCode is in the range 0-30 then a range of bytes is
// indicated: the following byte gives the content type and the
// remainder are arranged as a series of parameter attribute-value
// pairs. This method checks for the presence of a 'charset' parameter.
byteCode = respChars[index];
// __LOG1(_L("CHTTPResponse::CharSet : found bytecode = %d"), byteCode);
// Check valid range ... note that a range of zero could not contain a charset
// parameter anyway, so exclude it...
if ((byteCode > 0) && (byteCode <= 30))
{
// Check for overrun... if this occurs it should be an error. Note that
// corruption _could_ occur in this response buffer - some gateways, which
// don't return error decks (e.g. AnyTime GW) send a response buffer 1 byte
// long, containing only the value 0x01 - which is invalid WSP.
// Be conservative and safe here - we can't overrun. Use the value of byte-
// -Code (which should be the WSP encoding of how many bytes follow), or the
// total length of the response - whichever is smaller.
if (index + byteCode < respLength)
{
// e,g, header to illustrate use of offsets in this code:
// 03 94 81 84 : Content-Type: application/vnd.wap.wmlc; charset=iso-8859-1
// +0 +1 +2 +3 : 03 = no. bytes in Content-Type header
// : 94 = 14 | 80 = application/vnd.wap.wmlc
// : 81 = 01 | 80 = Charset parameter
// : 84 = 04 | 80 = iso-8859-1
paramByteCode = respChars[index + 2];
if ((paramByteCode & 0x7f) == EHttpCharset)
{
// We have a charset
paramByteCode &= 0x7f;
valueByteCode1 = respChars[index + 3];
if (valueByteCode1 & 0x80)
{
// A short one-byte value
charsetCode = valueByteCode1 & 0x7f;
}
else
{
// A multibyte value
ExtractMultiOctetInteger(charsetCode,
respChars.Mid(index + 3));
}
}
}
else
{
index = KErrNotFound;
}
}
}
// If a parameter-value pair was found, determine whether it encodes a
// charset
if ( (index != KErrNotFound) && (paramByteCode == EHttpCharset) )
{
// Look up the value from the charset table.
const TText8* chset;
chset = CharSet(charsetCode);
// Convert the charset string to the supplied descriptor
if (chset)
aDesc.Set(TPtrC8(chset));
else
index = KErrNotFound; // We've found a charset but we don't recognise it
}
else // Either no content-type header (hence no charset) or a content-type
// header with a parameter other than charset
{
index = KErrNotFound;
}
// __LOG1(_L("CHTTPResponse::CharSet : CharSet = %S"), &aDesc);
// __LOG_RETURN;
return (index !=KErrNotFound);
}
/**
* Encodes the information element into its raw format. (no IE id)
*
* @param aPtr the buffer to be used which is to contain the data
* @param TBool boolean to indicate if it is for serialisation or encoding
* @leave KErrCorrupt If the melody has not been defined.
*/
void CEmsSoundIE::EncodeBodyL(TPtr8 aPtr, TBool) const
{
__ASSERT_ALWAYS(iMelody!=NULL, User::Leave(KErrCorrupt));
aPtr.Append(*iMelody);
}
TVerdict CClientFinishedStep::doTestStepL()
{
INFO_PRINTF1(_L("Calling TLS Provider to fetch cipher suites."));
// first we have to retrieve the available cipher suites
TInt err = GetCipherSuitesL();
if (err != KErrNone)
{
INFO_PRINTF2(_L("Failed! Cannot retrieve supported cipher suites! (Error %d)"),
err);
SetTestStepResult(EFail);
return TestStepResult();
}
// verifies certificate if is not a PSK cipher suite
if( !UsePsk() )
{
// we have to verify the server certificate, to supply the certificate
// and its parameters to the TLS provider.
INFO_PRINTF1(_L("Calling TLS Provider to verify server certificate."));
CX509Certificate* cert = NULL;
err = VerifyServerCertificateL(cert);
delete cert;
// make sure it completed sucessfully.
if (err != KErrNone)
{
INFO_PRINTF2(_L("Failed! Server Certificate did not verify correctly! (Error %d)"),
err);
SetTestStepResult(EFail);
return TestStepResult();
}
}
INFO_PRINTF1(_L("Creating TLS Session."));
// now, create a session with the parameters set in the preamble
err = CreateSessionL();
// ensure we succeeded
if (err != KErrNone)
{
INFO_PRINTF2(_L("Failed! Create Session failed! (Error %d)"), err);
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("Calling TLS session key exchange."));
HBufC8* keyExMessage = NULL;
err = ClientKeyExchange(keyExMessage);
if (err != KErrNone)
{
INFO_PRINTF2(_L("Failed! Key exchange failed! (Error %d)"), err);
delete keyExMessage;
SetTestStepResult(EFail);
return TestStepResult();
}
INFO_PRINTF1(_L("Deriving premaster secret."));
// derive the premaster secret from the key exchange method
CleanupStack::PushL(keyExMessage);
HBufC8* premaster = DerivePreMasterSecretL(*keyExMessage);
CleanupStack::PopAndDestroy(keyExMessage);
INFO_PRINTF1(_L("Deriving master secret."));
// compute the master secret from the premaster.
CleanupStack::PushL(premaster);
HBufC8* master = ComputeMasterSecretL(*premaster);
CleanupStack::PopAndDestroy(premaster);
CleanupStack::PushL(master);
// create a block of random data to represent our handshake messages,
// and create hash objects from it.
HBufC8* handshake = HBufC8::NewLC(1024); // totally arbitary length...
TPtr8 handshakeBuf = handshake->Des();
handshakeBuf.SetLength(1024);
TRandom::RandomL(handshakeBuf);
CMessageDigest* handshakeSha = CMessageDigestFactory::NewDigestLC(CMessageDigest::ESHA1);
CMessageDigest* handshakeMd = CMessageDigestFactory::NewDigestLC(CMessageDigest::EMD5);
handshakeSha->Update(handshakeBuf);
handshakeMd->Update(handshakeBuf);
INFO_PRINTF1(_L("Computing our test finished message."));
// now, calculate our idea of what the finished message should be.
HBufC8* ourFinished = ComputeFinishedMessageL(handshakeSha, handshakeMd, *master, ETrue);
CleanupStack::PushL(ourFinished);
INFO_PRINTF1(_L("Calling TLS Session to generate client finished message."));
// ask TLS provider for our finished message and compare the two.
HBufC8* theirFinished = NULL;
err = GenerateClientFinishedL(handshakeSha, handshakeMd, theirFinished);
if (err != KErrNone || *theirFinished != *ourFinished)
{
INFO_PRINTF2(_L("Failed! Either client finished message generation failed (Error %d), or finished message malformed!"),
err);
SetTestStepResult(EFail);
}
else
{
INFO_PRINTF1(_L("Test passed."));
SetTestStepResult(EPass);
}
delete theirFinished;
CleanupStack::PopAndDestroy(5, master); // handshake, handshakeSha, handshakeMd, ourFinished
return TestStepResult();
}
/**
* Encodes the information element into its raw format. (no IE id)
*
* @param aPtr the buffer to be used which is to contain the data
* @param TBool boolean to indicate if it is for serialisation or encoding
*/
void CEmsPreDefSoundIE::EncodeBodyL(TPtr8 aPtr, TBool) const
{
aPtr.Append(static_cast<TUint8>(iSound));
}
TVerdict CHmacIncrementalHmacWithResetStep::doTestStepL()
{
if (TestStepResult()==EPass)
{
//Assume faliure, unless all is successful
SetTestStepResult(EFail);
INFO_PRINTF1(_L("*** Hmac - Incremental Hash with Reset ***"));
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
TVariantPtrC algorithmUid;
TVariantPtrC operationModeUid;
TPtrC sourcePath;
TPtrC expectedHash;
TPtrC encryptKey;
TVariantPtrC keyType;
//Extract the Test Case ID parameter from the specified INI file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigOperationMode,operationModeUid) ||
!GetStringFromConfig(ConfigSection(),KConfigSourcePath,sourcePath) ||
!GetStringFromConfig(ConfigSection(),KConfigExHashHmacValue,expectedHash) ||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKey,encryptKey) ||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKeyType,keyType))
{
ERR_PRINTF1(_L("** Error: Failed to Load Configuration Parameters **"));
SetTestStepResult(EFail);
}
else
{
//Create a pointer for the Hmac Implementation Object
CHash* hmacImpl = NULL;
//Convert encryption key to an 8 Bit Descriptor
HBufC8* keyStr = HBufC8::NewLC(encryptKey.Length());
TPtr8 keyStrPtr = keyStr->Des();
keyStrPtr.Copy(encryptKey);
//Create an new CryptoParams object to encapsulate the key type and secret key string
CCryptoParams* keyParams = CCryptoParams::NewL();
CleanupStack::PushL(keyParams);
keyParams->AddL(*keyStr,keyType);
//Create Key Object
TKeyProperty keyProperty;
CKey* key=CKey::NewL(keyProperty,*keyParams);
CleanupStack::PushL(key);
//Retrieve a Hmac Factory Object
TRAPD(err,CHashFactory::CreateHashL(hmacImpl,
algorithmUid,
operationModeUid,
key,
NULL));
if(hmacImpl && (err==KErrNone))
{
//Push the Hmac Implementation Object onto the Cleanup Stack
CleanupStack::PushL(hmacImpl);
RFs fsSession;
//Create a connection to the file server
err = fsSession.Connect();
if(err != KErrNone)
{
ERR_PRINTF2(_L("*** Error: File Server Connection - %d ***"), err);
SetTestStepResult(EFail);
}
else
{
RFile sourceFile;
CleanupClosePushL(sourceFile);
//Open the specified source file
err = sourceFile.Open(fsSession,sourcePath, EFileRead);
if(err != KErrNone)
{
ERR_PRINTF2(_L("*** Error: Opening Source File - %d ***"), err);
SetTestStepResult(EFail);
}
else
{
TInt sourceLength = 0;
TInt readPosition = 0;
TInt readIncrement = 0;
TBool hashComplete = EFalse;
TBool hashReset = EFalse;
TPtrC8 hashStr;
User::LeaveIfError(sourceFile.Size(sourceLength));
//Divide the file size into seperate incremental blocks to read
readIncrement = sourceLength/KDataReadBlocks;
do
{
//Create a heap based descriptor to store the data
HBufC8* sourceData = HBufC8::NewL(readIncrement);
CleanupStack::PushL(sourceData);
TPtr8 sourcePtr = sourceData->Des();
//Read in a block of data from the source file from the current position
err = sourceFile.Read(readPosition,sourcePtr,readIncrement);
//Update the read position by adding the number of bytes read
readPosition += readIncrement;
if(readPosition == readIncrement)
{
//Read in the first block from the data file into the Hmac implementation object
hmacImpl->Hash(*sourceData);
INFO_PRINTF2(_L("Intial Hmac - Bytes Read: %d"), readPosition);
}
else if(readPosition >= sourceLength)
{
//Reading in the final block, constructs the complete hash value and returns it within a TPtrC8
hashStr.Set(hmacImpl->Final(*sourceData));
//Sets the Complete Flag to ETrue in order to drop out of the loop
hashComplete = ETrue;
TInt totalRead = (readPosition - readIncrement) + (*sourceData).Length();
INFO_PRINTF2(_L("Final Hmac - Bytes Read: %d"),totalRead);
}
//If the read position is half the source length and the implementation
//object hasn't already been reset
else if((readPosition >= sourceLength/2) && (hashReset == EFalse))
{
INFO_PRINTF1(_L("Resetting Hmac Object..."));
hmacImpl->Reset();
//Sets the read position back to 0 inorder to restart the file read from the beginning
readPosition = 0;
hashReset = ETrue;
INFO_PRINTF2(_L("*** HMAC RESET - Bytes Read: %d ***"), readPosition);
}
else
{
//Update the message data within the Hmac object with the new block
hmacImpl->Update(*sourceData);
INFO_PRINTF2(_L("Hmac Update - Bytes Read: %d"), readPosition);
}
CleanupStack::PopAndDestroy(sourceData);
}while(hashComplete == EFalse);
//Create a NULL TCharacteristics pointer
const TCharacteristics* charsPtr(NULL);
//Retrieve the characteristics for the hash implementation object
TRAP_LOG(err, hmacImpl->GetCharacteristicsL(charsPtr));
//Static cast the characteristics to type THashCharacteristics
const THashCharacteristics* hashCharsPtr = static_cast<const THashCharacteristics*>(charsPtr);
//The hash output size is returned in Bits, divide by 8 to get the Byte size
TInt hashSize = hashCharsPtr->iOutputSize/8;
//Retrieve the final 8bit hash value and convert to 16bit
HBufC* hashData = HBufC::NewLC(hashSize);
TPtr hashPtr = hashData->Des();
hashPtr.Copy(hashStr);
//Take the 16bit descriptor and convert the string to hexadecimal
TVariantPtrC convertHash;
convertHash.Set(hashPtr);
HBufC* hmacResult = convertHash.HexStringLC();
INFO_PRINTF2(_L("*** Hashed Data: %S ***"),&*hmacResult);
INFO_PRINTF2(_L("*** Expected Hash: %S ***"),&expectedHash);
//If the returned hash value matches the expected hash, Pass the test
if(*hmacResult == expectedHash)
{
INFO_PRINTF1(_L("*** Hmac - Incremental Hash with Reset : PASS ***"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF2(_L("*** FAIL: Hashed and Expected Value Mismatch ***"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(hmacResult);
CleanupStack::PopAndDestroy(hashData);
}
//Cleanup the Source RFile
CleanupStack::PopAndDestroy();
}
fsSession.Close();
CleanupStack::PopAndDestroy(hmacImpl);
}
else
{
ERR_PRINTF2(_L("*** FAIL: Failed to Create Hmac Object - %d ***"), err);
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(key);
CleanupStack::PopAndDestroy(keyParams);
CleanupStack::PopAndDestroy(keyStr);
}
}
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
return TestStepResult();
}
TVerdict CHmacSetOperationModeCheckingStep::doTestStepL()
{
if (TestStepResult()==EPass)
{
//Assume faliure, unless all is successful
SetTestStepResult(EFail);
INFO_PRINTF1(_L("*** Hmac - Set Operation Mode Checking ***"));
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
TVariantPtrC algorithmUid;
TVariantPtrC operationModeUid;
TVariantPtrC secondOperationModeUid;
TPtrC sourcePath;
TPtrC expectedHash;
TPtrC expectedHmac;
TPtrC encryptKey;
TVariantPtrC keyType;
//Extract the Test Case ID parameter from the specified INI file
if(!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigOperationMode,operationModeUid) ||
!GetStringFromConfig(ConfigSection(),KConfigSecondOperationMode,secondOperationModeUid) ||
!GetStringFromConfig(ConfigSection(),KConfigSourcePath,sourcePath) ||
!GetStringFromConfig(ConfigSection(),KConfigExHashHmacValue,expectedHash) ||
!GetStringFromConfig(ConfigSection(),KConfigExSecondHashHmacValue,expectedHmac) ||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKey,encryptKey) ||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKeyType,keyType))
{
ERR_PRINTF1(_L("** Error: Failed to Load Configuration Parameters **"));
SetTestStepResult(EFail);
}
else
{
RFs fsSession;
//Create a connection to the file server
User::LeaveIfError(fsSession.Connect());
RFile sourceFile;
CleanupClosePushL(sourceFile);
//Open the specified source file
User::LeaveIfError(sourceFile.Open(fsSession,sourcePath, EFileRead));
TInt sourceLength = 0;
User::LeaveIfError(sourceFile.Size(sourceLength));
//Create a heap based descriptor to store the data
HBufC8* sourceData = HBufC8::NewL(sourceLength);
CleanupStack::PushL(sourceData);
TPtr8 sourcePtr = sourceData->Des();
sourceFile.Read(sourcePtr);
if(sourcePtr.Length() != sourceLength)
{
ERR_PRINTF1(_L("*** Error: Reading Source File ***"));
SetTestStepResult(EFail);
}
else
{
//Create a pointer for the Hash + Key (Hmac) Implementation Object
CHash* hashHmacImpl = NULL;
//Convert encryption key to an 8 Bit Descriptor
HBufC8* keyStr = HBufC8::NewLC(encryptKey.Length());
TPtr8 keyStrPtr = keyStr->Des();
keyStrPtr.Copy(encryptKey);
//Create an new CryptoParams object to encapsulate the invalid key type and key string
CCryptoParams* keyParams = CCryptoParams::NewL();
CleanupStack::PushL(keyParams);
keyParams->AddL(*keyStr,keyType);
//Create a valid CKey Object
TKeyProperty keyProperty;
CKey* key = CKey::NewL(keyProperty,*keyParams);
CleanupStack::PushL(key);
//Construct an initial hash object with NO key, Catching any possible Leaves
TRAPD(err,CHashFactory::CreateHashL(
hashHmacImpl,
algorithmUid,
operationModeUid,
NULL,
NULL));
if(hashHmacImpl && (err == KErrNone))
{
//Push the Implementation Object onto the Cleanup Stack
CleanupStack::PushL(hashHmacImpl);
//Create a NULL TCharacteristics pointer
const TCharacteristics* charsPtrA(NULL);
//Retrieve the characteristics for the hash implementation object
TRAP_LOG(err, hashHmacImpl->GetCharacteristicsL(charsPtrA));
//Static cast the characteristics to type THashCharacteristics
const THashCharacteristics* hashCharsPtrA = static_cast<const THashCharacteristics*>(charsPtrA);
//The hash output size is returned in Bits, divide by 8 to get the Byte size
TInt hashSize = hashCharsPtrA->iOutputSize/8;
//Retrieve the final 8bit hash value and convert to 16bit
HBufC* hashDataA = HBufC::NewLC(hashSize);
TPtr hashPtrA = hashDataA->Des();
hashPtrA.Copy(hashHmacImpl->Hash(*sourceData));
//Take the 16bit descriptor and convert the string to hexadecimal
TVariantPtrC convertHash;
convertHash.Set(hashPtrA);
HBufC* resultA = convertHash.HexStringLC();
INFO_PRINTF2(_L("*** Hashed Data: %S ***"),&*resultA);
INFO_PRINTF2(_L("*** Expected Hash: %S ***"),&expectedHash);
if(*resultA == expectedHash)
{
INFO_PRINTF1(_L("*** PRIMARY HASH VALID - STAGE 1 PASS ***"));
//Set the valid key within the Hmac Implementation Object
TRAP(err,hashHmacImpl->SetKeyL(*key));
if(err!=KErrNone)
{
ERR_PRINTF2(_L("*** ERROR %d: Setting Key ***"),err);
User::Leave(err);
}
else
{
INFO_PRINTF1(_L("*** HMAC KEY SET ***"));
}
//Set the Operation Mode of the Hmac Implementation Object
hashHmacImpl->SetOperationModeL(secondOperationModeUid);
if(err!=KErrNone)
{
ERR_PRINTF3(_L("*** ERROR %d: Setting Operation Mode %S ***"),err,&secondOperationModeUid);
User::Leave(err);
}
else
{
INFO_PRINTF2(_L("*** OPERATION MODE SET : %S ***"),&secondOperationModeUid);
}
//Create a NULL TCharacteristics pointer
const TCharacteristics* charsPtrB(NULL);
//Retrieve the characteristics for the hash implementation object
TRAP_LOG(err, hashHmacImpl->GetCharacteristicsL(charsPtrB));
//Static cast the characteristics to type THashCharacteristics
const THashCharacteristics* hashCharsPtrB = static_cast<const THashCharacteristics*>(charsPtrB);
//The hash output size is returned in Bits, divide by 8 to get the Byte size
hashSize = hashCharsPtrB->iOutputSize/8;
//Retrieve the final 8bit hash value and convert to 16bit
HBufC* hashDataB = HBufC::NewLC(hashSize);
TPtr hashPtrB = hashDataB->Des();
hashPtrB.Copy(hashHmacImpl->Hash(*sourceData));
//Take the 16bit descriptor and convert the string to hexadecimal
convertHash.Set(hashPtrB);
HBufC* resultB = convertHash.HexStringLC();
INFO_PRINTF2(_L("*** Hashed Data: %S ***"),&*resultB);
INFO_PRINTF2(_L("*** Expected Hash: %S ***"),&expectedHmac);
if(*resultB == expectedHmac)
{
INFO_PRINTF1(_L("*** SECONDARY HASH VALID - STAGE 2 PASS ***"));
//Set the Operation Mode of the Hmac Implementation Object
TRAP(err,hashHmacImpl->SetOperationModeL(operationModeUid));
if(err!=KErrNone)
{
ERR_PRINTF3(_L("*** ERROR %d: Setting Operation Mode %S ***"),err,&operationModeUid);
User::Leave(err);
}
else
{
INFO_PRINTF2(_L("*** OPERATION MODE SET : %S ***"),&operationModeUid);
}
//Create a NULL TCharacteristics pointer
const TCharacteristics* charsPtrC(NULL);
//Retrieve the characteristics for the hash implementation object
TRAP_LOG(err, hashHmacImpl->GetCharacteristicsL(charsPtrC));
//Static cast the characteristics to type THashCharacteristics
const THashCharacteristics* hashCharsPtrC = static_cast<const THashCharacteristics*>(charsPtrC);
//The hash output size is returned in Bits, divide by 8 to get the Byte size
hashSize = hashCharsPtrC->iOutputSize/8;
//Retrieve the final 8bit hash value and convert to 16bit
HBufC* hashDataC = HBufC::NewLC(hashSize);
TPtr hashPtrC = hashDataC->Des();
hashPtrC.Copy(hashHmacImpl->Hash(*sourceData));
//Take the 16bit descriptor and convert the string to hexadecimal
convertHash.Set(hashPtrC);
HBufC* resultC = convertHash.HexStringLC();
INFO_PRINTF2(_L("*** Hashed Data: %S ***"),&*resultC);
INFO_PRINTF2(_L("*** Expected Hash: %S ***"),&expectedHash);
if(*resultC == expectedHash)
{
INFO_PRINTF1(_L("*** FINAL HASH VALID - STAGE 3 PASS ***"));
INFO_PRINTF1(_L("*** Hmac - Set Operation Mode Checking : PASS ***"));
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF1(_L("*** STAGE 3 FAIL: Hash and Expected Value Mismatch ***"));
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(resultC);
CleanupStack::PopAndDestroy(hashDataC);
}
else
{
ERR_PRINTF1(_L("*** STAGE 2 FAIL: Hash and Expected Value Mismatch ***"));
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(resultB);
CleanupStack::PopAndDestroy(hashDataB);
}
else
{
ERR_PRINTF1(_L("*** STAGE 1 FAIL: Hash and Expected Value Match ***"));
SetTestStepResult(EFail);
}
CleanupStack::PopAndDestroy(resultA);
CleanupStack::PopAndDestroy(hashDataA);
CleanupStack::PopAndDestroy(hashHmacImpl);
}
else if(err==KErrNotSupported)
{
if((((TUid)operationModeUid != KHashModeUid) && ((TUid)operationModeUid != KHmacModeUid)) ||
((TUid)algorithmUid != KMd2Uid) && (TUid)algorithmUid != KMd5Uid && (TUid)algorithmUid != KSha1Uid && (TUid)algorithmUid != KMd4Uid && (TUid)algorithmUid != KSha224Uid && (TUid)algorithmUid != KSha256Uid && (TUid)algorithmUid != KSha384Uid && (TUid)algorithmUid != KSha512Uid)
{
ERR_PRINTF2(_L("*** Object Load Failure - Invalid Operation Mode : %d ***"), err);
User::Leave(err);
}
else
{
SetTestStepResult(EFail);
}
}
else
{
ERR_PRINTF2(_L("*** Hash/Hmac Facotry Object Load Failure : %d ***"), err);
User::Leave(err);
}
CleanupStack::PopAndDestroy(key);
CleanupStack::PopAndDestroy(keyParams);
CleanupStack::PopAndDestroy(keyStr);
}
CleanupStack::PopAndDestroy(sourceData);
//Cleanup the Source RFile
CleanupStack::PopAndDestroy();
fsSession.Close();
}
}
else
{
SetTestStepResult(EFail);
}
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
return TestStepResult();
}
// -----------------------------------------------------------------------------
// CNSmlDsProvisioningAdapter::SaveL
// -----------------------------------------------------------------------------
void CNSmlDsProvisioningAdapter::SaveL(TInt aItem)
{
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): begin");
TPckgBuf<TUint32> uid;
RSyncMLDataSyncProfile profile;
TBool ret = EFalse;
if(iProfiles[aItem]->iServerId != NULL)
{
RSyncMLDataSyncProfile ProfileToSearch;
RArray<TSmlProfileId> arr;
iSession.ListProfilesL( arr, ESmlDataSync );
TInt ProfileId = KErrNotFound;
CleanupClosePushL(arr);
for ( TInt index = 0; index < arr.Count(); index++ )
{
TRAPD( error, ProfileToSearch.OpenL(iSession, arr[index], ESmlOpenRead ) );
if ( error == KErrNone )
{
if ( ( iProfiles[aItem]->iServerId->Des()).Compare(ProfileToSearch.ServerId() ) == 0 )
{
ret = ETrue;
ProfileId = (TInt)arr[index];
ProfileToSearch.Close();
break;
}
}
ProfileToSearch.Close();
}
CleanupStack::PopAndDestroy( &arr );
if( ret )
{
profile.OpenL(iSession, ProfileId , ESmlOpenReadWrite );
}
else
{
profile.CreateL( iSession );
}
CleanupClosePushL( profile );
}
else
{
profile.CreateL( iSession );
CleanupClosePushL( profile );
}
// ui needs this to be set 0
profile.SetCreatorId(0);//iProfiles[aItem]->iProfile.SetCreatorId(0);
profile.SetSanUserInteractionL( iProfiles[aItem]->iServerAlertedAction );
if ( iProfiles[aItem]->iDisplayName )
{
profile.SetDisplayNameL( iProfiles[aItem]->iDisplayName->Des() );
}
if ( iProfiles[aItem]->iServerId )
{
profile.SetServerIdL( iProfiles[aItem]->iServerId->Des() );
}
if ( iProfiles[aItem]->iUsername )
{
profile.SetUserNameL( iProfiles[aItem]->iUsername->Des() );
}
if ( iProfiles[aItem]->iPassword )
{
profile.SetPasswordL( iProfiles[aItem]->iPassword->Des() );
}
// creates profile -> must be done before opening the connection
profile.UpdateL();
RSyncMLConnection connection;
connection.OpenL( profile, KUidNSmlMediumTypeInternet.iUid );
CleanupClosePushL( connection );
if ( (iProfiles[aItem]->iVisitParameter
&& iProfiles[aItem]->iVisitParameter->Data().Length() == uid.MaxLength() )
|| iToNapIDInternetIndicator)
{
TUint apId = 0;
TInt ERROR = KErrNone;
TInt err1 = KErrNone;
if (iToNapIDInternetIndicator)
{
//Get Access Point from DB or SNAP
TRAP(err1, apId = WPAdapterUtil::GetAPIDL());
}
else
{
uid.Copy(iProfiles[aItem]->iVisitParameter->Data() );
RCmManagerExt cmmanagerExt;
cmmanagerExt.OpenL();
CleanupClosePushL(cmmanagerExt);
RCmConnectionMethodExt cm;
cm = cmmanagerExt.ConnectionMethodL( uid());
CleanupClosePushL( cm );
TRAP( ERROR, apId = cm.GetIntAttributeL(CMManager::ECmIapId) );
CleanupStack::PopAndDestroy(2); //cmmanager,cm
}
//Get default access point in failure of getting AP
if (ERROR != KErrNone || err1 != KErrNone)
{
apId = GetDefaultIAPL();
}
HBufC8* iapBuf = HBufC8::NewLC( 8 );
TPtr8 ptrBuf = iapBuf->Des();
ptrBuf.Num( apId );
connection.SetPropertyL( KNSmlIAPId, *iapBuf );
CleanupStack::PopAndDestroy(); //iapBuf
}
if( iProfiles[aItem]->iHostAddress )
{
// see if address contains also port
TBool portFound = EFalse;
TInt startPos(0);
if(iProfiles[aItem]->iHostAddress->Find(KNSmlDsProvisioningHTTP)==0)
{
startPos=KNSmlDsProvisioningHTTP().Length();
}
else if(iProfiles[aItem]->iHostAddress->Find(KNSmlDsProvisioningHTTPS)==0)
{
startPos=KNSmlDsProvisioningHTTPS().Length();
}
TPtrC uriPtr = iProfiles[aItem]->iHostAddress->Mid(startPos);
if(uriPtr.Locate(KNSmlDMColon)!=KErrNotFound)
{
portFound = ETrue;
}
if( portFound == EFalse )
{
HBufC *uri = 0;
// port not found from URI -> see if it is given separately
if( iProfiles[aItem]->iPort )
{
// parse address and port into URI
if( CombineURILC( iProfiles[aItem]->iHostAddress->Des(),
iProfiles[aItem]->iPort->Des(), uri ) == KErrNone )
{
if(iProfiles[aItem]->iHostAddress)
{
delete iProfiles[aItem]->iHostAddress;
iProfiles[aItem]->iHostAddress = NULL;
}
iProfiles[aItem]->iHostAddress = uri->Des().AllocL();
}
CleanupStack::PopAndDestroy(); // uri
}
else
{
// use default port
if( CombineURILC( iProfiles[aItem]->iHostAddress->Des(),
KNSmlDsDefaultPort(), uri ) == KErrNone )
{
if(iProfiles[aItem]->iHostAddress)
{
delete iProfiles[aItem]->iHostAddress;
iProfiles[aItem]->iHostAddress = NULL;
}
iProfiles[aItem]->iHostAddress = uri->Des().AllocL();
}
CleanupStack::PopAndDestroy(); // uri
}
}
connection.SetServerURIL( ConvertTo8LC( iProfiles[aItem]->iHostAddress->Des() ) );
CleanupStack::PopAndDestroy(); // ConvertTo8LC
}
// set authtype, HTTPUserName, HTTPPassword
if( iProfiles[aItem]->iHTTPUserName ||
iProfiles[aItem]->iHTTPPassword )
{
connection.SetPropertyL( KNSmlHTTPAuth, KNSmlTrueVal );
if( iProfiles[aItem]->iHTTPUserName )
{
connection.SetPropertyL( KNSmlHTTPUsername, iProfiles[aItem]->iHTTPUserName->Des() );
}
if( iProfiles[aItem]->iHTTPPassword )
{
connection.SetPropertyL( KNSmlHTTPPassword, iProfiles[aItem]->iHTTPPassword->Des() );
}
}
else
{
connection.SetPropertyL( KNSmlHTTPAuth, KNSmlFalseVal );
}
connection.UpdateL();
CleanupStack::PopAndDestroy(); // connection
if(iProfiles[aItem]->iProtocolVersion == ESmlVersion1_1_2 ||
iProfiles[aItem]->iProtocolVersion == ESmlVersion1_2 )
{
profile.SetProtocolVersionL(iProfiles[aItem]->iProtocolVersion);
}
TInt iDataProvElementCount = iProfiles[aItem]->iDataProvElement.Count();
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: before Start");
for ( TInt i = 0; i < iDataProvElementCount; i++ )
{
_DBG_FILE(
"CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: In");
RSyncMLDataProvider dataProvider;
TRAPD(error, dataProvider.OpenL(iSession,
iProfiles[aItem]->iDataProvElement[i]->iUid));
if (!error)
{
CleanupClosePushL(dataProvider);
if (ret)
{
RArray<TSmlTaskId> providers;
profile.ListTasksL(providers);
TInt dataprovcount = providers.Count();
for (TInt i = 0; i < dataprovcount; i++)
{
TSmlTaskId taskID = providers[i];
RSyncMLTask task;
task.OpenL(profile, taskID);
CleanupClosePushL(task);
if (dataProvider.Identifier() == task.DataProvider())
{
profile.DeleteTaskL(taskID);
CleanupStack::PopAndDestroy();
break;
}
CleanupStack::PopAndDestroy();
}
providers.Reset();
providers.Close();
}
HBufC* localDB = dataProvider.DefaultDataStoreName().AllocLC();
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): DB value");
DBG_ARGS(
iProfiles[aItem]->iDataProvElement[i]->iRemoteDBUri->Des().Ptr());
RSyncMLTask task;
task.CreateL(
profile,
iProfiles[aItem]->iDataProvElement[i]->iUid,
iProfiles[aItem]->iDataProvElement[i]->iRemoteDBUri->Des(),
localDB->Des());
CleanupClosePushL(task);
TRAPD(err, task.UpdateL());
if (err != KErrAlreadyExists && err != KErrNone)
{
User::Leave(err);
}
CleanupStack::PopAndDestroy(3); // task, localDB, dataProvider
}
}
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): Resource For loop: after End");
profile.UpdateL();
iProfiles[aItem]->iProfileId = profile.Identifier();
CleanupStack::PopAndDestroy( &profile );
_DBG_FILE("CNSmlDsProvisioningAdapter::SaveL(): end");
}
EAP_FUNC_EXPORT eap_status_e eapol_am_wlan_authentication_symbian_c::read_configure(
const eap_configuration_field_c * const field,
eap_variable_data_c * const data)
{
EAP_TRACE_BEGIN(m_am_tools, TRACE_FLAGS_DEFAULT);
EAP_ASSERT_ALWAYS(data != NULL);
EAP_TRACE_DEBUG(
m_am_tools,
TRACE_FLAGS_DEFAULT,
(EAPL("eapol_am_wlan_authentication_symbian_c::read_configure(): %s, this = 0x%08x => 0x%08x\n"),
(m_is_client == true) ? "client": "server",
this,
dynamic_cast<abs_eap_base_timer_c *>(this)));
EAP_TRACE_RETURN_STRING_FLAGS(m_am_tools, TRACE_FLAGS_DEFAULT, "returns: eapol_am_wlan_authentication_symbian_c::read_configure()");
// Trap must be set here because the OS independent portion of EAPOL
// that calls this function does not know anything about Symbian.
eap_status_e status(eap_status_ok);
// Check if the wanted parameter is default type
eap_variable_data_c wanted_field(m_am_tools);
eap_variable_data_c type_field(m_am_tools);
status = wanted_field.set_buffer(
field->get_field(),
field->get_field_length(),
false,
false);
if (status != eap_status_ok)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, status);
}
status = type_field.set_buffer(
cf_str_EAP_default_type_hex_data.get_field()->get_field(),
cf_str_EAP_default_type_hex_data.get_field()->get_field_length(),
false,
false);
if (status != eap_status_ok)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, status);
}
// It was something else than EAP type. Read it from eapol DB.
_LIT( KEapolTableName, "eapol" );
TFileName aPrivateDatabasePathName;
TRAPD(err, EapPluginTools::GetPrivatePathL(
m_session,
aPrivateDatabasePathName));
if (err)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, m_am_tools->convert_am_error_to_eapol_error(err));
}
aPrivateDatabasePathName.Append(KEapolDatabaseName);
EAP_TRACE_DATA_DEBUG_SYMBIAN(("aPrivateDatabasePathName",
aPrivateDatabasePathName.Ptr(),
aPrivateDatabasePathName.Size()));
TRAPD( error, read_configureL(
aPrivateDatabasePathName,
KEapolTableName,
field->get_field(),
field->get_field_length(),
data) );
// Try to read it for eap fast DB
HBufC8* fieldBuf = HBufC8::New( field->get_field_length() );
eap_automatic_variable_c<HBufC8> automatic_fieldBuf(
m_am_tools,
fieldBuf);
if (fieldBuf == 0)
{
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, eap_status_allocation_error);
}
TPtr8 fieldPtr = fieldBuf->Des();
fieldPtr.Copy( reinterpret_cast<const TUint8 *> ( field->get_field() ));
if (error != KErrNone)
{
status = m_am_tools->convert_am_error_to_eapol_error(error);
#if defined(USE_EAP_FILECONFIG)
if (m_fileconfig != 0
&& m_fileconfig->get_is_valid() == true)
{
// Here we could try the final configuration option.
status = m_fileconfig->read_configure(
field,
data);
}
#endif //#if defined(USE_EAP_FILECONFIG)
}
m_am_tools->trace_configuration(
status,
field,
data);
EAP_TRACE_END(m_am_tools, TRACE_FLAGS_DEFAULT);
return EAP_STATUS_RETURN(m_am_tools, status);
}
// ---------------------------------------------------------
// CNSmlDsProvisioningAdapter::StoreAttributesL
// ---------------------------------------------------------
void CNSmlDsProvisioningAdapter::StoreAttributesL( const TDesC& aType )
{
_DBG_FILE("CNSmlDsProvisioningAdapter::StoreAttributesL(): begin");
TInt iDataProvElementCount = iProfiles[iProfiles.Count()-1]->iDataProvElement.Count()-1;
// Leave if aType cannot be assigned
if( ( aType.Length() > 0 ) &&
( iProfiles[iProfiles.Count()-1]->iDataProvElement[iDataProvElementCount]->iRemoteDBUri ) )
{
TBool dataProvIdFoundInZ = FALSE;
TSmlDataProviderId firstDataProvIdFound = 0;
TSmlDataProviderId uidFound = 0;
TBool doSearch = ETrue;
if ( aType.FindF( KXVcardMimeType ) != KErrNotFound )
{
if ( IsOperatorProfile( *iProfiles[iProfiles.Count()-1] ) )
{
const CNSmlDsProfileElement& profile = *iProfiles[iProfiles.Count()-1];
StoreOperatorUrlL( *profile.iHostAddress );
// Do not make a search through adapter implementations
doSearch = EFalse;
uidFound = OperatorAdapterUid();
if ( !uidFound )
{
// If OperatorAdapterUid returns 0, do a search
doSearch = ETrue;
}
}
}
// look through every implementation adapter until one found
// which supports MIME type in question
// The first one located in ROM is chosen. If none found in ROM then
// the first adapter found is chosen.
HBufC8 *type = HBufC8::NewLC(aType.Size());
TPtr8 typePtr = type->Des();
CnvUtfConverter::ConvertFromUnicodeToUtf8( typePtr, aType);
// get list of dataproviderIds
RImplInfoPtrArray implArray;
CleanupStack::PushL( PtrArrCleanupItemRArr( CImplementationInformation, &implArray ) );
TUid ifUid = { KNSmlDSInterfaceUid };
REComSession::ListImplementationsL( ifUid, implArray );
if ( doSearch )
{
TInt countProviders = implArray.Count();
for( TInt i = 0; i < countProviders; i++ )
{
CImplementationInformation* implInfo = implArray[i];
RSyncMLDataProvider dataProvider;
dataProvider.OpenL( iSession, implInfo->ImplementationUid().iUid );
CleanupClosePushL( dataProvider );
TInt mimeTypeCount = dataProvider.MimeTypeCount();
for( TInt j = 0; j < mimeTypeCount; j++ )
{
HBufC* mimeType = dataProvider.MimeType( j ).AllocLC();
TPtrC8 convMimeType = ConvertTo8LC( *mimeType );
if( typePtr.Find( convMimeType ) == 0)
{
// MIME type in question was found
uidFound = implInfo->ImplementationUid().iUid;
if( firstDataProvIdFound == 0 )
{
// save the first in case of none found from ROM
firstDataProvIdFound = uidFound;
}
// check whether the provider is located in ROM (drive Z)
if( implInfo->Drive() == EDriveZ )
{
dataProvIdFoundInZ = TRUE;
}
}
CleanupStack::PopAndDestroy(2); // mimetype, ConvertTo8LC
if( uidFound )
{
break;
}
}
CleanupStack::PopAndDestroy(); // dataProvider
if ( dataProvIdFoundInZ )
{
break;
}
else
{
uidFound = firstDataProvIdFound;
}
}
}
REComSession::FinalClose();
CleanupStack::PopAndDestroy( 2 ); // type, implArray
if( uidFound )
{
iProfiles[iProfiles.Count()-1]->iDataProvElement[iDataProvElementCount]->iUid = uidFound;
}
}
_DBG_FILE("CNSmlDsProvisioningAdapter::StoreAttributesL(): end");
}
EXPORT_C void TRequestContext::AddSubjectAttributeL( const TDesC8& aAttributeId, const TCertInfo& aCertInfo)
{
TInt certLength = aCertInfo.iIssuerDNInfo.iCountry.Length();
certLength += aCertInfo.iIssuerDNInfo.iOrganizationUnit.Length();
certLength += aCertInfo.iIssuerDNInfo.iOrganization.Length();
certLength += aCertInfo.iIssuerDNInfo.iCommonName.Length();
certLength += aCertInfo.iSerialNo.Length() * 2;
certLength += aCertInfo.iFingerprint.Length() * 2;
HBufC8 *casn = HBufC8::NewLC( certLength + 5);
TPtr8 ptr = casn->Des();
const TChar KCASNDelimeter = '-';
if ( aCertInfo.iIssuerDNInfo.iCommonName.Length())
{
ptr.Append( aCertInfo.iIssuerDNInfo.iCommonName);
ptr.Append( KCASNDelimeter);
}
if ( aCertInfo.iIssuerDNInfo.iOrganization.Length())
{
ptr.Append( aCertInfo.iIssuerDNInfo.iOrganization);
ptr.Append( KCASNDelimeter);
}
if ( aCertInfo.iIssuerDNInfo.iOrganizationUnit.Length())
{
ptr.Append( aCertInfo.iIssuerDNInfo.iOrganizationUnit);
ptr.Append( KCASNDelimeter);
}
if ( aCertInfo.iIssuerDNInfo.iCountry.Length())
{
ptr.Append( aCertInfo.iIssuerDNInfo.iCountry);
ptr.Append( KCASNDelimeter);
}
if ( aCertInfo.iSerialNo.Length())
{
//convert fingerprint to plain text
for ( TInt i(0); i < aCertInfo.iSerialNo.Length(); i++)
{
ptr.AppendNumFixedWidth( aCertInfo.iSerialNo[i], EHex, 2);
}
ptr.Append( KCASNDelimeter);
}
if ( aCertInfo.iFingerprint.Length())
{
//convert fingerprint to plain text
for ( TInt i(0); i < aCertInfo.iFingerprint.Length(); i++)
{
ptr.AppendNumFixedWidth( aCertInfo.iFingerprint[i], EHex, 2);
}
}
AddSubjectAttributeL( aAttributeId, *casn, PolicyEngineXACML::KStringDataType);
CleanupStack::PopAndDestroy( casn);
}
EXPORT_C TInt CMTPTypeObjectPropList::FirstWriteChunk(TPtr8& aChunk)
{
aChunk.Set(&(iIOPages[0][iTransportHeaderIndex]), 0, KMTPPropListBufferPageSize - iTransportHeaderIndex);
return KErrNone;
}
/*
-------------------------------------------------------------------------------
Class: CStifParser
Method: NextSectionMemoryL
Description: Parses sections from configuration files.
Open and read configuration source and parses a required section.
If start tag is empty the parsing starts beginning of the configuration
file. If end tag is empty the parsing goes end of configuration file.
This method will parse next section after the earlier section if aSeeked
parameter is not given.
If configuration file includes several sections with both start and end
tags so aSeeked parameter seeks the required section. The aSeeked
parameters indicates section that will be parsed.
Parameters: const TDesC& aStartTag: in: Indicates a start tag for parsing
const TDesC& aEndTag: in: Indicates an end tag for parsing
TInt aSeeked: in: a seeked section which will be parsed
Return Values: CStifSectionParser* : pointer to CStifSectionParser object
NULL will return if file size or aSeeked is not positive
NULL will return if start tag is not found
NULL will return if end tag is not found
NULL will return if parsed section length is not positive
Errors/Exceptions: Leaves if called Size method fails
Leaves if HBufC::NewLC method leaves
Leaves if called Read method fails
Leaves if CStifSectionParser::NewL methods leaves
Status: Proposal
-------------------------------------------------------------------------------
*/
CStifSectionParser* CStifParser::NextSectionMemoryL( const TDesC& aStartTag,
const TDesC& aEndTag,
TInt aSeeked )
{
TInt size( 0 );
// Parser is created straight with data
if( iParsingMode == EBufferParsing )
{
size = iBuffer.Length();
}
// Parser is created with path and file informations
else
{
User::LeaveIfError( iFile.Size( size ) );
}
// size or aSeeked cannot be 0 or negetive
if( size <= 0 || aSeeked <= 0)
{
__TRACE(
KInfo, ( _L( "STIFPARSER: NextSectionL method returns a NULL" ) ) );
return NULL;
}
const TInt tmpSize = 128;//--UNICODE-- KMaxName; // 128 - set to even value, because KMaxName may change in the future
TInt offset( 0 ); // Offset value to parts reading
// Construct modifiable heap-based descriptor. tmp to CleanupStack
HBufC* tmp = HBufC::NewLC( size );
TPtr wholeSection = tmp->Des();
// Construct modifiable heap-based descriptor. tmp2 to CleanupStack
HBufC8* tmp2 = HBufC8::NewLC( tmpSize ); // 128
TPtr8 buf = tmp2->Des();
// Construct modifiable heap-based descriptor. tmp3 to CleanupStack
HBufC* tmp3 = HBufC::NewLC( tmpSize ); // 128
TPtr currentSection = tmp3->Des();
// Parser is created straight with data
if( iParsingMode == EBufferParsing )
{
// If 8 bit copy changes to 16
wholeSection.Copy( iBuffer );
}
// Parser is created with path and file informations
else
{
TPtrC16 currentSectionUnicode;
do // Read data in parts(Maximum part size is KMaxName)
{
// Read data
User::LeaveIfError( iFile.Read( offset, buf, tmpSize ) );
// If file is unicode convert differently
if(iIsUnicode)
{
// 8 bit to 16 with unicode conversion - simply point to byte array as to double-byte array
currentSectionUnicode.Set((TUint16 *)(buf.Ptr()), buf.Length() / 2);
// Appends current section to whole section
wholeSection.Append( currentSectionUnicode );
}
else
{
// 8 bit to 16
currentSection.Copy( buf );
// Appends current section to whole section
wholeSection.Append( currentSection );
}
offset += tmpSize;
} while( offset < size );
}
CleanupStack::PopAndDestroy( tmp3 );
CleanupStack::PopAndDestroy( tmp2 );
// User wants section without c-style comments
if( iCommentType == ECStyleComments )
{
ParseCommentsOff( wholeSection );
}
TLex lex( wholeSection );
lex.SkipAndMark( iOffset );
// For the required section length and positions
TInt length( 0 );
TInt lengthStartPos( 0 );
TInt lengthEndPos( 0 );
TBool eos( EFalse );
TInt tagCount( 1 );
// Check is aStartTag given
if ( aStartTag.Length() == 0 )
{
// Skip line break, tabs, spaces etc.
lex.SkipSpace();
lengthStartPos = lex.Offset();
}
else
{
// While end of section
while ( !lex.Eos() )
{
TPtrC ptr = lex.NextToken();
// Start of the section is found and correct section
if ( ptr == aStartTag && tagCount == aSeeked )
{
lengthStartPos = lex.Offset();
break;
}
// Start tag is found but not correct section
else if ( ptr == aStartTag )
{
tagCount++;
}
}
}
// If we are end of section lex.Eos() and eos will be ETrue
eos = lex.Eos();
// Seeked section is not found
if ( tagCount != aSeeked )
{
__TRACE( KInfo, ( _L(
"STIFPARSER: NextSectionL method: Seeked section is not found" ) ) );
CleanupStack::PopAndDestroy( tmp );
User::Leave( KErrNotFound );
}
// Check is aEndTag given
if ( aEndTag.Length() == 0 )
{
lengthEndPos = wholeSection.Length();
}
else
{
// While end of section
while ( !lex.Eos() )
{
TPtrC ptr = lex.NextToken();
// End tag of the section is found
if ( ptr == aEndTag )
{
lengthEndPos = lex.Offset();
// Because Offset() position is after the aEndTag
lengthEndPos -= aEndTag.Length();
break;
}
}
}
// If we are end of section and lengthEndPos is 0
if ( lengthEndPos == 0 )
{
// lex.Eos() and eos will be ETrue
eos = lex.Eos();
}
// The length includes spaces and end of lines
length = ( lengthEndPos - lengthStartPos );
CStifSectionParser* section = NULL;
// If eos is true or length is negative
if ( eos || length <= 0 )
{
__TRACE(
KInfo, ( _L( "STIFPARSER: NextSectionL method returns a NULL" ) ) );
}
else
{
// Make CStifSectionParser object and alloc required length
section = CStifSectionParser::NewL( length );
CleanupStack::PushL( section );
// Copy required data to the section object
section->SetData( wholeSection, lengthStartPos, length );
//iOffset += lengthEndPos + aEndTag.Length();
iOffset = lex.Offset();
CleanupStack::Pop( section );
}
CleanupStack::PopAndDestroy( tmp );
return section;
}
EXPORT_C TInt CMTPTypeObjectPropList::NextWriteChunk(TPtr8& aChunk)
{
ReserveNewPage();
aChunk.Set(&(iIOPages[iIOPages.Count()-1][0]), 0, KMTPPropListBufferPageSize);
return KErrNone;
}
void CRFC3984Encode::PayloadizeNaluL(
TDes8 & aBuffer,
TUint32 /*aTimeStamp*/,
TUint32& /*aMarkerBit*/,
TInt & aNalCount )
{
TInt startIndex = 0;
TInt size = 0;
__ASSERT_ALWAYS( iToPayloadizeCount > 0, User::Leave( KErrArgument ) );
__ASSERT_ALWAYS( iToPayloadizeBuffer.Count() == iToPayloadizeSizeBuffer.Count(),
User::Leave( KErrArgument ) );
if ( iToPayloadizeCount == 1 ) // SNALU packet
{
startIndex = iToPayloadizeBuffer[0];
size = iToPayloadizeSizeBuffer[0];
TPtr8 start = aBuffer.MidTPtr( startIndex );
AddSnaluPacketL( start, size );
}
else // payloadize STAP-A packet
{
TInt count = 0;
TInt totalSize = 0;
TUint8 headerByte = 0;
for ( count = 0; count < iToPayloadizeCount; count++ )
{
// finding total size of all the NALU's to aggregate
totalSize += iToPayloadizeSizeBuffer[count];
}
// addding the total size fields and STAP-A header size
totalSize += ( iToPayloadizeCount*2 + 1 );
count = 0;
// allocating memory for the total buffer size
HBufC8* pBuffer = HBufC8::NewLC( totalSize );
TUint16 value = 0;
TPtr8 pDes1 = pBuffer->Des();
headerByte = PACKET_STAP_A | ( aBuffer[iToPayloadizeBuffer[count]] & ( 0x7 << 5 ) );
pDes1.Append( &headerByte, 1 );
// Pps and sps are handled as SNALUs,
// if there's nothing else to packetize, stap-a packet is not created
TBool stapPacketCreated( EFalse );
for( count = 0; count < iToPayloadizeCount; count++ )
{
startIndex = iToPayloadizeBuffer[count];
size = iToPayloadizeSizeBuffer[count];
TPtr8 pStart = aBuffer.MidTPtr( startIndex ); // getting start index
if ( TMccCodecInfo::IsAvcPpsOrSpsData( pStart, ETrue ) )
{
AddSnaluPacketL( pStart, size );
}
else
{
// convert to network byte order
value = ByteOrder::Swap16( static_cast<TUint16>( size ) );
TUint8* ptrByte = reinterpret_cast<TUint8*>( &value );
pDes1.Append( ptrByte, 2 );
pDes1.Append( pStart.Ptr(), size );
stapPacketCreated = ETrue;
}
}
if ( stapPacketCreated )
{
// inserting stap-a packet into the payloadized NAL unit buffer for retrieval
iPayloadizedBuffers.InsertL( pBuffer, iNalCount );
iNalCount++;
CleanupStack::Pop(pBuffer);
}
else
{
// stap-a packet not created
CleanupStack::PopAndDestroy(pBuffer);
}
}
//Now cleaning up the buffer
iToPayloadizeBuffer.Reset();
iToPayloadizeSizeBuffer.Reset();
iToPayloadizeCount = 0;
aNalCount = iNalCount;
}
TVerdict CUPSDbManagementStep::doTestStepPreambleL()
/**
* @return - TVerdict code
* Override of base class virtual
*/
{
__UHEAP_MARK;
INFO_PRINTF2(_L("START CELLS: %d"), User::CountAllocCells());
// reads client name and SID
TParse clientFullName;
RThread client;
clientFullName.Set(client.FullName(),NULL, NULL);
iTEFServerName=clientFullName.Name();
iExpectedClientSid = client.SecureId() ;
client.Close();
// Read how many times the test step needs to be repeated.
TName fStepRepeat(_L("StepRepeat"));
TInt repeats;
if(GetIntFromConfig(ConfigSection(),fStepRepeat,repeats))
{
iStepRepeat=repeats;
}
else
{
iStepRepeat=1;
}
// Read values for test sequence from INI file. (ARRAY of values)
TInt index=0;
TName fOperation;
fOperation.Format(_L("Operation_%d"), index);
TName fClientSid;
fClientSid.Format(_L("ClientSid_%d"),index);
TName fEvaluatorId;
fEvaluatorId.Format(_L("EvaluatorId_%d"),index);
TName fServiceId;
fServiceId.Format(_L("ServiceId_%d"),index);
TName fServerSid;
fServerSid.Format(_L("ServerSid_%d"),index);
TName fFingerprint;
fFingerprint.Format(_L("Fingerprint_%d"),index);
TName fClientEntity;
fClientEntity.Format(_L("ClientEntity_%d"),index);
TName fDescription;
fDescription.Format(_L("Description_%d"),index);
TName fDecisionResult;
fDecisionResult.Format(_L("DecisionResult_%d"),index);
TName fMajorPolicyVersion;
fMajorPolicyVersion.Format(_L("MajorPolicyVersion_%d"),index);
TName fRecordId;
fRecordId.Format(_L("RecordId_%d"),index);
TName fEvaluatorInfo;
fEvaluatorInfo.Format(_L("EvaluatorInfo_%d"),index);
TName fExpectedDecisionCount;
fExpectedDecisionCount.Format(_L("ExpectedDecisionCount_%d"),index);
TPtrC operation;
TInt clientSid;
TInt evaluatorId;
TInt serviceId;
TInt serverSid;
TPtrC fingerprint;
TPtrC clientEntity;
TPtrC description;
TPtrC decisionResult;
TInt majorPolicyVersion;
TInt recordId;
TInt evaluatorInfo;
TInt expectedDecisionCount;
while (GetStringFromConfig(ConfigSection(),fOperation,operation))
{
// Create an instance of a new request
CUpsDbRequest* newRequest = CUpsDbRequest::NewL();
CleanupStack::PushL(newRequest);
// Set the operation to be performed
newRequest->iOperation = operation;
if(GetHexFromConfig(ConfigSection(),fClientSid,clientSid))
{
newRequest->iClientSid = clientSid;
newRequest->iDecisionFilter->SetClientSid(TSecureId(clientSid),EEqual);
}
if(GetHexFromConfig(ConfigSection(),fEvaluatorId,evaluatorId))
{
newRequest->iEvaluatorId = evaluatorId;
newRequest->iDecisionFilter->SetEvaluatorId(TUid::Uid(evaluatorId),EEqual);
}
if(GetHexFromConfig(ConfigSection(),fServiceId,serviceId))
{
newRequest->iServiceId = serviceId;
newRequest->iDecisionFilter->SetServiceId(TUid::Uid(serviceId),EEqual);
}
if(GetHexFromConfig(ConfigSection(),fServerSid,serverSid))
{
newRequest->iServerSid = serverSid;
newRequest->iDecisionFilter->SetServerSid(TSecureId(serverSid),EEqual);
}
if(GetStringFromConfig(ConfigSection(),fFingerprint,fingerprint))
{
HBufC8* fingerprintConverter = HBufC8::NewLC(fingerprint.Length());
TPtr8 fingerprintPtr = fingerprintConverter->Des();
fingerprintPtr.Copy(fingerprint);
newRequest->iFingerprint = fingerprintPtr;
HBufC8* binaryFingerprint = StringToBinaryLC(fingerprintPtr);
newRequest->iDecisionFilter->SetFingerprintL(*binaryFingerprint,EEqual);
CleanupStack::PopAndDestroy(binaryFingerprint);
CleanupStack::PopAndDestroy(fingerprintConverter);
}
if(GetStringFromConfig(ConfigSection(),fClientEntity,clientEntity))
{
HBufC8* clientEntityConverter = HBufC8::NewLC(clientEntity.Length());
TPtr8 clientEntityPtr = clientEntityConverter->Des();
clientEntityPtr.Copy(clientEntity);
newRequest->iClientEntity = clientEntityPtr;
newRequest->iDecisionFilter->SetClientEntityL(clientEntityPtr,EEqual);
CleanupStack::PopAndDestroy(clientEntityConverter);
}
if(GetStringFromConfig(ConfigSection(),fDescription,description))
{
newRequest->iDescription = description;
}
if(GetStringFromConfig(ConfigSection(),fDecisionResult,decisionResult))
{
if(decisionResult.CompareF(_L("Yes"))==0 || decisionResult.CompareF(_L("No"))==0 || decisionResult.CompareF(_L(""))==0 )
{
newRequest->iDecisionResult = decisionResult;
}
else
{
ERR_PRINTF3(_L("%S: Unexpected Decision Result - %S"),&iTEFServerName, &decisionResult);
}
}
if(GetIntFromConfig(ConfigSection(),fMajorPolicyVersion,majorPolicyVersion))
{
newRequest->iMajorPolicyVersion = majorPolicyVersion;
newRequest->iDecisionFilter->SetMajorPolicyVersion(majorPolicyVersion,EEqual);
}
if(GetIntFromConfig(ConfigSection(),fRecordId,recordId))
{
newRequest->iRecordId = recordId;
newRequest->iDecisionFilter->SetRecordId(recordId,EEqual);
}
if(GetIntFromConfig(ConfigSection(),fEvaluatorInfo,evaluatorInfo))
{
newRequest->iEvaluatorInfo = evaluatorInfo;
}
if(GetIntFromConfig(ConfigSection(),fExpectedDecisionCount,expectedDecisionCount))
{
newRequest->iExpectedDecisionCount = expectedDecisionCount;
}
// Add the new service to be requested to array.
iArraySersToRequest.AppendL(newRequest);
CleanupStack::Pop(newRequest);
index++;
fOperation.Format(_L("Operation_%d"), index);
fClientSid.Format(_L("ClientSid_%d"),index);
fEvaluatorId.Format(_L("EvaluatorId_%d"),index);
fServiceId.Format(_L("ServiceId_%d"),index);
fServerSid.Format(_L("ServerSid_%d"),index);
fFingerprint.Format(_L("Fingerprint_%d"),index);
fClientEntity.Format(_L("ClientEntity_%d"),index);
fDescription.Format(_L("Description_%d"),index);
fDecisionResult.Format(_L("DecisionResult_%d"),index);
fMajorPolicyVersion.Format(_L("MajorPolicyVersion_%d"),index);
fRecordId.Format(_L("RecordId_%d"),index);
fEvaluatorInfo.Format(_L("EvaluatorInfo_%d"),index);
fExpectedDecisionCount.Format(_L("ExpectedDecisionCount_%d"),index);
}
SetTestStepResult(EPass);
return TestStepResult();
}
TInt CTestSession::CheckDesPresent(const RMessage2& aMessage, TUint aArgIndex, TBool aExpected, TBool aWrite)
{
TRequestStatus clientStat;
if (aExpected)
{
RDebug::Printf(" Checking message argument at %d is present", aArgIndex);
}
else
{
RDebug::Printf(" Checking message argument at %d is not present", aArgIndex);
// Start watching for client thread death
RThread clientThread;
aMessage.Client(clientThread);
clientThread.Logon(clientStat);
clientThread.Close();
}
// Get the length of the descriptor and verify it is as expected.
TInt length = aMessage.GetDesLength(aArgIndex);
if (length < KErrNone)
{
RDebug::Printf(" Error getting descriptor length %d", length);
return length;
}
if (length < 3)
{// The incorrect descriptor length.
RDebug::Printf(" Error - Descriptor length too small %d", length);
return KErrArgument;
}
if (!aWrite)
{// Now read the descriptor and verify that it is present or not.
TBuf8<5> des;
TInt r = aMessage.Read(aArgIndex, des);
if (r != (aExpected ? KErrNone : KErrBadDescriptor))
{
RDebug::Printf(" Unexpected value returned from aMessage.Read:%d", r);
return KErrGeneral;
}
if (r==KErrNone && (des[0] != 'a' || des[1] != 'r' || des[2] != 'g'))
{// The incorrect descriptor data has been passed.
RDebug::Printf(" Error in descriptor data is corrupt r %d", r);
return KErrArgument;
}
}
else
{// Now write to the maximum length of the descriptor.
TInt max = aMessage.GetDesMaxLength(aArgIndex);
if (max < 0)
{
RDebug::Printf(" Error getting descriptor max. length %d", max);
return length;
}
HBufC8* argTmp = HBufC8::New(max);
TPtr8 argPtr = argTmp->Des();
argPtr.SetLength(max);
for (TInt i = 0; i < max; i++)
argPtr[i] = (TUint8)aArgIndex;
TInt r = aMessage.Write(aArgIndex, argPtr);
if (r != (aExpected ? KErrNone : KErrBadDescriptor))
{
RDebug::Printf(" Unexpected value returned from aMessage.Write:%d", r);
return KErrGeneral;
}
}
if (!aExpected)
{// The client should have been killed as the data wasn't present.
RDebug::Printf(" CheckDesPresent: Waiting for client to die");
User::WaitForRequest(clientStat);
iClientDied = ETrue;
RDebug::Printf(" CheckDesPresent: Client dead");
}
return KErrNone;
}
void CMacBasicDataStep::doTestL()
{
INFO_PRINTF1(_L("*** Mac - Basic Data ***"));
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
TVariantPtrC algorithmUid;
TPtrC sourcePath;
TPtrC expectedMac;
TPtrC encryptKey;
TVariantPtrC keyType;
//Extract the Test Case ID parameter from the specified INI file
if (!GetStringFromConfig(ConfigSection(),KConfigAlgorithmUid,algorithmUid) ||
!GetStringFromConfig(ConfigSection(),KConfigSourcePath,sourcePath) ||
!GetStringFromConfig(ConfigSection(),KConfigExMacValue,expectedMac)||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKey,encryptKey) ||
!GetStringFromConfig(ConfigSection(),KConfigEncryptKeyType,keyType))
{
ERR_PRINTF1(_L("** Error: Failed to Load Configuration Parameters **"));
return;
}
//Create a pointer for the Mac Implementation Object
CMac* macImpl = NULL;
//Convert encryption key to an 8 Bit Descriptor
HBufC8* keyStr = HBufC8::NewLC(encryptKey.Length());
TPtr8 keyStrPtr = keyStr->Des();
keyStrPtr.Copy(encryptKey);
//Create an new CryptoParams object to encapsulate the key type and secret key string
CCryptoParams* keyParams = CCryptoParams::NewL();
CleanupStack::PushL(keyParams);
keyParams->AddL(*keyStr,keyType);
//Create Key Object
TKeyProperty keyProperty;
CKey* key=CKey::NewL(keyProperty,*keyParams);
CleanupStack::PushL(key);
//Retrieve a Mac Factory Object
TRAPD(err, CMacFactory::CreateMacL(macImpl,
algorithmUid,
*key,
NULL));
if (err != KErrNone)
{
CleanupStack::PopAndDestroy(3, keyStr); // keyStr, keyParams, key
delete macImpl;
ERR_PRINTF2(_L("*** FAIL: Failed to Create Mac Object - %d ***"), err);
User::Leave(err);
}
//Push the Mac Implementation Object onto the Cleanup Stack
CleanupStack::PushL(macImpl);
RFs fsSession;
User::LeaveIfError(fsSession.Connect());
CleanupClosePushL(fsSession);
RFile sourceFile;
//Open the specified source file
User::LeaveIfError(sourceFile.Open(fsSession,sourcePath, EFileRead));
CleanupClosePushL(sourceFile);
TInt sourceLength = 0;
User::LeaveIfError(sourceFile.Size(sourceLength));
//Create a heap based descriptor to store the data
HBufC8* sourceData = HBufC8::NewL(sourceLength);
CleanupStack::PushL(sourceData);
TPtr8 sourcePtr = sourceData->Des();
sourceFile.Read(sourcePtr);
if(sourcePtr.Length() != sourceLength)
{
ERR_PRINTF1(_L("*** Error: Reading Source File ***"));
}
else
{
//Create a NULL TCharacteristics pointer
const TCharacteristics* charsPtr(NULL);
//Retrieve the characteristics for the Mac implementation object
TRAP_LOG(err, macImpl->GetCharacteristicsL(charsPtr));
//Static cast the characteristics to type TMacCharacteristics
const TMacCharacteristics* macCharsPtr = static_cast<const TMacCharacteristics*>(charsPtr);
//The mac output size is returned in Bits, divide by 8 to get the Byte size
TInt macSize = macCharsPtr->iHashAlgorithmChar->iOutputSize/8;
//Retrieve the final 8bit mac value and convert to 16bit
HBufC* macData = HBufC::NewLC(macSize);
TPtr macPtr = macData->Des();
// This is just a simple performance measurement on generating
// the Mac
TTime startTime;
startTime.UniversalTime();
macPtr.Copy(macImpl->MacL(*sourceData));
TTime endTime;
endTime.UniversalTime();
TTimeIntervalMicroSeconds time = endTime.MicroSecondsFrom(startTime);
//Take the 16bit descriptor and convert the string to hexadecimal
TVariantPtrC convertMac;
convertMac.Set(macPtr);
HBufC* macResult = convertMac.HexStringLC();
INFO_PRINTF2(_L("*** Mac: %S ***"), &*macResult);
INFO_PRINTF2(_L("*** Expected Mac: %S ***"), &expectedMac);
//If the returned mac value matches the expected mac, Pass the test
if(*macResult == expectedMac)
{
INFO_PRINTF2(_L("*** Mac - Basic Data generated after setup in %d micro sec.: PASS ***"), time.Int64());
SetTestStepResult(EPass);
}
else
{
ERR_PRINTF1(_L("*** FAIL: Generated Mac and Expected Mac Mismatch ***"));
}
CleanupStack::PopAndDestroy(2, macData); // macData, macResult
}
CleanupStack::PopAndDestroy(7, keyStr); // keyStr, keyParams, key, macImpl, &fsSession, &sourceFile, sourceData
INFO_PRINTF2(_L("HEAP CELLS: %d"), User::CountAllocCells());
}
