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 ); } }