/**
Check if the buffer is filled with aFill character.
@param aBufPtr buffer descriptor
@param aFill filling character
@return ETrue if the buffer is filled with aFill byte.
*/
static TBool CheckBufFill(const TPtrC8& aBufPtr, TUint8 aFill)
{
const TUint32 bufSz = (TUint32)aBufPtr.Size();
//-- optimised by using DWORD granularity
if(bufSz % sizeof(TUint32) == 0)
{
TUint32 wordPattern = aFill;
wordPattern <<= 8; wordPattern |= aFill;
wordPattern <<= 8; wordPattern |= aFill;
wordPattern <<= 8; wordPattern |= aFill;
const TUint nWords = bufSz / sizeof(TUint32);
const TUint32* pWords = (const TUint32*) aBufPtr.Ptr();
for(TUint32 i=0; i<nWords; ++i)
{
if(pWords[i] != wordPattern)
return EFalse;
}
return ETrue;
}
//-- dumb implementation
for(TUint32 i=0; i<bufSz; ++i)
{
if(aBufPtr[i] != aFill)
return EFalse;
}
return ETrue;
}
void RCdlSession::SetUidsToNotifyL(const CCdlUids& aUids)
{
TPtrC8 ptr = aUids.Export();
TIpcArgs p(&ptr, ptr.Size());
User::LeaveIfError(SendReceive(ECdlServCmdSetUidsToNotify,p));
}
// -----------------------------------------------------------------------------
// TBTSUDataConverter::ConvertDataUnsignedL
// -----------------------------------------------------------------------------
//
TUint32 TBTSUDataConverter::ConvertDataUnsignedL( const TPtrC8& aData )
{
if ( aData.Size() != sizeof(TUint32) )
{
User::Leave( KErrArgument );
}
return BigEndian::Get32(aData.Ptr());
}
EXPORT_C TInt CMTPTypeOpaqueData::Write( const TPtrC8 &aDes)
{
if(iBuffer.MaxSize() != 0)
{
iBuffer.Close();
}
iPtrBuffer.Set(const_cast<TUint8*>(aDes.Ptr()), aDes.Length(), aDes.Size());
return KErrNone;
}
EXPORT_C TInt TWsGraphicMsgAnimation::Load(const TWsGraphicMsgBufParser& aData,TInt aIndex)
{
if(aData.Uid(aIndex).iUid != TWsGraphicAnimation::ETypeId)
{
return KErrArgument;
}
const TPtrC8 pckg = aData.Data(aIndex);
if(pckg.Size() != sizeof(TWsGraphicMsgAnimation))
{
return KErrCorrupt;
}
memcpy(this,pckg.Ptr(),sizeof(TWsGraphicMsgAnimation));
return KErrNone;
}
void QBluetoothServiceDiscoveryAgentPrivate::VisitAttributeValueL(CSdpAttrValue &aValue, TSdpElementType aType)
{
qDebug() << "VisitAttributeValueL";
QVariant var;
TUint datasize = aValue.DataSize();
switch (aType) {
case ETypeNil:
break;
case ETypeUint:
if (datasize == 8) {
TUint64 value;
aValue.Uint64(value);
var = QVariant::fromValue(value);
} else
var = QVariant::fromValue(aValue.Uint());
break;
case ETypeInt:
var = QVariant::fromValue(aValue.Int());
break;
case ETypeUUID: {
TPtrC8 shortForm(aValue.UUID().ShortestForm());
if (shortForm.Size() == 2) {
QBluetoothUuid uuid(ntohs(*reinterpret_cast<const quint16 *>(shortForm.Ptr())));
var = QVariant::fromValue(uuid);
} else if (shortForm.Size() == 4) {
QBluetoothUuid uuid(ntohl(*reinterpret_cast<const quint32 *>(shortForm.Ptr())));
var = QVariant::fromValue(uuid);
} else if (shortForm.Size() == 16) {
QBluetoothUuid uuid(*reinterpret_cast<const quint128 *>(shortForm.Ptr()));
var = QVariant::fromValue(uuid);
}
break;
}
case ETypeString: {
TPtrC8 stringBuffer = aValue.Des();
var = QVariant::fromValue(QString::fromLocal8Bit(reinterpret_cast<const char *>(stringBuffer.Ptr()), stringBuffer.Size()));
break;
}
case ETypeBoolean:
var = QVariant::fromValue(static_cast<bool>(aValue.Bool()));
break;
case ETypeDES:
m_stack.push(QVariant::fromValue(QBluetoothServiceInfo::Sequence()));
break;
case ETypeDEA:
m_stack.push(QVariant::fromValue(QBluetoothServiceInfo::Alternative()));
break;
case ETypeURL: {
TPtrC8 stringBuffer = aValue.Des();
var = QVariant::fromValue(QUrl(QString::fromLocal8Bit(reinterpret_cast<const char *>(stringBuffer.Ptr()), stringBuffer.Size())));
break;
}
case ETypeEncoded:
qWarning() << "Don't know how to handle encoded type.";
break;
default:
qWarning() << "Don't know how to handle type" << aType;
}
if (aType != ETypeDES && aType != ETypeDEA) {
if (m_stack.size() == 0) {
// single value attribute, just push onto stack
m_stack.push(var);
} else if (m_stack.size() >= 1) {
// sequence or alternate attribute, add non-DES -DEA values to DES or DEA
if (m_stack.top().canConvert<QBluetoothServiceInfo::Sequence>()) {
QBluetoothServiceInfo::Sequence *sequence = static_cast<QBluetoothServiceInfo::Sequence *>(m_stack.top().data());
sequence->append(var);
} else if (m_stack.top().canConvert<QBluetoothServiceInfo::Alternative>()) {
QBluetoothServiceInfo::Alternative *alternative = static_cast<QBluetoothServiceInfo::Alternative *>(m_stack.top().data());
alternative->append(var);
} else {
qWarning("Unknown type in the QVariant, should be either a QBluetoothServiceInfo::Sequence or an QBluetoothServiceInfo::Alternative");
}
}
}
}
// --------------------------------------------------------------------------------------
// Serializes TXmlEngNode to buffer
// --------------------------------------------------------------------------------------
//
TInt CXmlEngSerializerXOP::SerializeL( RBuf8& aBuffer,
const TXmlEngNode aRoot,
const TXmlEngSerializationOptions& aOptions )
{
if(aBuffer.Length())
{
aBuffer.Close();
}
LeaveIfXopIncludeL(aRoot);
iDataContainerArray.Reset();
if(aOptions.iDataSerializer)
{
return CXmlEngSerializer::SerializeL(aBuffer, aRoot, aOptions);
}
TXmlEngSerializationOptions opt = aOptions;
opt.iDataSerializer = this;
RBuf8 xopDocument;
CleanupClosePushL(xopDocument);
aRoot.OwnerDocument().SaveL(xopDocument, aRoot, opt);
if( iCleanXOPInfoset )
{
if(xopDocument.Size() > aBuffer.MaxSize())
{
aBuffer.ReAllocL( xopDocument.Size() );
}
aBuffer.Append(xopDocument);
}
else
{
// adjust buffer size
TInt bufSize = KXOPDocumentStart().Size()
+ KMimeRoot().Size()
+ xopDocument.Size()
+ KXOPDocumentEnd().Size();
for(TInt j = 0; j < iDataContainerArray.Count(); j++)
{
TPtrC8 contentTypeStr;
if(GetContentTypeValue(iDataContainerArray[j], contentTypeStr))
{
bufSize += KMimeHeaderContentType().Size()
+ contentTypeStr.Size()
+ KNewLine().Size();
}
bufSize += KMimeHeaderStart().Size()
+ KMimeHeaderContentIdStart().Size()
+ iDataContainerArray[j].Cid().Length()
+ KMimeHeaderContentIdEnd().Size()
+ KNewLine().Size()
+ iDataContainerArray[j].Size();
}
if (bufSize > aBuffer.MaxSize())
{
aBuffer.ReAllocL( bufSize );
}
// write to buffer
aBuffer.Append(KXOPDocumentStart());
aBuffer.Append(KMimeRoot());
aBuffer.Append(xopDocument);
for(TInt i = 0; i < iDataContainerArray.Count(); i++)
{
aBuffer.Append(KMimeHeaderStart);
TPtrC8 contentTypeStr;
if(GetContentTypeValue(iDataContainerArray[i], contentTypeStr))
{
aBuffer.Append(KMimeHeaderContentType);
aBuffer.Append(contentTypeStr);
aBuffer.Append(KNewLine);
}
aBuffer.Append(KMimeHeaderContentIdStart);
aBuffer.Append(iDataContainerArray[i].Cid());
aBuffer.Append(KMimeHeaderContentIdEnd);
aBuffer.Append(KNewLine);
switch(iDataContainerArray[i].NodeType())
{
case TXmlEngNode::EBinaryContainer:
{
if(opt.iOptions & TXmlEngSerializationOptions::KOptionDecodeBinaryContainers )
{
HBufC8* decodedData = CreateDecodedBufLC(iDataContainerArray[i].AsBinaryContainer().Contents());
aBuffer.Append(decodedData->Des());
CleanupStack::PopAndDestroy(); //decodedData
}
else
{
aBuffer.Append(iDataContainerArray[i].AsBinaryContainer().Contents());
}
break;
}
case TXmlEngNode::EChunkContainer:
{
TPtrC8 data = TPtrC8(
((RChunk&)iDataContainerArray[i].AsChunkContainer().Chunk()).Base()
+ iDataContainerArray[i].AsChunkContainer().ChunkOffset(),
iDataContainerArray[i].AsChunkContainer().Size());
if(opt.iOptions & TXmlEngSerializationOptions::KOptionDecodeBinaryContainers )
{
HBufC8* decodedData = CreateDecodedBufLC(data);
aBuffer.Append(decodedData->Des());
CleanupStack::PopAndDestroy(); //decodedData
}
else
{
aBuffer.Append(data);
}
break;
}
case TXmlEngNode::EFileContainer:
{
TInt size = iDataContainerArray[i].AsFileContainer().Size();
HBufC8* data = HBufC8::NewLC(size);
TPtr8 dataPtr = data->Des();
iDataContainerArray[i].AsFileContainer().File().Read(dataPtr, size);
if(opt.iOptions & TXmlEngSerializationOptions::KOptionDecodeBinaryContainers )
{
HBufC8* decodedData = CreateDecodedBufLC(dataPtr);
aBuffer.Append(decodedData->Des());
CleanupStack::PopAndDestroy(); //decodedData
}
else
{
aBuffer.Append(dataPtr);
}
CleanupStack::PopAndDestroy(); //data
break;
}
}
}
aBuffer.Append(KXOPDocumentEnd);
}
CleanupStack::PopAndDestroy(); //xopDocument
return aBuffer.Size();
}
// -----------------------------------------------------------------------------
// CCMSX509CertificateList::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
EXPORT_C void CCMSX509CertificateList::ConstructL(
const CX509Certificate& aSigningCertificate,
const CArrayPtrFlat<CX509Certificate>& aRevokedCertificates )
{
ConstructL();
// setting signature
const CSigningAlgorithmIdentifier& signAlgorithm =
aSigningCertificate.SigningAlgorithm();
iParams->iSignatureAlgorithm =
CCMSX509AlgorithmIdentifier::NewL( signAlgorithm.AsymmetricAlgorithm(),
signAlgorithm.DigestAlgorithm() );
// setting issuer
iParams->iIssuer =
CX500DistinguishedName::NewL( aSigningCertificate.IssuerName() );
// setting validity
const CValidityPeriod& validity = aSigningCertificate.ValidityPeriod();
iParams->iThisUpdate = validity.Start();
iParams->iNextUpdate = validity.Finish();
// copying revoked certificates
TInt revCerts = aRevokedCertificates.Count();
if( revCerts > 0 )
{
iParams->iRevokedCertificates =
new( ELeave )CArrayPtrFlat< CCMSX509RevokedCertificate >
( KDefaultGranularity );
for( TInt i = 0; i < revCerts; i++ )
{
CX509Certificate* cert = aRevokedCertificates[ i ];
CCMSX509RevokedCertificate* tmpRevCer =
new(ELeave) CCMSX509RevokedCertificate();
CleanupStack::PushL( tmpRevCer );
// convert serial from des to int
TPtrC8 serialDes = cert->SerialNumber();
TInt length = serialDes.Size();
const TUint8* ptr = serialDes.Ptr();
TInt serial = ( ptr[ 0 ] & 0x80 ) ? -1 : 0;
for( TInt j = 0; j < length; j++ )
{
serial <<= 8;
serial += *ptr++;
}
tmpRevCer->iUserCertificateSerialNumber = serial;
const CValidityPeriod& reValidity = cert->ValidityPeriod();
tmpRevCer->iRevokationDate = reValidity.Start();
// copying extensions
const CArrayPtrFlat<CX509CertExtension>& extensions =
cert->Extensions();
TInt extensionCount = extensions.Count();
if( extensionCount > 0 )
{
tmpRevCer->iExtensions =
new(ELeave) CArrayPtrFlat<CX509CertExtension>
( KDefaultGranularity );
for( TInt j = 0; j < extensionCount; j++ )
{
CX509CertExtension* ext = extensions[ j ];
CX509CertExtension* tmpExt =
CX509CertExtension::NewLC( *ext );
tmpRevCer->iExtensions->AppendL( tmpExt );
CleanupStack::Pop( tmpExt );
}
}
iParams->iRevokedCertificates->AppendL( tmpRevCer );
CleanupStack::Pop( tmpRevCer );
}
}
// copying possible extensions
TInt extensionCount = aSigningCertificate.Extensions().Count();
if( extensionCount > 0 )
{
iParams->iExtensions =
new( ELeave )CArrayPtrFlat< CX509CertExtension >
( KDefaultGranularity );
const CArrayPtrFlat< CX509CertExtension >& extensions =
aSigningCertificate.Extensions();
for( TInt i = 0; i < extensionCount; i++ )
{
CX509CertExtension* copy = CX509CertExtension::NewL( *extensions[ i ] );
CleanupStack::PushL( copy );
iParams->iExtensions->AppendL( copy );
CleanupStack::Pop( copy );
}
}
// copying signature
iParams->iSignature = aSigningCertificate.Signature().AllocL();
}
TInt CSenBaseIdentityManager::AuthenticationForL(
CSenIdentityProvider& aProvider,
TPckgBuf<TSenAuthentication>& aResponse)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"CSenBaseIdentityManager::AuthenticationForL");
TPtrC8 user = aProvider.AuthzID();
if (user == KNullDesC8)
{
user.Set(aProvider.AdvisoryAuthnID());
}
if (!iShowPasswordDialog)
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"Not allowed to show password dialog");
HBufC8* pDecodedPassword = SenXmlUtils::DecodeHttpCharactersLC(aProvider.Password());
TPtrC8 decodedPassword = pDecodedPassword->Des();
aResponse().iUsername.Append((const TUint8*)user.Ptr(), user.Size());
aResponse().iPassword.Append((const TUint8*)decodedPassword.Ptr(),
decodedPassword.Size());
CleanupStack::PopAndDestroy(); // delete pDecodedPassword
return KErrNone;
}
RNotifier notifier;
User::LeaveIfError(notifier.Connect());
CleanupClosePushL(notifier);
TPckgBuf<TAuthenticationDlgRequest>* request =
new(ELeave)TPckgBuf<TAuthenticationDlgRequest>();
CleanupStack::PushL(request);
// convert username to unicode
HBufC* pUserAsUnicode = SenXmlUtils::ToUnicodeLC(user); // push
TPtrC username = pUserAsUnicode->Des();
// decode password
HBufC8* pDecodedPassword = SenXmlUtils::DecodeHttpCharactersLC(aProvider.Password());
TPtrC8 decodedPassword = pDecodedPassword->Des();
// convert decoded password to unicode
HBufC* pPasswordAsUnicode =
SenXmlUtils::ToUnicodeLC(decodedPassword); // push
TPtrC password = pPasswordAsUnicode->Des();
// set data to request
(*request)().SetData(username, password);
CleanupStack::PopAndDestroy(3); // delete pPasswordAsUnicode, pDecodedPassword, pUserAsUnicode
TPckgBuf<TAuthenticationDlgResponse>* response =
new(ELeave)TPckgBuf<TAuthenticationDlgResponse>();
CleanupStack::PushL(response);
TRequestStatus reqStatus;
notifier.StartNotifierAndGetResponse(reqStatus,
KSenNotifierPluginUID, *request, *response);
TBool illegalUsername = EFalse;
HBufC8* pUsernameUtf8 = NULL;
HBufC8* pPasswordUtf8 = NULL;
User::WaitForRequest(reqStatus);
notifier.Close();
if(reqStatus.Int() == KErrNone)
{
if((*response)().OkButtonPressed())
{
TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("User pressed OK Button in Password dialog")));
pUsernameUtf8 = SenXmlUtils::ToUtf8LC((*response)().Username());
pPasswordUtf8 = SenXmlUtils::ToUtf8LC((*response)().Password());
TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Username: %S"), pUsernameUtf8));
TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Password: %S"), pPasswordUtf8 ));
HBufC8* pEncodedUsername = NULL;
illegalUsername =
SenXmlUtils::EncodeHttpCharactersL(*pUsernameUtf8,
pEncodedUsername);
if (illegalUsername)
{
TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("Username included illegal characters.")));
delete pEncodedUsername;
pEncodedUsername = NULL;
}
#ifdef _SENDEBUG
else
{
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"Username did NOT include illegal characters.");
}
#endif
//Check if iilegal chars are there then return
if (!illegalUsername)
{
if(user != *pUsernameUtf8)
{
// User modified the username in the dialog prompt(!)
// We have to save it right away, because there is
// no in-memory/session based member variables in
// components calling identity manager (sec mechs and
// in ID-WSF AS client!
TLSLOG_L(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,"Username changed. Saving new username.");
// Use Advisory only if AuthzID is not available
if (aProvider.AuthzID() == KNullDesC8
&& aProvider.AdvisoryAuthnID() != KNullDesC8)
{
aProvider.SetUserInfoL(aProvider.AuthzID(),
*pUsernameUtf8,
aProvider.Password());
}
else
{
// There was at least AuthzID available, and possibly
// also advisory value. Any way, if
// We have to NULL advisory value (set it to KNullDesC8),
// because if both were available, then user was
// prompted to allow modification of AuthzID AND
// if advisory was changed in service (is no longer
// valid), there would NOT be any way for end-user
// to change (remove) it(!)
CSenElement& element = aProvider.AsElement();
delete element.RemoveElement(KSenIdpAdvisoryAuthnIdLocalname);
aProvider.SetUserInfoL(*pUsernameUtf8,
KNullDesC8,
aProvider.Password());
}
// serialize changed username into sensessions.xml database immediately
WriteDatabase();
}
if (AllowSavePasswordL())
{
HBufC8* pEncodedPassword = SenXmlUtils::EncodeHttpCharactersLC(*pPasswordUtf8);
#ifdef _SENDEBUG
if(pEncodedPassword)
{
TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8("Encoded password: %S"), pEncodedPassword));
}
#endif
if(pEncodedPassword)
{
aProvider.SetUserInfoL(aProvider.AuthzID(),
aProvider.AdvisoryAuthnID(),
*pEncodedPassword);
}
WriteDatabase();
CleanupStack::PopAndDestroy(1); // pEncodedPassword
}
}
aResponse().iUsername.Zero();
aResponse().iPassword.Zero();
if (!illegalUsername)
{
aResponse().iUsername.Copy(pUsernameUtf8->Des());
aResponse().iPassword.Copy(pPasswordUtf8->Des());
}
CleanupStack::PopAndDestroy(2); // pPasswordUtf8, pUsernameUtf8
}
else
{
TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("User pressed Cancel Button in Password dialog")));
}
}
else if(reqStatus.Int() == KErrNotFound)
{
TLSLOG(KSenCoreServiceManagerLogChannelBase , KMinLogLevel,(_L("Password dialog plugin notifier impl. was not found")));
}
else
{
TLSLOG_FORMAT((KSenCoreServiceManagerLogChannelBase , KMinLogLevel, _L8(" Notifier plugin for 'Password' dialog returned an error: %d"),
reqStatus.Int()));
}
CleanupStack::PopAndDestroy(2); // request, response;
CleanupStack::Pop(); // notifier
if (illegalUsername) return KErrArgument;
return reqStatus.Int();
}
void CHttpEventHandler::MHFRunL(RHTTPTransaction aTransaction, const THTTPEvent& aEvent)
{
switch (aEvent.iStatus)
{
case THTTPEvent::EGotResponseHeaders:
{
// HTTP response headers have been received. We can determine now if there is
// going to be a response body to save.
RHTTPResponse resp = aTransaction.Response();
TInt status = resp.StatusCode();
if (iVerbose)
{
RStringF statusStr = resp.StatusText();
TBuf<32> statusStr16;
statusStr16.Copy(statusStr.DesC());
iTest->Console()->Printf(_L("Status: %d (%S)\n"), status, &statusStr16);
// Dump the headers if we're being verbose
DumpRespHeadersL(aTransaction);
}
// Determine if the body will be saved to disk
iSavingResponseBody = EFalse;
if (resp.HasBody() && (status >= 200) && (status < 300) && (status != 204))
{
if (iVerbose)
{
TInt dataSize = resp.Body()->OverallDataSize();
if (dataSize >= 0)
iTest->Console()->Printf(_L("Response body size is %d\n"), dataSize);
else
iTest->Console()->Printf(_L("Response body size is unknown\n"));
}
iSavingResponseBody = ETrue;
}
else
{
if (iVerbose)
iTest->Console()->Printf(_L("Response status is bad\n"));
}
if ((status >= 200) && (status < 300) && (status != 204))
{
ParseCookieL(aTransaction);
}
if (iSavingResponseBody) // If we're saving, then open a file handle for the new file
{
if ( iUsingFile )
{
iHttpFileManager->GetNewFile(iRespBodyFilePath, iRespBodyFileName, EFalse);
// Check it exists and open a file handle
TInt valid = iFileServ.IsValidName(iRespBodyFilePath);
if (!valid)
{
if (iVerbose)
iTest->Console()->Printf(_L("The specified filename is not valid!.\n"));
iSavingResponseBody = EFalse;
}
else
{
TInt err = iRespBodyFile.Create(iFileServ,
iRespBodyFilePath,
EFileWrite|EFileShareExclusive);
if (err)
{
iSavingResponseBody = EFalse;
User::Leave(err);
}
}
}
else
{
TInt dataSize = resp.Body()->OverallDataSize();
if ( iResBodyBuffer )
delete iResBodyBuffer;
iResBodyBuffer = NULL;
if ( dataSize > 50 * 1024) //skip large chunks of data
{
iSavingResponseBody = false;
//try to stop current connection
if (iVerbose)
iTest->Console()->Printf(_L("Transaction Failed\n"));
aTransaction.Close();
CActiveScheduler::Stop();
}
else
{
iResBodyBuffer = HBufC8::NewMaxL(dataSize);
iResBodyBufferPtr.Set(iResBodyBuffer->Des());
}
iCurPos = 0;
}
}
} break;
case THTTPEvent::EGotResponseBodyData:
{
// Get the body data supplier
iRespBody = aTransaction.Response().Body();
// Some (more) body data has been received (in the HTTP response)
if (iVerbose)
DumpRespBody(aTransaction);
// Append to the output file if we're saving responses
if (iSavingResponseBody)
{
TPtrC8 bodyData;
TBool lastChunk = iRespBody->GetNextDataPart(bodyData);
if ( iUsingFile )
{
iRespBodyFile.Write(bodyData);
if (lastChunk)
{
iRespBodyFile.Flush();
iRespBodyFile.Rename(iRespBodyFileName);
iRespBodyFile.Close();
}
}
else
{
Mem::Copy((void*)(iResBodyBuffer->Ptr()+iCurPos), (void*)bodyData.Ptr(), bodyData.Size());
iCurPos += bodyData.Size();
}
}
// Done with that bit of body data
iRespBody->ReleaseData();
} break;
case THTTPEvent::EResponseComplete:
{
// The transaction's response is complete
if (iVerbose)
iTest->Console()->Printf(_L("\nTransaction Complete\n"));
} break;
case THTTPEvent::ESucceeded:
{
if (iVerbose)
iTest->Console()->Printf(_L("Transaction Successful\n"));
aTransaction.Close();
CActiveScheduler::Stop();
} break;
case THTTPEvent::EFailed:
{
if (iVerbose)
iTest->Console()->Printf(_L("Transaction Failed\n"));
aTransaction.Close();
CActiveScheduler::Stop();
} break;
case THTTPEvent::ERedirectedPermanently:
{
if (iVerbose)
iTest->Console()->Printf(_L("Permanent Redirection\n"));
} break;
case THTTPEvent::ERedirectedTemporarily:
{
if (iVerbose)
iTest->Console()->Printf(_L("Temporary Redirection\n"));
} break;
default:
{
if (iVerbose)
iTest->Console()->Printf(_L("<unrecognised event: %d>\n"), aEvent.iStatus);
// close off the transaction if it's an error
if (aEvent.iStatus < 0)
{
aTransaction.Close();
CActiveScheduler::Stop();
}
} break;
}
}
LOCAL_C void CreateNewPlaintextMessageL()
{
CTestActive* testActive = new(ELeave) CTestActive();
CleanupStack::PushL(testActive);
TMsvEmailTypeList msvEmailTypeList = 0;
TMsvPartList partList = (KMsvMessagePartBody | KMsvMessagePartAttachments);
CImEmailOperation* emailOperation = CImEmailOperation::CreateNewL(testActive->iStatus, *(testUtils->iMsvSession),KMsvGlobalOutBoxIndexEntryId, partList, msvEmailTypeList, KUidMsgTypeSMTP);
CleanupStack::PushL(emailOperation);
TestMsvOperationTimer* testMsvOperationTimer = TestMsvOperationTimer::NewLC(test.Console(), emailOperation, test);
testActive->StartL();
testMsvOperationTimer->IssueRequest();
CActiveScheduler::Start();
//check progress
TMsvId temp;
TPckgC<TMsvId> paramPack(temp);
const TDesC8& progBuf = emailOperation->ProgressL();
paramPack.Set(progBuf);
TMsvId newMessageId;
newMessageId = paramPack();
test(newMessageId != NULL);
CImEmailMessage* imEmailMessage = CImEmailMessage::NewLC(*(testUtils->iMsvEntry));
// Make sure you are set on the Message Id
testUtils->iMsvEntry->SetEntryL(newMessageId);
CMsvAttachment* attachmentInfo = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachmentInfo);
attachmentInfo->SetAttachmentNameL(KAttachmentFileName1());
CleanupStack::Pop(attachmentInfo); // ownership passed to attachment manager
imEmailMessage->AttachmentManager().AddAttachmentL(KAttachment1, attachmentInfo, testActive->iStatus);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
if (testActive->iStatus.Int())
{
testUtils->WriteComment(_L("CreateNewPlaintextMessageWithIncompleteAttachmentL failed"));
testUtils->TestHarnessFailed(testActive->iStatus.Int());
}
testUtils->iMsvEntry->SetEntryL(newMessageId);
CMsvAttachment* attachmentInfo1 = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachmentInfo1);
attachmentInfo1->SetAttachmentNameL(KAttachmentFileName2());
CleanupStack::Pop(attachmentInfo1); // ownership passed to attachment manager
imEmailMessage->AttachmentManager().AddAttachmentL(KAttachment2, attachmentInfo1, testActive->iStatus);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
if (testActive->iStatus.Int())
{
testUtils->WriteComment(_L("CreateNewPlaintextMessageWithIncompleteAttachmentL failed"));
testUtils->TestHarnessFailed(testActive->iStatus.Int());
}
testUtils->iMsvEntry->SetEntryL(newMessageId);
CMsvAttachment* attachmentInfo2 = CMsvAttachment::NewL(CMsvAttachment::EMsvFile);
CleanupStack::PushL(attachmentInfo2);
attachmentInfo2->SetAttachmentNameL(KAttachmentFileName3());
CleanupStack::Pop(attachmentInfo2); // ownership passed to attachment manager
imEmailMessage->AttachmentManager().AddAttachmentL(KAttachment3, attachmentInfo2, testActive->iStatus);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
if (testActive->iStatus.Int())
{
testUtils->WriteComment(_L("CreateNewPlaintextMessageWithIncompleteAttachmentL failed"));
testUtils->TestHarnessFailed(testActive->iStatus.Int());
}
const TDesC8& progBuf2 = imEmailMessage->ProgressL();
paramPack.Set(progBuf2);
TMsvId attachmentId = paramPack();
testUtils->WriteComment(_L("\t Created New plaintext message"));
testUtils->iMsvEntry->SetEntryL(attachmentId);
imEmailMessage->GetAttachmentsListL(testActive->iStatus, newMessageId, CImEmailMessage::EAllAttachments, CImEmailMessage::EThisMessageOnly);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
const CMsvEntrySelection& selection = imEmailMessage->Selection();
testUtils->Printf(KTotalNoOfAttachment , selection.Count());
imEmailMessage->GetBodyTextEntryIdL(testActive->iStatus,newMessageId,CImEmailMessage::EThisMessageOnly);
testActive->StartL();
CActiveScheduler::Start(); // wait for the asynch operation to complete
const CMsvEntrySelection& selection1 = imEmailMessage->Selection();
TInt count = imEmailMessage->Selection().Count();
if( count > 0)
{
// Get the Id of the body text
// The body text part Id is present at index 0. Not checking for other
// Ids, as currently only Plain text part is verified.
TMsvId iBodyTextId = imEmailMessage->Selection().At(0);
testUtils->Printf(KBodytextId, iBodyTextId);
}
CleanupStack::PopAndDestroy(); // imEmailMessage
testUtils->iMsvEntry->SetEntryL(attachmentId);
CMsvStore* store1 = testUtils->iMsvEntry->EditStoreL();
CleanupStack::PushL(store1);
CImMimeHeader *Head1 = CImMimeHeader::NewLC();
Head1->RestoreL(*store1);
const TPtrC8 contentSubType = Head1->ContentSubType();
store1->CommitL();
if(contentSubType.Size() == 0 )
{
testUtils->Printf(_L("ContentSubType Has NO SUB CONTENT****") );
test(contentSubType.Size() != 0);
}
else
{
testUtils->Printf(_L("ContentSubType Has ****SUB CONTENT****"));
}
CleanupStack::PopAndDestroy(2, store1);//store1,Head1,Buffer
testUtils->iMsvEntry->SetEntryL(newMessageId);
CMsvStore* store = testUtils->iMsvEntry->EditStoreL();
CleanupStack::PushL(store);
CImHeader* header = CImHeader::NewLC();
header->RestoreL(*store);
TInt serverLength = testUtils->MachineName().Length();
HBufC* serverad = HBufC::NewL(serverLength + 7 ); // 7 is the length of KServerAddress
CleanupStack::PushL(serverad);
serverad->Des().Copy(testUtils->MachineName());
serverad->Des().Append(KServer);
HBufC* emailaddress = HBufC::NewL(serverLength + 8 + serverad->Des().Length() + 1 );
CleanupStack::PushL(emailaddress);
emailaddress->Des().Copy(testUtils->MachineName());
emailaddress->Des().Append(KAt);
emailaddress->Des().Append(*serverad);
header->ToRecipients().AppendL(*emailaddress);
header->SetSubjectL(_L("Test sending message using CMsvEntry::CopyL!!"));
header->StoreL(*store);
store->CommitL();
CleanupStack::PopAndDestroy(emailaddress);
CleanupStack::PopAndDestroy(serverad);
CleanupStack::PopAndDestroy(5,testActive); // header,store,testMsvOperationTimer,emailOperation,testActive
}
