/**
Subtest function
@SYMTestCaseID SYSLIB-BAFL-CT-0490
@SYMTestCaseDesc Tests for defect number DEF043985
@SYMTestPriority High
@SYMTestActions Tests that the table is invalid when creating a folded RString
@SYMTestExpectedResults Tests must not fail
@SYMREQ REQ0000
*/
void RStringPoolPanicTest::DEF043985_IndexTest_SubFunctionL()
{
__UHEAP_MARK;
RStringPool stringPool;
stringPool.OpenL();
// Create a table and make it so it passes some internal tests
// for validity as we are testing a particular internal test
TStringTable testTable;
testTable.iCaseSensitive = ETrue;
testTable.iCount = 1;
RString testString = stringPool.OpenStringL(KDummyString());
CleanupClosePushL(testString);
// Test for Panic
testString.Index(testTable);
// Test should never get this far as it Panics
CleanupStack::PopAndDestroy(&testString);
stringPool.Close();
__UHEAP_MARKEND;
}
// ----------------------------------------------------------------------------
// CWmDrmDlaDefaultHttpManager::GetCredentialsL
// This function is NOT currently used as authentication is not current used in
// this project at the current time
// ----------------------------------------------------------------------------
TBool CWmDrmDlaDefaultHttpManager::GetCredentialsL(
const TUriC8& /*aURI*/,
RString aRealm,
RStringF aAuthenticationType,
RString& aUsername,
RString& aPassword )
{
LOGFN( "CWmDrmDlaDefaultHttpManager::GetCredentialsL" );
iCredentialsOk = EFalse;
RStringPool pool = aRealm.Pool();
if ( aAuthenticationType == HTTP_STRING( HTTP::EBasic ) )
{
DeleteUsernamePassword();
// Get the username/password
iInCallback = ETrue;
iCredentialsOk =
iObserver.OnGetUsernamePasswordL( iUsername, iPassword );
iInCallback = EFalse;
// authentication = iCredentialsOk && iUsername && iPassword
// no authentication = !iCredentialsOk && !iUsername && !iPassword
ASSERT( (iCredentialsOk && iUsername && iPassword) ||
(!iCredentialsOk && !iUsername && !iPassword ) );
if (iCredentialsOk)
{
aUsername = pool.OpenStringL( *iUsername );
aPassword = pool.OpenStringL( *iPassword );
}
}
// If the authentication type is not Basic, we simply return EFalse.
return iCredentialsOk;
}
// ------------------------------------------------------------------------------------------------
// CHttpFilterConnHandler::MHFRunL
// Process a transaction event.
// ------------------------------------------------------------------------------------------------
//
void CHttpFilterConnHandler::MHFRunL(RHTTPTransaction aTransaction,
const THTTPEvent& aEvent)
{
TInt state = 0;
TInt gprsState = 0;
TInt wcdmaState = 0;
TApBearerType bearerType;
if (aEvent.iStatus == THTTPEvent::ESubmit)
{
THTTPHdrVal isNewConn;
RHTTPConnectionInfo connInfo = iSession->ConnectionInfo();
RStringPool strPool = aTransaction.Session().StringPool();
TBool ret = connInfo.Property (strPool.StringF(HttpFilterCommonStringsExt::EHttpNewConnFlag,
HttpFilterCommonStringsExt::GetTable()), isNewConn);
if ( LocalHostCheckL(aTransaction) && !( ret && isNewConn.Type() == THTTPHdrVal::KTIntVal ) )
{
return;
}
THTTPHdrVal callback;
RHTTPTransactionPropertySet propSet = aTransaction.PropertySet();
RStringF callbackStr = strPool.StringF( HttpFilterCommonStringsExt::EConnectionCallback,
HttpFilterCommonStringsExt::GetTable() );
MConnectionCallback* callbackPtr = NULL;
// this is a transaction, already forwarded to download manager
if( propSet.Property( callbackStr, callback ) )
{
callbackPtr = REINTERPRET_CAST( MConnectionCallback*, callback.Int() );
}
void CPipeliningConfigTest::CheckAndSetSessionSettingsL(RHTTPSession aSession)
{
RStringPool stringPool = aSession.StringPool();
RHTTPConnectionInfo sessionSettings = aSession.ConnectionInfo();
if (iMaxNumberTransactionsToPipeline > 0)
{
RStringF maxToPipelineSetting = stringPool.StringF(HTTP::EMaxNumTransactionsToPipeline,
aSession.GetTable());
THTTPHdrVal value;
if (sessionSettings.Property(maxToPipelineSetting, value) == EFalse)
{
value.SetInt(iMaxNumberTransactionsToPipeline);
sessionSettings.SetPropertyL(maxToPipelineSetting,value);
}
}
if (iMaxNumberTransportHandlers > 0)
{
RStringF maxTransportHandlers = stringPool.StringF(HTTP::EMaxNumTransportHandlers,
aSession.GetTable());
THTTPHdrVal value;
if (sessionSettings.Property(maxTransportHandlers, value) == EFalse)
{
value.SetInt(iMaxNumberTransportHandlers);
sessionSettings.SetPropertyL(maxTransportHandlers,value);
}
}
}
// ---------------------------------------------------------------------------
// SdpUtil::SetDefaultNetTypeAndAddrType
// Sets network type and address type to their "default" values
// ---------------------------------------------------------------------------
//
void SdpUtil::SetDefaultNetTypeAndAddrType(
RStringPool aPool,
const TInetAddr& aAddress,
RStringF& aNetType,
RStringF& aAddressType )
{
// Sets network type to IN
aNetType.Close();
aNetType = aPool.StringF( SdpCodecStringConstants::ENetType,
SdpCodecStringConstants::Table ).Copy();
// Address type
aAddressType.Close();
TBuf16 <KMaxAddressLength> output;
aAddress.Output(output);
//addresstype for IPv4
if((aAddress.Address() && !aAddress.IsV4Mapped()) ||
(!aAddress.Address() && aAddress.IsWildAddr() &&
output.Match(KWildAddr) == 0))
{
aAddressType = aPool.StringF( SdpCodecStringConstants::EAddressTypeIP4,
SdpCodecStringConstants::Table ).Copy();
}
else
{
//addresstype for IPv4-Mapped IPv6 && IPv6
aAddressType = aPool.StringF( SdpCodecStringConstants::EAddressType,
SdpCodecStringConstants::Table ).Copy();
}
}
void CHttpTestCaseGet12::LogConnectionProperties()
{
RHTTPConnectionInfo connectionInfo = iSession.ConnectionInfo();
RStringPool stringPool = iSession.StringPool();
THTTPHdrVal value;
TBool hasValue = connectionInfo.Property (stringPool.StringF(HTTP::EHttpSocketConnection, RHTTPSession::GetTable()), value);
if (hasValue)
{
RConnection* conn = REINTERPRET_CAST(RConnection*, value.Int());
TUint count;
//get the no of active connections
TInt err = conn->EnumerateConnections(count);
if(err==KErrNone)
{
for (TUint i=1; i<=count; ++i)
{
TPckgBuf<TConnectionInfo> connInfo;
conn->GetConnectionInfo(i, connInfo);
iEngine->Utils().LogIt(_L("Connection %d: IapId=%d, NetId=%d\n"),i, connInfo().iIapId, connInfo().iNetId);
}
}
else
{
iEngine->Utils().LogIt(_L("Unable to enumerate number of connections, Error: %d"), err);
}
}
}
void CINC097492_3::CreateTransArrayL()
{
RStringPool strP = iSession.StringPool();
TUriParser8 up;
up.Parse(KHttpUrl1);
RHTTPTransaction trans1 = iSession.OpenTransactionL(up, *this, strP.StringF(HTTP::EGET,RHTTPSession::GetTable()));
CleanupClosePushL(trans1);
iTransArray.Append(trans1);
CleanupStack::Pop(&trans1);
up.Parse(KHttpUrl2);
RHTTPTransaction trans2 = iSession.OpenTransactionL(up, *this, strP.StringF(HTTP::EGET,RHTTPSession::GetTable()));
CleanupClosePushL(trans2);
iTransArray.Append(trans2);
CleanupStack::Pop(&trans2);
up.Parse(KHttpUrl3);
RHTTPTransaction trans3 = iSession.OpenTransactionL(up, *this, strP.StringF(HTTP::EGET,RHTTPSession::GetTable()));
CleanupClosePushL(trans3);
iTransArray.Append(trans3);
CleanupStack::Pop(&trans3);
for(TInt i=0; i<iTransArray.Count(); i++)
{
iTransArray[i].SubmitL();
iOpenTransCount++;
}
}
COCSPTransportDefault::TTransportScheme COCSPTransportDefault::IdentifySchemeL(const TDesC8& aURI)
{
TTransportScheme ret = ETransportSchemeNotSupported;
TUriParser8 uri;
TInt error = uri.Parse(aURI);
if (error != KErrNone || !uri.IsPresent(EUriScheme))
{
return ret;
}
const TPtrC8 scheme = uri.Extract(EUriScheme);
RStringPool stringPool;
stringPool.OpenL();
CleanupClosePushL(stringPool);
RStringF schemeF = stringPool.OpenFStringL(scheme);
CleanupClosePushL(schemeF);
RStringF httpF = stringPool.OpenFStringL(KHttpString);
CleanupClosePushL(httpF);
if (schemeF == httpF)
{
ret = ETransportSchemeHTTP;
}
CleanupStack::PopAndDestroy(3); // close httpF, schemeF, stringPool
return ret;
}
/**
@SYMTestCaseID SYSLIB-BAFL-CT-0488
@SYMTestCaseDesc Tests for defect number DEF043985
@SYMTestPriority High
@SYMTestActions Tests that the table is invalid when creating an RString
Check for panic
@SYMTestExpectedResults Tests must not fail
@SYMREQ REQ0000
*/
TInt RStringPoolPanicTest::DEF043985_StringTest_ThreadL(TAny*)
{
__UHEAP_MARK;
RStringPool stringPool;
stringPool.OpenL();
// Create a table and make it so it passes some internal tests
// for validity as we are testing a particular internal test
TStringTable testTable;
testTable.iCaseSensitive = ETrue;
testTable.iCount = 1;
// Test for Panic
RString testString = stringPool.String(0, testTable);
// Test should never get this far as it Panics
testString.Close();
stringPool.Close();
__UHEAP_MARKEND;
return KErrNone;
}
void UPPayHttpConnection::AddHeaderL(RHTTPHeaders aHeaders, TInt aHeaderField, const TDesC8& aHeaderValue)
{
RStringPool stringPool = iSession.StringPool();
RStringF valStr = stringPool.OpenFStringL(aHeaderValue);
THTTPHdrVal headerVal(valStr);
aHeaders.SetFieldL(stringPool.StringF(aHeaderField, RHTTPSession::GetTable()), headerVal);
valStr.Close();
}
TBool CUPnPArgument::Validate(const RStringPool& aStringPool, const TStringTable& aStringTable ) const
{
TBool result=EFalse;
if( (Property(aStringPool.String(UPNPDESCRIPTIONXMLTAGS::EName, aStringTable)).Length()!=0) &&
(Property(aStringPool.String(UPNPDESCRIPTIONXMLTAGS::EArgumentDirection, aStringTable)).Length()!=0) &&
(Property(aStringPool.String(UPNPDESCRIPTIONXMLTAGS::ERelatedStateVar, aStringTable)).Length()!=0))
result = ETrue;
return result;
}
// ----------------------------------------------------------------------------
// CWmDrmDlaDefaultHttpManager::SetHeaderL
// ----------------------------------------------------------------------------
void CWmDrmDlaDefaultHttpManager::SetHeaderL(
RHTTPHeaders& aHeaders,
TInt aHdrField,
const TDesC8& aHdrValue ) const
{
RStringPool pool = iHttpSession.StringPool();
RStringF valStr = pool.OpenFStringL( aHdrValue );
CleanupClosePushL( valStr );
THTTPHdrVal val( valStr );
aHeaders.SetFieldL( HTTP_STRING( aHdrField ), val );
CleanupStack::PopAndDestroy( &valStr ); // Close
}
TBool CTestTransaction::AddAcceptHeaderL(RHTTPHeaders &aHeaders, RStringPool &aStrPool)
{
// some tests may require specific 'Accept' parameters
TBuf8<KMaxAcceptLengthSize> acceptBuf;
acceptBuf.Copy(Machine()->GetDefine(KITHAccept));
RStringF accept = (acceptBuf.Length() == 0) ?
aStrPool.StringF(HTTP::EAnyAny, RHTTPSession::GetTable()) : aStrPool.OpenFStringL(acceptBuf);
THTTPHdrVal acceptHdr(accept);
aHeaders.SetFieldL(aStrPool.StringF(HTTP::EAccept, RHTTPSession::GetTable()), acceptHdr);
accept.Close();
return ETrue;
}
void CHTTPTest::DoTestsL()
{
testHarness->StartTestL(_L("Creating the string pool"));
RStringPool pool;
pool.OpenL(table);
testHarness->EndTest(0);
testHarness->StartTestL(_L("Creating 'hello'"));
STRDCI_L(hello, KHello);
RStringF def;
testHarness->EndTest(hello == def);
testHarness->StartTestL(_L("Creating another 'hello'"));
ASTRDCI_L(hello1, KHello1);
testHarness->EndTest(!(hello == hello1.iObj));
testHarness->StartTestL(_L("Testing !="));
testHarness->EndTest(hello != hello1.iObj);
testHarness->StartTestL(_L("Creating 'goodbye'"));
STRDCI_L(goodbye, KGoodbye);
testHarness->EndTest(hello == goodbye);
testHarness->StartTestL(_L("Creating string tokens"));
RStringTokenF h1, h2(hello), g;
h1 = hello;
testHarness->EndTest(h1 != h2);
testHarness->StartTestL(_L("Testing == on string tokens"));
testHarness->EndTest(!(h1 == h2));
testHarness->StartTestL(_L("Making a string from a token"));
hello1.iObj = pool.StringF(h1);
testHarness->EndTest(hello != hello1.iObj);
testHarness->StartTestL(_L("Non-equal tokens"));
g = goodbye;
testHarness->EndTest(hello == goodbye);
testHarness->StartTestL(_L("Operator != on non-equal tokens"));
testHarness->EndTest(!(hello != goodbye));
testHarness->StartTestL(_L("Copy function"));
hello1.iObj = hello.Copy();
testHarness->EndTest(hello != hello1.iObj);
testHarness->StartTestL(_L("String extraction (same)"));
testHarness->EndTest(static_cast<const TDesC8&>(hello).Compare(hello1.iObj));
testHarness->StartTestL(_L("String extraction (different)"));
testHarness->EndTest(!static_cast<const TDesC8&>(hello).Compare(goodbye));
testHarness->StartTestL(_L("String extraction (original)"));
testHarness->EndTest(static_cast<const TDesC8&>(hello).Compare(KHello));
testHarness->StartTestL(_L("Closing pool"));
hello.Copy();
hello.Close();
hello.Close();
hello1.iObj.Close();
// The copys here have got a bit confused
hello1.iObj.Close();
goodbye.Close();
pool.CloseAll();
testHarness->EndTest(0);
}
// -----------------------------------------------------------------------------
// LocalHostCheckL
// If the host is a local host, then remove the proxy property. Returns ETrue
// if the transaction request URI was for a localhost.
// -----------------------------------------------------------------------------
//
TBool LocalHostCheckL(RHTTPTransaction& aTransaction, RStringPool& aStringPool)
{
_LIT8(KLoopbackIPv4Url, "http://127.0.0.1");
RHTTPRequest request = aTransaction.Request();
TUriC8 uri = request.URI();
TUriParser8 parserLoopBack;
parserLoopBack.Parse(KLoopbackIPv4Url());
TInt match = parserLoopBack.Compare(uri, EUriHost);
if (KErrNone != match)
{
_LIT8(KLocalHostUrl, "http://localhost");
// try another compare - compare against the "localhost".
TUriParser8 parserLocalHost;
parserLocalHost.Parse(KLocalHostUrl());
match = parserLocalHost.Compare(uri, EUriHost);
if (KErrNone == match)
{
_LIT8(KLoopbackIPv4, "127.0.0.1");
// "localhost" resolves to "::1", manually, replace with "127.0.0.1"
CUri8* newUri = CUri8::NewLC(uri);
newUri->SetComponentL(KLoopbackIPv4(), EUriHost);
request.SetURIL(newUri->Uri());
CleanupStack::PopAndDestroy(newUri);
}
}
if (KErrNone == match)
{
// request is for localhost, explicitly state that this transaction
// must not be sent to proxy.
RStringF proxyUsageStrF = aStringPool.StringF(HTTP::EProxyUsage,
RHTTPSession::GetTable());
RStringF dontUseProxyStrF = aStringPool.StringF(HTTP::EDoNotUseProxy,
RHTTPSession::GetTable());
aTransaction.PropertySet().RemoveProperty(proxyUsageStrF);
aTransaction.PropertySet().SetPropertyL(proxyUsageStrF, dontUseProxyStrF);
//RStringF proxyAddrStrF = aStringPool.StringF(HTTP::EProxyAddress,
// RHTTPSession::GetTable());
//aTransaction.PropertySet().RemoveProperty(proxyAddrStrF);
return ETrue;
}
return EFalse;
}
// -----------------------------------------------------------------------------
// CSdpConnectionField::InternalizeL
// Internalizes the object from stream
// -----------------------------------------------------------------------------
//
CSdpConnectionField* CSdpConnectionField::InternalizeL(
RReadStream& aStream )
{
TUint32 length;
CSdpConnectionField* obj = NULL;
RStringPool pool = SdpCodecStringPool::StringPoolL();
// address
length = aStream.ReadUint32L();
HBufC8* address = HBufC8::NewLC( length );
TPtr8 ptr( address->Des() );
aStream.ReadL( ptr, length );
// TTL
TInt ttl = aStream.ReadInt32L();
// Number of addresses
TInt numOfAddr = aStream.ReadInt32L();
// Network type
length = aStream.ReadUint32L();
HBufC8* netType = HBufC8::NewLC( length );
ptr.Set( netType->Des() );
aStream.ReadL( ptr, length );
// Address type
length = aStream.ReadUint32L();
HBufC8* addrType = HBufC8::NewLC( length );
ptr.Set( addrType->Des() );
aStream.ReadL( ptr, length );
TInetAddr addr;
HBufC* address16 = HBufC::NewLC( address->Length() ) ;
address16->Des().Copy( *address );
TInt err = addr.Input( *address16 );
if ( !err )
{
// Create connection field based on TInetAddr
obj = CSdpConnectionField::NewL( addr, ttl, numOfAddr );
}
else
{
// Create connection field from buffer, ttl & numOfAddr
// are in this case irrelevant
RStringF netTypeStr = pool.OpenFStringL( *netType );
CleanupClosePushL( netTypeStr );
RStringF addrTypeStr = pool.OpenFStringL( *addrType );
CleanupClosePushL( addrTypeStr );
obj = CSdpConnectionField::NewL( netTypeStr, addrTypeStr, *address );
CleanupStack::PopAndDestroy( 2 ); // netTypeStr, addrTypeStr
}
CleanupStack::PopAndDestroy( 4 ); // address, netType, addrType, address16
return obj;
}
// -----------------------------------------------------------------------------
// TSdpTypedTime::DecodeL
// Decodes typed time from TDesC
// -----------------------------------------------------------------------------
//
TSdpTypedTime TSdpTypedTime::DecodeL(const TDesC8& aText)
{
TLex8 typedTimeLex(aText);
TSdpTypedTime typedTime;
User::LeaveIfError(typedTimeLex.Val(typedTime.iValue, EDecimal));
if (typedTimeLex.Peek() != 0)
{
TPtrC8 unitString = typedTimeLex.NextToken();
RStringPool pool = SdpCodecStringPool::StringPoolL();
const TDesC8& timeDays = pool.StringF(
SdpCodecStringConstants::ETimeUnitDays,
SdpCodecStringConstants::Table).DesC();
const TDesC8& timeHours = pool.StringF(
SdpCodecStringConstants::ETimeUnitHours,
SdpCodecStringConstants::Table).DesC();
const TDesC8& timeMinutes = pool.StringF(
SdpCodecStringConstants::ETimeUnitMinutes,
SdpCodecStringConstants::Table).DesC();
const TDesC8& timeSeconds = pool.StringF(
SdpCodecStringConstants::ETimeUnitSeconds,
SdpCodecStringConstants::Table).DesC();
if (unitString.Compare(timeDays) == 0)
{
typedTime.iUnit = ETimeUnitDays;
}
else if (unitString.Compare(timeHours) == 0)
{
typedTime.iUnit = ETimeUnitHours;
}
else if (unitString.Compare(timeMinutes) == 0)
{
typedTime.iUnit = ETimeUnitMinutes;
}
else if (unitString.Compare(timeSeconds) == 0)
{
typedTime.iUnit = ETimeUnitSeconds;
}
else
{
User::Leave(KErrSdpCodecTypedTime);
}
}
else
{
typedTime.iUnit = ETimeUnitNone;
}
return typedTime;
}
TBool CHttpTestCaseGet12::GetCredentialsL(const TUriC8& aURI, RString aRealm, RStringF aAuthenticationType, RString& aUsername, RString& aPassword)
{
iEngine->Utils().LogIt(_L("Supplying credentials"));
iEngine->Utils().DumpData(aURI.UriDes());
iEngine->Utils().DumpData(aRealm.DesC());
iEngine->Utils().DumpData(aAuthenticationType.DesC());
_LIT8(KScooby, "scooby");
_LIT8(KDoo, "doo");
RStringPool p = aRealm.Pool();
aUsername = p.OpenStringL(KScooby);
aPassword = p.OpenStringL(KDoo);
return ETrue;
}
TBool CTestTransaction::SetContentLengthL(RHTTPHeaders &aHeaders, RStringPool &aStrPool)
{
TBuf8<KMaxContentLengthSize> contLengthBuf;
contLengthBuf.Copy(Machine()->GetDefine(KITHContentLength));
if (contLengthBuf.Length() != 0)
{
RStringF contLengthStr = aStrPool.OpenFStringL(contLengthBuf);
THTTPHdrVal contLength(contLengthStr);
aHeaders.SetFieldL(aStrPool.StringF(HTTP::EContentLength, RHTTPSession::GetTable()), contLength);
contLengthStr.Close();
}
return ETrue;
}
TBool CTestTransaction::AcceptEncodingL(RHTTPHeaders &aHeaders, RStringPool &aStrPool)
{
TBuf8<KMaxAcceptEncodingSize> acceptEncodingBuf;
acceptEncodingBuf.Copy(Machine()->GetDefine(KITHAcceptEncoding));
if (acceptEncodingBuf.Length() > 0)
{
RStringF acceptEncoding = aStrPool.OpenFStringL(acceptEncodingBuf);
THTTPHdrVal acceptEncodingHdr(acceptEncoding);
aHeaders.SetFieldL(aStrPool.StringF(HTTP::EAcceptCharset, RHTTPSession::GetTable()), acceptEncodingHdr);
acceptEncoding.Close();
}
return ETrue;
}
/**
validation
*/
TBool CUPnPStateVariable::Validate(const RStringPool& aStringPool, const TStringTable& aStringTable ) const
{
TBool result=ETrue;
// name cannot be of zero chars
if( (Property(aStringPool.String(UPNPDESCRIPTIONXMLTAGS::EName, aStringTable)).Length()!=0) &&
(Property(aStringPool.String(UPNPDESCRIPTIONXMLTAGS::EStateVariableDataType, aStringTable)).Length()!=0) &&
(Property(aStringPool.String(UPNPDESCRIPTIONXMLTAGS::ESendEvents, aStringTable)).Length()!=0) )
result = ETrue;
return result;
}
TBool CTestTransaction::SetUserAgentL(RHTTPHeaders &aHeaders, RStringPool &aStrPool)
{
// get the DEFINE for UserAgent
TBuf8<KMaxUserAgentSize> userAgentBuf;
userAgentBuf.Copy(Machine()->GetDefine(KITHUserAgent));
TInt iLen = userAgentBuf.Length();
// assign the selection
RStringF agent = (iLen == 0) ? aStrPool.OpenFStringL(KUserAgent) : aStrPool.OpenFStringL(userAgentBuf);
THTTPHdrVal userAgent(agent);
aHeaders.SetFieldL(aStrPool.StringF(HTTP::EUserAgent, RHTTPSession::GetTable()), userAgent);
agent.Close();
return ETrue;
}
// ---------------------------------------------------------------------------
// SdpUtil::EncodeBufferL
// Encodes headername and a value to the stream
// ---------------------------------------------------------------------------
//
void SdpUtil::EncodeBufferL(
const TDesC8& aValue,
TInt aIndex,
RWriteStream& aStream )
{
if( aValue.Length() != 0 )
{
RStringPool pool = SdpCodecStringPool::StringPoolL();
RStringF headername = pool.StringF( aIndex,
SdpCodecStringPool::StringTableL() );
aStream.WriteL( headername.DesC() );
aStream.WriteL( aValue );
aStream.WriteL( KCRLFStr );
}
}
// -----------------------------------------------------------------------------
// CHttpCacheManager::VSSRequestCheck
//
// -----------------------------------------------------------------------------
//
TBool CHttpCacheManager::VSSRequestCheckL( const RHTTPTransaction& aTrans,
const RHTTPHeaders& aHttpHeader,
const TDesC8& aUrl )
{
TBool VSSTransaction ( EFalse );
if ( iVSSCacheEnabled && HttpCacheUtil::VSSCacheContent( aUrl, iVSSWhiteList ) )
{
RStringPool strP = aTrans.Session().StringPool();
#ifdef __CACHELOG__
RHTTPHeaders headers ( aHttpHeader );
HBufC8* responseHeaderStr8 = HttpCacheUtil::HeadersToBufferLC( headers, strP );
HBufC* responseHeaderStr;
if( responseHeaderStr8 )
{
responseHeaderStr = HBufC::NewL( responseHeaderStr8->Length() );
responseHeaderStr->Des().Copy( responseHeaderStr8->Des() );
CleanupStack::PopAndDestroy(); // responseHeaderStr8;
TPtrC headerStr( responseHeaderStr->Des() );
HttpCacheUtil::WriteLog( 0, _L("========== VSS Header Start =========\n") );
HttpCacheUtil::WriteLog( 0, responseHeaderStr->Des() );
HttpCacheUtil::WriteLog( 0, _L("========== VSS Header End =========\n") );
delete responseHeaderStr;
}
#endif
TPtrC8 nameStr ( KVSSHeaderFieldName() );
RStringF VSSnameStr = strP.OpenFStringL( nameStr );
CleanupClosePushL<RStringF>( VSSnameStr);
THTTPHdrVal tempVal;
if ( aHttpHeader.GetField( VSSnameStr, 0, tempVal ) == KErrNone )
{
TPtrC8 valueStr ( KVSSHeaderFieldValue() );
RStringF VSSValueStr = strP.OpenFStringL( valueStr );
CleanupClosePushL<RStringF>( VSSValueStr );
if ( tempVal == VSSValueStr )
{
VSSTransaction = ETrue;
}
CleanupStack::PopAndDestroy(); // VSSValueStr
}
CleanupStack::PopAndDestroy(); // VSSnameStr
} //end if( iVSSCacheEnabled && HttpCacheUtil::VSSCacheContent( aUrl, iVSSWhiteList ) )
return VSSTransaction;
}
// ---------------------------------------------------------------------------
// TIRXMLElementFormat::CloseStringPoolL
// Closes the StringPool
// ---------------------------------------------------------------------------
//
void TIRXMLElementFormat::CloseStringPoolL( RStringPool& aStringPool )
{
IRLOG_DEBUG( "TIRXMLElementFormat::CloseStringPoolL" );
aStringPool.Close();
IRLOG_DEBUG( "TIRXMLElementFormat::CloseStringPoolL - Exiting." );
return;
}
void CHeaderDecode::ProcessHeadersL(RHTTPTransaction aTrans)
{
RStringPool stringPool = aTrans.Session().StringPool();
RHTTPHeaders headers = aTrans.Response().GetHeaderCollection();
THTTPHdrVal hdrVal;
//Check Content-Length header parameter is stored correctly
RStringF contentLengthStr = stringPool.StringF(HTTP::EContentLength, aTrans.Session().GetTable());
User::LeaveIfError(headers.GetField(contentLengthStr,0,hdrVal));
if(headers.FieldPartsL(contentLengthStr) != 1)
User::Leave(KErrArgument);
if (hdrVal.Int() != 6)
User::Leave(KErrArgument);
}
/**
This function is called to initiate the tests.
It may leave with one of the system-wide error codes.
*/
void CTextModeTestPostBodyChunks::DoRunL()
{
// Open the HTTP session
iSession.OpenL();
CleanupClosePushL(iSession);
RStringPool strP = iSession.StringPool();
// Open a POST transactions, specifying this object as the request body
// data supplier
TUriParser8 up;
HBufC8* newUrl8 = TSrvAddrVal::ReplaceHostNameL(KHttpPostBodyChunksUrl(), iIniSettingsFile);
CleanupStack::PushL(newUrl8);
TPtr8 newUrlPtr8 = newUrl8->Des();
up.Parse(newUrlPtr8);
iTransaction = iSession.OpenTransactionL(up, *this, strP.StringF(HTTP::EPOST,RHTTPSession::GetTable()));
RHTTPRequest rq = iTransaction.Request();
rq.SetBody(*this);
RHTTPHeaders hdr = rq.GetHeaderCollection();
THTTPHdrVal length(OverallDataSize());
hdr.SetFieldL(strP.StringF(HTTP::EContentLength,RHTTPSession::GetTable()), length);
THTTPHdrVal contType(strP.StringF(HTTP::EApplicationXWwwFormUrlEncoded, RHTTPSession::GetTable()));
hdr.SetFieldL(strP.StringF(HTTP::EContentType, RHTTPSession::GetTable()), contType);
// Create the delayed notifier
iReleaseTimer = CDelayedBodyDataNotifier::NewL(iTransaction);
CleanupStack::PushL(iReleaseTimer);
CActiveScheduler::Add(iReleaseTimer);
// Submit the transaction
iTransaction.SubmitL();
iFailureError = KErrNone;
CActiveScheduler::Start();
// Get the completion code and inform the engine. Anything other than
// HTTP/200 status is a failure for this test.
iEngine->SetCurrentStatusCode(iTransaction.Response().StatusCode());
iExpectedStatusCode = 200;
// Close anything opened
CleanupStack::PopAndDestroy(3, &iSession); // and iReleaseTimer, newUrl8;
// Check for failure error codes caught in MHFRunL
User::LeaveIfError(iFailureError);
}
TBool CHttpEventHandler::GetHdrVal( THTTPHdrVal& hdrVal, RStringPool& pool)
{
TBool retval = ETrue;
TPtrC8 auth_token((const TUint8*)"auth_token");
switch (hdrVal.Type())
{
case THTTPHdrVal::KStrFVal:
{
RStringF fieldNameStr = pool.StringF(hdrVal.StrF());
const TDesC8& fieldNameDesC = fieldNameStr.DesC();
if (iVerbose)
{
TBuf<CHttpConstants::KMaxHeaderValueLen> value;
value.Copy(fieldNameDesC.Left(CHttpConstants::KMaxHeaderValueLen));
iTest->Console()->Printf(_L("%S:\n"), &value);
}
if ( fieldNameDesC.Length() > 0 && fieldNameDesC.Compare(auth_token) )
iCookies.Append(fieldNameDesC);
else
retval = EFalse;
}
break;
case THTTPHdrVal::KStrVal:
{
RString fieldNameStr = pool.String(hdrVal.Str());
const TDesC8& fieldNameDesC = fieldNameStr.DesC();
if (iVerbose)
{
TBuf<CHttpConstants::KMaxHeaderValueLen> value;
value.Copy(fieldNameDesC.Left(CHttpConstants::KMaxHeaderValueLen));
iTest->Console()->Printf(_L("%S:\n"), &value);
}
if ( fieldNameDesC.Length() > 0 && fieldNameDesC.Compare(auth_token) )
iCookies.Append(fieldNameDesC);
else
retval = EFalse;
}
break;
}
return retval;
}
CHTTPSession::~CHTTPSession()
{
iSessionClosing = ETrue;
while (iTransactions.Count())
iTransactions[iTransactions.Count() - 1]->Close();
iTransactions.Close();
// We need a RHTTPSession to give to the filters, so fake one up
RHTTPSession s;
s.iImplementation = this;
// If there isn't a manager we must have failed to construct
// the session so there can't be any filters. So it's safe not
// to close them.
if (iManager)
{
RStringPool strP = iManager->StringPool();
for (TInt i = 0; i < iFilterQueue.Count(); i++)
{
THTTPFilterHandle h;
h.iValue = iFilterQueue[i].iHandle;
iFilterQueue[i].iFilter->MHFUnload(s, h);
strP.StringF(iFilterQueue[i].iHeader).Close();
strP.StringF(iFilterQueue[i].iName).Close();
}
iFilterQueue.Close();
}
delete iProtocolHandler;
delete iConnectionInfo;
delete iRequestSessionHeaders;
delete iResponseSessionHeaders;
delete iFilterConfigIter;
// Flush and close the filter arrays
iFilterInfoList.ResetAndDestroy();
iEComFilterInfoArray.ResetAndDestroy();
// No longer need the manager... the last session to close causes the manager
// (and string pool) to be deleted.
if (iManager)
iManager->Release();
// force ECOM to release all - final clean-up
REComSession::FinalClose();
}
AMInt32 SetSessionConnectionInfo(AMPVoid session)
{
REINTERPRET( RHTTPSession*, temp, session );
// Set the sessions connection info...
RStringPool strPool = temp->StringPool();
RHTTPConnectionInfo connInfo = temp->ConnectionInfo();
REINTERPRET( CNetworkAccessPoint*, NetworkAccessPoint, AMSocketIAPGet() );
// ...to use our socket server and connection
connInfo.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketServ,
RHTTPSession::GetTable() ), THTTPHdrVal (NetworkAccessPoint->GetRSocketServ().Handle()) );
// ...to use our connection
connInfo.SetPropertyL ( strPool.StringF(HTTP::EHttpSocketConnection,
RHTTPSession::GetTable() ),
THTTPHdrVal (REINTERPRET_CAST(TInt, &(NetworkAccessPoint->GetRConnection()))) );
}
