MCL/sf/mw/web: comparison webengine/osswebengine/cache/src/HttpCacheUtil.cpp

equal deleted inserted replaced

-:dd21522fd290
+:7c90e6132015
 *
 * Description:   Implementation of HttpCacheUtil
 *
 */
 // INCLUDE FILES
 #include "HttpCacheUtil.h"
 #include <http/rhttpheaders.h>
 #include <http/RHTTPTransaction.h>
 #include <http.h>
 age = Age( aCachedHeaders, cachedRequestTime, cachedResponseTime, aStrP );
 #ifdef __CACHELOG__
 TBuf<50> dateString;
 TTime fr( freshness );
-fr.FormatL( dateString, KDateString );
+TRAP(err, fr.FormatL( dateString, KDateString ) );
-HttpCacheUtil::WriteLog( 0, _L( "fresness" ) );
+if ( err == KErrNone ) {
-HttpCacheUtil::WriteLog( 0, dateString );
+HttpCacheUtil::WriteLog( 0, _L( "freshness" ) );
+HttpCacheUtil::WriteLog( 0, dateString );
+}
 TTime ca( age );
-ca.FormatL( dateString, KDateString );
+TRAP( err, ca.FormatL( dateString, KDateString ) );
-HttpCacheUtil::WriteLog( 0, _L( "age" ) );
+if ( err == KErrNone ) {
-HttpCacheUtil::WriteLog( 0, dateString );
+HttpCacheUtil::WriteLog( 0, _L( "age" ) );
+HttpCacheUtil::WriteLog( 0, dateString );
+}
 #endif // __CACHELOG__
 // Get useful cache-control directives from the requestHeaders
 status = GetCacheControls( aRequestHeaders, &maxAge, &minFresh, &maxStale, NULL, NULL, NULL, aStrP );
 if( status == KErrNone )
 TInt noStoreField( requestHeaders.GetField( fieldName, 0, headerVal ) );
 //
 return( noCacheField == KErrNone || noStoreField == KErrNone );
 }
 // -----------------------------------------------------------------------------
 // HttpCacheUtil::GetHeaderFileName
 //
 // -----------------------------------------------------------------------------
 //
 aHeaderFileName.Copy( aBodyFileName );
 // take the filename and append the new extension
 aHeaderFileName.Append( KHttpCacheHeaderExt() );
 }
 // -----------------------------------------------------------------------------
 // HttpCacheUtil::AdjustExpirationTime
 //
 // -----------------------------------------------------------------------------
 //
 const TStringTable& stringTable = RHTTPSession::GetTable();
 THTTPHdrVal hdrVal;
 if( aResponseHeaders.GetField( aStrP.StringF( HTTP::EExpires, stringTable ), 0, hdrVal ) == KErrNone )
 {
+TTime expDate( hdrVal.DateTime() );
+#ifdef __CACHELOG__
 HttpCacheUtil::WriteLog( 0, _L( "adjust expiration time from" ) );
-TTime expDate( hdrVal.DateTime() );
-#ifdef __CACHELOG__
 TBuf<50> dateString;
 TTime expTime( hdrVal.DateTime() );
 expTime.FormatL( dateString, KDateString );
 HttpCacheUtil::WriteLog( 0, dateString );
 #endif // __CACHELOG__
 // double it
 TTimeIntervalMinutes minutes;
 TTimeIntervalHours hours;
 TTime now;
 now.UniversalTime();
 if( expDate.MinutesFrom( now, minutes ) == KErrNone )
 {
 #ifdef __CACHELOG__
-//
 now.FormatL( dateString, KDateString );
 HttpCacheUtil::WriteLog( 0, _L( "current time" ) );
 HttpCacheUtil::WriteLog( 0, dateString );
 //
 now.FormatL( dateString, KDateString );
 HttpCacheUtil::WriteLog( 0, _L( "expires in (minutes)" ), minutes.Int() );
 #endif // __CACHELOG__
-//
 expDate+=minutes;
 }
 // minutes owerflow? take hours instead
 else if( expDate.HoursFrom( now, hours ) == KErrNone )
 {
 // check if this is a noncacheable content type
 if( respHeaders.GetField( fieldName, 0, contType ) == KErrNone &&
 contType.StrF() == strP.StringF( HttpFilterCommonStringsExt::EApplicationVndOmaDrm,
 HttpFilterCommonStringsExt::GetTable() ) )
 {
-HttpCacheUtil::WriteLog( 0, _L( "sensitive content. do not cache" ) );
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteLog( 0, _L( "HttpCacheUtil::IsCacheable - sensitive content. do not cache" ) );
+#endif
 // drm == nocache
 isCacheable = EFalse;
 }
 else
 {
 fieldName = strP.StringF( HTTP::EContentLength, RHTTPSession::GetTable() );
 if( respHeaders.GetField( fieldName, 0, contLen ) != KErrNotFound &&
 ( contLen.Type() == THTTPHdrVal::KTIntVal && contLen.Int() > aMaxSize ) )
 {
+#ifdef __CACHELOG__
 HttpCacheUtil::WriteLog( 0, _L( "oversized content. do not cache" ) );
+#endif
 // oversized content
 return EFalse;
 }
 // check if this is a proteced entry
 aProtectedEntry = ProtectedEntry( respHeaders, strP );
 // non-cachable.  Reject if they are present.
 //
 // If no-cache or no-store directives exist -> don't cache.
 if( noCache || noStore )
 {
-HttpCacheUtil::WriteLog( 0, _L( "no cache/no store header. do not cache" ) );
+#ifdef __CACHELOG__
+HttpCacheUtil::WriteLog( 0, _L( "HttpCacheUtil::IsCacheable - no cache/no store header. do not cache" ) );
+#endif
 // no protection on this entry
 aProtectedEntry = EFalse;
 return EFalse;
 }
 // Get the current time
 {
 #ifdef __CACHELOG__
 TBool log( aLogLevel <= KCurrentLogLevel );
 TPtrC fileName( KHttpCacheGeneralFileName );
-if( aLogLevel == 1 )
+if ( aLogLevel == 1 )
 {
-// hash
+// write logging to hash.txt
 fileName.Set( KHttpCacheHashFileName );
 log = ETrue;
 }
-if( log )
-{
+if ( log )
-if( aAny != 0xffff )
+{
+if ( aAny != 0xffff )
 {
 RFileLogger::WriteFormat(_L("Browser"), fileName, EFileLoggingModeAppend,
 _L("%S %d"), &aBuf, aAny );
 }
 else
 #else // __CACHELOG__
 (void)aLogLevel;
 (void)aBuf;
 (void)aAny;
 #endif // __CACHELOG__
+}
+// -----------------------------------------------------------------------------
+// HttpCacheUtil::WriteLogFilenameAndUrl
+//
+// -----------------------------------------------------------------------------
+//
+void HttpCacheUtil::WriteLogFilenameAndUrl(
+TInt aLogLevel,
+TPtrC aMethodName,
+const TPtrC aFilename,
+const TDesC8& aUrl,
+TInt aAny,
+TLogItemType aItemType )
+{
+#ifdef __CACHELOG__
+// Create a buffer for method name, filename, and url string
+_LIT(KColonSpace, " : ");
+_LIT(KSpace, " ");
+TInt itemTypeStringLen( 30 );
+TInt tmpLen( aMethodName.Length() + aFilename.Length() +
+3*KColonSpace().Length() + aUrl.Length() + itemTypeStringLen );
+HBufC* tmp = HBufC::New( tmpLen );
+if ( tmp ) {
+TPtr tmpPtr( tmp->Des() );
+tmpPtr.Copy( aMethodName );
+tmpPtr.Append( KColonSpace );
+TChar backSlash('\\');
+TInt filenamePos( aFilename.LocateReverse( TChar('\\') ) );
+if ( filenamePos > 0 ) {
+tmpPtr.Append( aFilename.Right( aFilename.Length() - filenamePos - 1 ) );
+tmpPtr.Append( KColonSpace );
+}
+// Convert url to TPtr
+HBufC* tmpUrl = HBufC::New( aUrl.Length() );
+if ( tmpUrl ) {
+TPtr tmpUrlPtr( tmpUrl->Des() );
+tmpUrlPtr.Copy( aUrl );
+TInt urlPos( tmpUrlPtr.LocateReverse( TChar('/') ) );
+if ( urlPos > 0 && (aUrl.Length()-2 > urlPos) ) {
+tmpPtr.Append( tmpUrlPtr.Right( aUrl.Length() - urlPos - 1 ) );
+tmpPtr.Append( KColonSpace );
+}
+else {
+tmpPtr.Append( tmpUrlPtr );
+tmpPtr.Append( KColonSpace );
+}
+}
+// Append the bucketIndex, lookup table pos, etc...
+switch ( aItemType )
+{
+case ELogItemTypeNone:
+break;
+case ELogBucketIndex:
+tmpPtr.Append( _L("bucketIndex =") );
+break;
+case ELogEntrySize:
+tmpPtr.Append( _L("entrySize =") );
+break;
+case ELogLookupTablePos:
+tmpPtr.Append( _L("lookupTable pos =") );
+break;
+case ELogFileErrorCode:
+tmpPtr.Append( _L("file errorCode =") );
+break;
+default:
+break;
+}
+HttpCacheUtil::WriteLog( aLogLevel, tmpPtr, aAny );
+delete tmp;
+delete tmpUrl;
+}
+#else // __CACHELOG__
+(void)aLogLevel;
+(void)aMethodName;
+(void)aFilename;
+(void)aUrl;
+(void)aAny;
+(void)aItemType;
+#endif
 }
 // -----------------------------------------------------------------------------
 // HttpCacheUtil::WriteUrlToLog
 //
 // The format is <cache base dir> + <subdirectory> + <file name>.
 // Caller must free the returned HBufC* when done.
 // -----------------------------------------------------------------------------
 HBufC* HttpCacheUtil::GenerateNameLC(
 const TDesC8& aUrl, const TDesC& aBaseDir)
 {
 TUint32 crc (0);
 //use the entire URL for CRC calculation: maximizes source entropy/avoids collisions
 Mem::Crc32(crc, aUrl.Ptr(), aUrl.Size());
 TUint32 nibble (crc & (KCacheSubdirCount-1)); // extract least significant 4 bits (nibble) for subdirectory
 HBufC* fileName = HBufC::NewLC( KMaxPath ); // e.g E\078AFEFE
 _LIT(KFormat,"%S%x%c%08x"); // Note the %08x : a 32-bit value can represented as 0xFFFFFFFF
 fileName->Des().Format(KFormat, &aBaseDir, nibble, KPathDelimiter, crc);
 return fileName;
 }
 // -----------------------------------------------------------------------------
 // HttpCacheUtil::Freshness
 {
 TTime now;
 TDateTime date;
 TTime time;
-// Int64 timeinsec;
 TInt64 correctedRecvAge;
 TInt64 apparentAge;
 TInt64 responseDelay;
 TInt64 correctedInitialAge;
 TInt64 residentTime;
 // Get the current time. All internet dates are GMT
 now.UniversalTime();
 #ifdef __CACHELOG__
 TBuf<50> dateString;
 //
-now.FormatL( dateString, KDateString );
+TRAP( err, now.FormatL( dateString, KDateString ) );
-HttpCacheUtil::WriteLog( 0, _L( "current time" ) );
+if ( err == KErrNone ) {
-HttpCacheUtil::WriteLog( 0, dateString );
+HttpCacheUtil::WriteLog( 0, _L( "current time" ) );
+HttpCacheUtil::WriteLog( 0, dateString );
+}
 #endif // __CACHELOG__
 // The aRequestTime is same as that of headers time.
 time = aRequestTime;
 }
 }
 else
 {
 aDirective = cacheDir.Copy();
-// Directives which MUST have values;
+// Directives which MUST have values
 if( ( aDirective == aStrP.StringF( HTTP::EMaxAge, RHTTPSession::GetTable() ) ) ||
 ( aDirective == aStrP.StringF( HTTP::EMinFresh, RHTTPSession::GetTable() ) ) ||
 ( aDirective == aStrP.StringF( HTTP::ESMaxAge, RHTTPSession::GetTable() ) ) )
 {
 aDirective.Close();

changeset 1	7c90e6132015
parent 0	dd21522fd290
child 10	a359256acfc6