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;
}
// -----------------------------------------------------------------------------
// 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;
}
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;
}
// -----------------------------------------------------------------------------
// 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;
}
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();
}
// ----------------------------------------------------------------------------
// 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
}
void CRefTestAgentManager::PrepareHTTPRequestHeadersL(RStringPool& aStringPool, RHTTPHeaders& aRequestHeaders) const
{
// Add the accept header for the reference test agent
TBuf8 <KMaxDataTypeLength> mimeType;
// Add accept header for Content only files
mimeType.Copy(KRtaMimeContent());
RStringF valStr = aStringPool.OpenFStringL(mimeType);
CleanupClosePushL(valStr);
THTTPHdrVal val1(valStr);
aRequestHeaders.SetFieldL(aStringPool.StringF(HTTP::EAccept, RHTTPSession::GetTable()), val1);
CleanupStack::PopAndDestroy(&valStr);
// Add accept header for content and rights files
mimeType.Copy(KRtaMimeContentRights());
valStr = aStringPool.OpenFStringL(mimeType);
CleanupClosePushL(valStr);
THTTPHdrVal val2(valStr);
aRequestHeaders.SetFieldL(aStringPool.StringF(HTTP::EAccept, RHTTPSession::GetTable()), val2);
CleanupStack::PopAndDestroy(&valStr);
}
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;
}
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;
}
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::AddRequestBodyL( RHTTPHeaders &aHeaders,
RStringPool &aStrPool)
{
// the content type info will be in $ContentType$. If NULL or Empty then an error generated
TBuf8<KMaxContentTypeSize> contTypeBuf;
contTypeBuf.Copy(Machine()->GetDefine(KITHContentType));
if (contTypeBuf.Length() == 0)
return EFalse; //Error(KErrArgument, THA_KErrNoContentTypeDefined, &transmthd);
RStringF contTypeStr = aStrPool.OpenFStringL(contTypeBuf);
THTTPHdrVal contType(contTypeStr);
aHeaders.SetFieldL(aStrPool.StringF(HTTP::EContentType, RHTTPSession::GetTable()), contType);
contTypeStr.Close();
MHTTPDataSupplier *dataSupplier = this;
iTransaction.Request().SetBody(*dataSupplier);
return ETrue;
}
// ---------------------------------------------------------------------------
// CSdpCodecParseUtil::FirstLineArrayElementL
// ---------------------------------------------------------------------------
//
RArray<TPtrC8> CSdpCodecParseUtil::FirstLineArrayElementL(RStringPool aPool,
TInt aIndex,
TInt aErrCode)
{
if(!iLineArray.Count())
{
User::Leave(aErrCode);
}
RArray<TPtrC8> elementArray =
SdpUtil::GetElementsFromLineL(iLineArray[0],aErrCode);
CleanupClosePushL(elementArray);
RStringF name = aPool.OpenFStringL(elementArray[0]);
CleanupClosePushL(name);
if(name!=(aPool.StringF(aIndex, SdpCodecStringConstants::Table)))
{
User::Leave(aErrCode);//parsererror
}
CleanupStack::Pop(2);//name, elementArray
name.Close();
return elementArray;
}
// ---------------------------------------------------------------------------
// CSdpCodecParseUtil::CheckFieldNameL
// ---------------------------------------------------------------------------
//
RArray<TPtrC8> CSdpCodecParseUtil::CheckFieldNameL(RStringPool aPool,
TInt aIndex,
const TDesC8& aValue,
TInt aErrCode)
{
if(!aValue.Length())
{
User::Leave(KErrArgument);
}
RArray<TPtrC8> elementArray = SdpUtil::GetElementsFromLineL(aValue,
aErrCode);
CleanupClosePushL(elementArray);
RStringF name = aPool.OpenFStringL(elementArray[0]);
CleanupClosePushL(name);
if(name!=(aPool.StringF(aIndex, SdpCodecStringConstants::Table)))
{
User::Leave(KErrArgument);//parsererror
}
CleanupStack::Pop(2);//name, elementArray
name.Close();
return elementArray;
}
// ---------------------------------------------------------------------------
// CSdpCodecParseUtil::CheckOptionalFieldNameL
// ---------------------------------------------------------------------------
//
RArray<TPtrC8> CSdpCodecParseUtil::CheckOptionalFieldNameL(RStringPool aPool,
TInt aIndex,
const TDesC8& aValue,
TInt aErrCode)
{
RArray<TPtrC8> elementArray;
elementArray.Reset();
if(aValue.Length())
{
elementArray = SdpUtil::GetElementsFromLineL(aValue, aErrCode);
CleanupClosePushL(elementArray);
RStringF name = aPool.OpenFStringL(elementArray[0]);
CleanupClosePushL(name);
if(name!=(aPool.StringF(aIndex, SdpCodecStringConstants::Table)))
{
elementArray.Reset();
}
CleanupStack::Pop(2);//name, elementArray
name.Close();
}
return elementArray;
}
// -----------------------------------------------------------------------------
// CSdpOriginField::InternalizeL
// Internalizes from stream
// -----------------------------------------------------------------------------
//
CSdpOriginField* CSdpOriginField::InternalizeL(
RReadStream& aStream )
{
RStringPool pool = SdpCodecStringPool::StringPoolL();
// <username>
TUint32 length = aStream.ReadUint32L();
HBufC8* userName = HBufC8::NewLC( length );
TPtr8 ptr( userName->Des() );
aStream.ReadL( ptr, length );
// <session id>
length = aStream.ReadUint32L();
HBufC8* sessionId = HBufC8::NewLC( length );
ptr.Set( sessionId->Des() );
aStream.ReadL( ptr, length );
// <version>
length = aStream.ReadUint32L();
HBufC8* version = HBufC8::NewLC( length );
ptr.Set( version->Des() );
aStream.ReadL( ptr, length );
// <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 );
// <address>
length = aStream.ReadUint32L();
HBufC8* address = HBufC8::NewLC( length );
TPtr8 ptr2( address->Des() );
aStream.ReadL( ptr2, length );
RStringF netTypeStr = pool.OpenFStringL( *netType );
RStringF addrTypeStr = pool.OpenFStringL( *addrType );
CleanupClosePushL( netTypeStr );
CleanupClosePushL( addrTypeStr );
CSdpOriginField* obj = CSdpOriginField::NewLC( *userName, KDummyValue,
KDummyValue, netTypeStr,
addrTypeStr, *address );
// Set the real values
obj->OriginFieldPtrs().SetSessionIdL( *sessionId );
obj->OriginFieldPtrs().SetSessionVersionL( *version );
CleanupStack::Pop( obj );
CleanupStack::Pop( 2 ); // addrTypeStr, netTypeStr
CleanupStack::PopAndDestroy( address );
CleanupStack::PopAndDestroy( addrType );
CleanupStack::PopAndDestroy( netType );
CleanupStack::PopAndDestroy( version );
CleanupStack::PopAndDestroy( sessionId );
CleanupStack::PopAndDestroy( userName );
return obj;
}
CResourceManager::EHttpSessionState CResourceManager::OpenHttpSessionIfNeededL(void* aKernel)
{
if (!m_IAPSeted || !m_IAPReady) {
((CNBrKernel*)aKernel)->RequestAP();
if (!m_IAPSeted)
return ENotSetIAP;
if (m_IAPSeted && !m_IAPReady)
return ENotReady;
}
if (!m_sessionRunning) {
m_httpSession.OpenL(KHttpProtString);
m_sessionRunning = true;
RStringPool strP = m_httpSession.StringPool();
const TStringTable& stringTable = RHTTPSession::GetTable();
RHTTPConnectionInfo connInfo = m_httpSession.ConnectionInfo();
if (m_bUseOutNetSettting) {
// 使用外壳提供的连接
if (iSocketServ)
connInfo.SetPropertyL(
strP.StringF(HTTP::EHttpSocketServ, RHTTPSession::GetTable()),
THTTPHdrVal(iSocketServ->Handle()) );
if (iConnection)
connInfo.SetPropertyL(
strP.StringF(HTTP::EHttpSocketConnection, RHTTPSession::GetTable()),
THTTPHdrVal(REINTERPRET_CAST(TInt, iConnection)) );
}
else {
// 使用内部连接
connInfo.SetPropertyL(
strP.StringF(HTTP::EHttpSocketServ, RHTTPSession::GetTable()),
THTTPHdrVal(m_socketServ.Handle()));
connInfo.SetPropertyL(
strP.StringF(HTTP::EHttpSocketConnection, RHTTPSession::GetTable()),
THTTPHdrVal(REINTERPRET_CAST(TInt, &(m_connection))));
}
if (m_isWap) {
RStringF iPrxAddr = strP.OpenFStringL(KHttpProxy);
CleanupClosePushL(iPrxAddr);
THTTPHdrVal iPrxUsage(strP.StringF(HTTP::EUseProxy, RHTTPSession::GetTable()));
connInfo.SetPropertyL(strP.StringF(HTTP::EProxyUsage, RHTTPSession::GetTable()), iPrxUsage);
connInfo.SetPropertyL(strP.StringF(HTTP::EProxyAddress, RHTTPSession::GetTable()), iPrxAddr);
CleanupStack::PopAndDestroy();
}
// set shutdown
THTTPHdrVal immediateShutdown = strP.StringF(HTTP::ESocketShutdownImmediate, stringTable);
connInfo.SetPropertyL(strP.StringF(HTTP::ESocketShutdownMode, stringTable), immediateShutdown);
// // set pipelining
// RStringF maxConnection = strP.StringF(HTTP::EMaxNumTransportHandlers, stringTable);
// connInfo.SetPropertyL(maxConnection, THTTPHdrVal(KHttpMaxConnectionNum));
//
// RStringF maxToPipeline = strP.StringF(HTTP::EMaxNumTransactionsToPipeline, stringTable);
// connInfo.SetPropertyL(maxToPipeline, THTTPHdrVal(KHttpMaxTransactionNumPerConnection));
// // Set optimal pipelining
// RStringF strOptimalPipelineVal = strP.StringF(HTTP::EHttpEnableOptimalPipelining, RHTTPSession::GetTable());
// connInfo.SetPropertyL(strP.StringF(HTTP::EHttpOptimalPipelining, RHTTPSession::GetTable()), strOptimalPipelineVal);
// set HTTP receive Buffer Size property
// RStringF receiveBuffSize = strP.StringF(HTTP::ERecvBufferSize, stringTable);
// connInfo.SetPropertyL(receiveBuffSize, THTTPHdrVal(KHttpReceiveBuffSize));
// // set HTTP batching enable
// THTTPHdrVal batchingSupport(strP.StringF(HTTP::EEnableBatching, RHTTPSession::GetTable()));
// connInfo.SetPropertyL(strP.StringF(HTTP::EHttpBatching, RHTTPSession::GetTable()), batchingSupport);
// // set HTTP batching Buffer Size property
// RStringF batchingBuffSize = strP.StringF(HTTP::EBatchingBufferSize, stringTable);
// connInfo.SetPropertyL(batchingBuffSize, THTTPHdrVal(KHttpBatchingBuffSize));
RHTTPFilterCollection filtColl = m_httpSession.FilterCollection();
RStringF filterName = m_httpSession.StringPool().StringF(HTTP::ERedirect,RHTTPSession::GetTable());
filtColl.RemoveFilter(filterName);
}
return EReady;
}
// ---------------------------------------------------------
// CMmsSession::OpenL
// ---------------------------------------------------------
//
EXPORT_C void CMmsSession::OpenL(
const TDesC8& aProxyAddress,
const TBool aUseProxy,
const TInt32 aMaxReceiveSize,
const TInt32 aMaxSendSize,
TRequestStatus& aStatus )
{
LOG( _L("CMmsSession::OpenL") );
__ASSERT_DEBUG( iSessionStatus == ESessionIdle, gPanic( EMmsAlreadyBusy ) );
iError = KErrNone;
iRequestStatus = &aStatus;
//
// Setting max send/receive sizes. 0 means not limited.
// Values always come from CMmsSettings.
//
iMaxReceiveSize = aMaxReceiveSize;
iMaxSendSize = aMaxSendSize;
// Get pointer HTTP session headers
iSessionHeaders = iHTTPSession.RequestSessionHeadersL();
iHeadersCreated = ETrue;
// Check if we are connected already
if ( iConnected )
{
aStatus = KRequestPending;
User::RequestComplete( iRequestStatus, KMmsErrorSessionAlreadyOpen );
}
else
{
// set the session properties
// the handle comes from iHTTP session. I think we should not close it.
RStringPool strPool = iHTTPSession.StringPool();
RHTTPConnectionInfo connInfo = iHTTPSession.ConnectionInfo();
connInfo.SetPropertyL( strPool.StringF( HTTP::EHttpSocketServ, RHTTPSession::GetTable() ),
THTTPHdrVal( iSocketServ->Handle() ) );
TInt connPtr = REINTERPRET_CAST( TInt, iConnection );
connInfo.SetPropertyL(
strPool.StringF( HTTP::EHttpSocketConnection, RHTTPSession::GetTable() ),
THTTPHdrVal( connPtr ) );
// Add proxy usage if requested
if ( aUseProxy )
{
THTTPHdrVal proxyUsage( strPool.StringF( HTTP::EUseProxy, RHTTPSession::GetTable() ) );
connInfo.SetPropertyL(
strPool.StringF( HTTP::EProxyUsage, RHTTPSession::GetTable() ), proxyUsage );
RStringF proxyString = strPool.OpenFStringL( aProxyAddress );
CleanupClosePushL( proxyString );
THTTPHdrVal proxyAddr( proxyString );
connInfo.SetPropertyL(
strPool.StringF( HTTP::EProxyAddress, RHTTPSession::GetTable() ), proxyAddr );
CleanupStack::PopAndDestroy( &proxyString );
}
// Install MMS X-id header filter if required
FeatureManager::InitializeLibL();
if ( FeatureManager::FeatureSupported( KFeatureIdMmsXidHeaderHttpFilter ) )
{
// Install the MMS X-id header filter explicitly, since only MMS requires this filter.
const TUid KHttpFilterMmsXidHeaderImplementationUid = { 0x1020738D };
CEComFilter::InstallFilterL(iHTTPSession, KHttpFilterMmsXidHeaderImplementationUid);
}
FeatureManager::UnInitializeLib();
// Install UAProf filter
TInt error = KErrNotFound;
TRAP( error, CHttpUAProfFilterInterface::InstallFilterL( iHTTPSession ) );
if ( error != KErrNone )
{
LOG2( _L("ERROR: UAProf filter left with code %d. Using hardcoded UserAgent string.."), error );
// Manually set UA string
SetFixedUserAgentL();
// UserAgent header must be added always - either hard coded string or string from ini file
SetHeaderL( iSessionHeaders, HTTP::EUserAgent, iUserAgent->Des() );
// Add UAProf if available
if ( iUaProf && iUaProf->Length() > 0 )
{
RStringF tempString = strPool.OpenFStringL( iUaProf->Des() );
CleanupClosePushL( tempString );
RStringF tempString2 = strPool.OpenFStringL( KXProfile );
CleanupClosePushL( tempString2 );
iSessionHeaders.SetFieldL( tempString2, tempString );
CleanupStack::PopAndDestroy( &tempString2 );
CleanupStack::PopAndDestroy( &tempString );
}
}
// Accept headers moved to transaction as global filter overrides
// session headers
// HTTP session, no need for separate connect procedure
iConnected = ETrue;
// We may or may not get
iHTTPSession.SetSessionEventCallback( this );
aStatus = KRequestPending;
User::RequestComplete( iRequestStatus, KErrNone );
}
}
