FCL/sf/mw/netprotocols: comparison httpfilters/cookie/ManagerSrc/Cookie.cpp

equal deleted inserted replaced

-:fa2fd8b2d6cc
+:2611c08ee28e
 #include <http/rhttpsession.h>
 #include <uri8.h>
 	// User includes
 #include "cookie.h"
+#include "cookielogger.h"
 #include "CookieCommonConstants.h"
 const TUint8 KDayOfWeekSeparator    = ',';
 // const TUint8 KTimeSeparator         = ':';
 _LIT8( KLocalSeparators, " -");
 _LIT8( KLocalTimeSeparator, ":");
 _LIT8( KLocalMonthNames, "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec" );
+#ifdef __TEST_COOKIE_LOG__
+static void LogCookieAttribute( const CCookie& aCookie, const RStringPool& aPool, TInt aId, const TDesC8& aTextName, CCookie::TCookieAttributeName aAttributeName )
+{
+_LIT(KDateFormat,"%D%M%Y%/0%1%/1%2%/2%3%/3 %:0%H%:1%T%:2%S.%C%:3");
+THTTPHdrVal fieldVal;
+const TInt attribErr = aCookie.Attribute( aAttributeName, fieldVal );
+if ( attribErr == KErrNone )
+{
+switch ( fieldVal.Type() )
+{
+case THTTPHdrVal::KTIntVal:
+CLOG( ( ECookie, 0, _L8( "{%3d}  [Int]  %S = (%d)"), aId, &aTextName, fieldVal.Int() ) );
+break;
+case THTTPHdrVal::KStrFVal:
+{
+RStringF fieldValStr = aPool.StringF( fieldVal.StrF() );
+const TDesC8& fieldValDesC = fieldValStr.DesC();
+CLOG( ( ECookie, 0, _L8( "{%3d}  [StrF] %S = (%S)"), aId, &aTextName, &fieldValDesC ) );
+}
+break;
+case THTTPHdrVal::KStrVal:
+{
+RString fieldValStr = aPool.String( fieldVal.Str() );
+const TDesC8& fieldValDesC = fieldValStr.DesC();
+CLOG( ( ECookie, 0, _L8( "{%3d}  [Str]  %S = (%S)"), aId, &aTextName, &fieldValDesC ) );
+}
+break;
+case THTTPHdrVal::KDateVal:
+{
+TDateTime date = fieldVal.DateTime();
+TBuf<40> dateTimeString;
+TTime t( date );
+TRAP_IGNORE( t.FormatL( dateTimeString, KDateFormat ) );
+TBuf8<40> dateTimeString8;
+dateTimeString8.Copy( dateTimeString );
+CLOG( ( ECookie, 0, _L8( "{%3d}  [Date] %S = (%S)"), aId, &aTextName, &dateTimeString8 ) );
+}
+break;
+default:
+CLOG(( ECookie, 0, _L8("{%3d}  [????] %S = (%d)"), aId, &aTextName, fieldVal.Type() ));
+break;
+}
+}
+else
+{
+//CLOG( ( ECookie, 0, _L8( "{%3d}  LogCookie - absent: %S"), aId, &aTextName ) );
+}
+}
+#endif
+// ---------------------------------------------------------
+// CCookie::Log
+// ---------------------------------------------------------
+//
+void CCookie::Log( TInt aAssociatedId ) const
+{
+	TInt associateId = aAssociatedId;
+	CLOG( ( ECookie, 0, _L( "-> CCookie::Log() - Associate Id:%d"), associateId ) );
+#ifdef __TEST_COOKIE_LOG__
+const TInt count = iAttributes.Count();
+CLOG( ( ECookie, 0, _L( "-> CCookie::Log() - %d attributes..."), count ) );
+for( TInt i=0; i<count; i++ )
+{
+// Calculating/fetching size is enough to generate usable logs
+const TCookieAttribute& attrib = iAttributes[ i ];
+const TInt size = attrib.Size();
+}
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Name"), CCookie::EName );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Value"), CCookie::EValue );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Domain"), CCookie::EDomain );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Path"), CCookie::EPath );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Date"), CCookie::EDate );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Version"), CCookie::EVersion );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Expires"), CCookie::EExpires );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("MaxAge"), CCookie::EMaxAge );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Discard"), CCookie::EDiscard );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Port"), CCookie::EPort );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Secure"), CCookie::ESecure );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Comment"), CCookie::EComment );
+LogCookieAttribute( *this, iStringPool, aAssociatedId, _L8("Comment URI"), CCookie::ECommentURI );
+CLOG( ( ECookie, 0, _L( "{%3d}         fromCookie2: %d, fromNetscapeVersion: %d"), aAssociatedId, FromCookie2(), FromNetscapeVersion() ) );
+CLOG( ( ECookie, 0, _L( "{%3d}         expired: %d, persists: %d, unknownVer: %d"), aAssociatedId, Expired(), Persistent(), IsUnknownVersion() ) );
+CLOG( ( ECookie, 0, _L( "<- CCookie::Log() - %d attributes..."), count ) );
+#endif
+}
 // ---------------------------------------------------------
 // CCookie::NewL
 // ---------------------------------------------------------
 //
 EXPORT_C CCookie* CCookie::NewL( RStringPool aStringPool )
 	{
 	return new (ELeave) CCookie( aStringPool );
 	}
+// ---------------------------------------------------------
+// CCookie::NewL
+// ---------------------------------------------------------
+//
+CCookie* CCookie::CloneL( const CCookie& aCopy )
+{
+CCookie* self = new(ELeave) CCookie( aCopy.iStringPool );
+CleanupStack::PushL( self );
+self->CopyFromL( aCopy );
+CleanupStack::Pop( self );
+return self;
+}
 // ---------------------------------------------------------
 // CCookie::~CCookie
 // ---------------------------------------------------------
 //
 EXPORT_C CCookie::~CCookie()
 	{
 	// go through each attribute closing any attribute strings
 	TInt numAttributes = iAttributes.Count();
+	Log();
+	CLOG( ( ECookie, 0, _L( "-> CCookie::~CCookie - this: 0x%08x, numAttributes: %d"), this, numAttributes ) );
 	for ( TInt ii = 0; ii < numAttributes; ++ii )
 		{
 		iAttributes[ii].Close();
 		}
 	iAttributes.Close();
+	CLOG( ( ECookie, 0, _L( "<- CCookie::~CCookie - this: 0x%08x, count: %d"), this, numAttributes ) );
 	}
 // ---------------------------------------------------------
 // CCookie::AddDefaultPathL
 // ---------------------------------------------------------
 //
 void CCookie::AddDefaultPathL( const TUriC8& aUri )
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::AddDefaultPathL") ) );
 	// RFC2965 : Defaults to the path of the request URL that generated the
 	// Set-Cookie2 response, up to and including the right-most /.
 	// Note : there is a contradiction as we must not include the right-most /
 	// per RFC2109, which is obsolete. Decision : we support RFC2965.
 	const TUint8 KCookiePathSeparator = '/';
 RStringF defPath = iStringPool.OpenFStringL( requestPath );
 THTTPHdrVal defPathVal( defPath );
 	SetAttribute( EPath, defPathVal, ETrue );// ignore the result
 defPath.Close();
+CLOG( ( ECookie, 0, _L( "<- CCookie::AddDefaultPathL") ) );
 	}
 // ---------------------------------------------------------
 // CCookie::AddToRequestL
 // ---------------------------------------------------------
 //
 EXPORT_C void CCookie::AddToRequestL( RHTTPHeaders aRequestHeaders,
 									 TInt aPartIndex ) const
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::AddToRequestL") ) );
 	const TStringTable& commonStringTable = RHTTPSession::GetTable();
 	// We're writing out the "Cookie:" string
 	RStringF cookieString =
 					iStringPool.StringF( HTTP::ECookie, commonStringTable );
 							hVal,
 							aPartIndex );
 		}
 	else
 		{
+		CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - version is missing! - iSetCookie2: %d"), iSetCookie2 ) );
 		if ( iSetCookie2 )
 			{
 			// if this is a new-style cookie (it is from a Set-Cookie2 header),
 			// then it must have a Version attribute.
 			// TBD : or should we insert a '$Version=1' string instead?
+			CLOG( ( ECookie, 0, _L( "<- CCookie::AddToRequestL - KErrCorrupt!") ) );
 			User::Leave( KErrCorrupt );
 			}
 		}
+	CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding name...") ) );
 	// We're writing out the NAME attribute - it is a serious error if this
 	// attribute is missing
 	User::LeaveIfError( Attribute( CCookie::EName, hVal ) );
 	aRequestHeaders.SetParamL( cookieString,
 							iStringPool.StringF( HTTP::ECookieName,
 												commonStringTable ),
 							hVal,
 							aPartIndex );
+	CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding value...") ) );
 	// We're writing out the VALUE attribute - it is a serious error if this
 	// attribute is missing
 	User::LeaveIfError( Attribute( CCookie::EValue, hVal ) );
 	aRequestHeaders.SetParamL( cookieString,
 							iStringPool.StringF( HTTP::ECookieValue,
 	// Writing out the rest : domain, path and port. These are not mandatory,
 	// thus we do not leave if they are missing.
 	// Writing out Domain attribute
 	if ( Attribute( CCookie::EDomain, hVal ) == KErrNone && hVal.StrF().DesC().Length() > 0 )
 {
+CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding domain...") ) );
 		aRequestHeaders.SetParamL( cookieString,
 								iStringPool.StringF( HTTP::EDomain,
 													commonStringTable ),
 								hVal,
 								aPartIndex );
 }
 	// Writing out Path attribute
 	if ( Attribute( CCookie::EPath, hVal ) == KErrNone )
 {
+CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding path...") ) );
 		aRequestHeaders.SetParamL( cookieString,
 								iStringPool.StringF( HTTP::EPath,
 													commonStringTable ),
 								hVal,
 								aPartIndex );
 }
 	// Writing out Port attribute
 	if ( Attribute( CCookie::EPort, hVal ) == KErrNone )
 {
+CLOG( ( ECookie, 0, _L( "CCookie::AddToRequestL - adding port...") ) );
 		aRequestHeaders.SetParamL( cookieString,
 								iStringPool.StringF( HTTP::ECookiePort,
 													commonStringTable ),
 								hVal,
 								aPartIndex );
 }
+	CLOG( ( ECookie, 0, _L( "<- CCookie::AddToRequestL") ) );
 	}
 // ---------------------------------------------------------
 // CCookie::Attribute
 //
 EXPORT_C TInt CCookie::Attribute
 							( CCookie::TCookieAttributeName aAttributeName,
 								THTTPHdrVal& aAttributeVal) const
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::Attribute") ) );
 	TCookieAttribute attribute;
 	if ( FindAttribute( aAttributeName, attribute ) != KErrNotFound )
 		{
 		aAttributeVal = attribute.Value();
+		CLOG( ( ECookie, 0, _L( "<- CCookie::Attribute") ) );
 		return KErrNone;
 		}
+	CLOG( ( ECookie, 0, _L( "<- CCookie::Attribute") ) );
 	return KErrNotFound;
 	}
 // ---------------------------------------------------------
 //
 TInt CCookie::Attribute( TCookieAttributeName aAttributeName,
 						 THTTPHdrVal& aAttributeVal,
 						 TBool& aDefaulted ) const
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::Attribute ") ) );
 	TCookieAttribute attribute;
 	if ( FindAttribute( aAttributeName, attribute ) != KErrNotFound )
 		{
 		aAttributeVal = attribute.Value();
 		aDefaulted = attribute.Defaulted();
+		CLOG( ( ECookie, 0, _L( "<- CCookie::Attribute KErrNone") ) );
 		return KErrNone;
 		}
+	CLOG( ( ECookie, 0, _L( "<- CCookie::Attribute KErrNotFound") ) );
 	return KErrNotFound;
 	}
 // ---------------------------------------------------------
 //
 TInt CCookie::SetAttribute(  TCookieAttributeName aAttributeName,
 							const THTTPHdrVal& aAttributeVal,
 							TBool aDefaulted )
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::SetAttribute") ) );
 	TInt result( KErrNone );
 	TCookieAttribute attribute;
 	TInt index = FindAttribute( aAttributeName, attribute );
 	if ( index != KErrNotFound )
 		else
 			{
 			newAttribute.Close();
 			}
 		}
+	CLOG( ( ECookie, 0, _L( "<- CCookie::SetAttribute result: %d"),result ) );
 	return result;
 }
 // ---------------------------------------------------------
 // CCookie::CopyFromL
 // ---------------------------------------------------------
 //
 void CCookie::CopyFromL( const CCookie& aCopyFrom  )
 {
-	THTTPHdrVal attributevalue;
+CLOG( ( ECookie, 0, _L( "-> CCookie::CopyFromL ") ) );
-TBool aDefaulted( EFalse );
+THTTPHdrVal attributevalue;
+TBool defaulted( EFalse );
-if ( aCopyFrom.Attribute( EName, attributevalue, aDefaulted ) != KErrNotFound )
+if ( aCopyFrom.Attribute( EName, attributevalue, defaulted ) != KErrNotFound )
 {
-SetAttribute( EName, attributevalue, aDefaulted );
+if ( attributevalue.Type() != THTTPHdrVal::KStrVal )
-}
+{
+RString correctedStringType = iStringPool.OpenStringL( attributevalue.StrF().DesC() );
-	if ( aCopyFrom.Attribute( EValue, attributevalue, aDefaulted ) != KErrNotFound )
+attributevalue.SetStr( correctedStringType );
-{
+SetAttribute( EName, attributevalue, defaulted );
-SetAttribute( EValue, attributevalue, aDefaulted );
+correctedStringType.Close();
-}
+const TPtrC8 pVal( attributevalue.Str().DesC() );
+CLOG( ( ECookie, 0, _L8( "CCookie::CopyFromL - attribute EName Value : %S" ), &pVal ) );
-	if ( aCopyFrom.Attribute( EComment, attributevalue, aDefaulted ) != KErrNotFound )
+}
-{
+else
-SetAttribute( EComment, attributevalue, aDefaulted );
+{
-}
+SetAttribute( EName, attributevalue, defaulted );
+}
-	if ( aCopyFrom.Attribute( ECommentURI, attributevalue, aDefaulted ) != KErrNotFound )
+}
-{
-SetAttribute( ECommentURI, attributevalue, aDefaulted );
+if ( aCopyFrom.Attribute( EValue, attributevalue, defaulted ) != KErrNotFound )
-}
+{
+if ( attributevalue.Type() != THTTPHdrVal::KStrVal )
-	if ( aCopyFrom.Attribute( EDiscard, attributevalue, aDefaulted ) != KErrNotFound )
+{
-{
+RString correctedStringType = iStringPool.OpenStringL( attributevalue.StrF().DesC() );
-SetAttribute( EDiscard, attributevalue, aDefaulted );
+attributevalue.SetStr( correctedStringType );
-}
+SetAttribute( EValue, attributevalue, defaulted );
+correctedStringType.Close();
-	if ( aCopyFrom.Attribute( EDomain, attributevalue, aDefaulted ) != KErrNotFound )
+const TPtrC8 pVal( attributevalue.Str().DesC() );
-{
+CLOG( ( ECookie, 0, _L8( "CCookie::CopyFromL - attribute EValue value: %S" ), &pVal ) );
-SetAttribute( EDomain, attributevalue, aDefaulted );
+}
-}
+else
+{
-	if ( aCopyFrom.Attribute( EMaxAge, attributevalue, aDefaulted ) != KErrNotFound )
+SetAttribute( EValue, attributevalue, defaulted );
-{
+}
-SetAttribute( EMaxAge, attributevalue, aDefaulted );
+}
-}
+	if ( aCopyFrom.Attribute( EComment, attributevalue, defaulted ) != KErrNotFound )
+{
-	if ( aCopyFrom.Attribute( EPath, attributevalue, aDefaulted ) != KErrNotFound )
+SetAttribute( EComment, attributevalue, defaulted );
-{
+}
-SetAttribute( EPath, attributevalue, aDefaulted );
-}
+	if ( aCopyFrom.Attribute( ECommentURI, attributevalue, defaulted ) != KErrNotFound )
+{
-	if ( aCopyFrom.Attribute( EPort, attributevalue, aDefaulted ) != KErrNotFound )
+SetAttribute( ECommentURI, attributevalue, defaulted );
-{
+}
-SetAttribute( EPort, attributevalue, aDefaulted );
-}
+	if ( aCopyFrom.Attribute( EDiscard, attributevalue, defaulted ) != KErrNotFound )
+{
-	if ( aCopyFrom.Attribute( ESecure, attributevalue, aDefaulted ) != KErrNotFound )
+SetAttribute( EDiscard, attributevalue, defaulted );
-{
+}
-SetAttribute( ESecure, attributevalue, aDefaulted );
-}
+	if ( aCopyFrom.Attribute( EDomain, attributevalue, defaulted ) != KErrNotFound )
+{
-	if ( aCopyFrom.Attribute( EVersion, attributevalue, aDefaulted ) != KErrNotFound )
+SetAttribute( EDomain, attributevalue, defaulted );
-{
+}
-SetAttribute( EVersion, attributevalue, aDefaulted );
-}
+	if ( aCopyFrom.Attribute( EMaxAge, attributevalue, defaulted ) != KErrNotFound )
+{
-	if ( aCopyFrom.Attribute( EExpires, attributevalue, aDefaulted ) != KErrNotFound )
+SetAttribute( EMaxAge, attributevalue, defaulted );
-{
+}
-SetAttribute( EExpires, attributevalue, aDefaulted );
-}
+	if ( aCopyFrom.Attribute( EPath, attributevalue, defaulted ) != KErrNotFound )
+{
-SetCookie2( aCopyFrom.FromCookie2() );
+SetAttribute( EPath, attributevalue, defaulted );
+}
+	if ( aCopyFrom.Attribute( EPort, attributevalue, defaulted ) != KErrNotFound )
+{
+SetAttribute( EPort, attributevalue, defaulted );
+}
+	if ( aCopyFrom.Attribute( ESecure, attributevalue, defaulted ) != KErrNotFound )
+{
+SetAttribute( ESecure, attributevalue, defaulted );
+}
+	if ( aCopyFrom.Attribute( EVersion, attributevalue, defaulted ) != KErrNotFound )
+{
+SetAttribute( EVersion, attributevalue, defaulted );
+}
+	if ( aCopyFrom.Attribute( EExpires, attributevalue, defaulted ) != KErrNotFound )
+{
+SetAttribute( EExpires, attributevalue, defaulted );
+}
+//SetCookie2( aCopyFrom.FromCookie2() );
+// Other properties
+iSetCookie2 = aCopyFrom.iSetCookie2;
+iNetscape = aCopyFrom.iNetscape;
+iSize = aCopyFrom.iSize;
+iReceivedTime = aCopyFrom.iReceivedTime;
+CLOG( ( ECookie, 0, _L( "<- CCookie::CopyFromL ") ) );
 }
 // CCookie::Expired
 // ---------------------------------------------------------
 //
 TBool CCookie::Expired() const
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::Expired ") ) );
 // the cookie has expired if:
 // 1. it's Age > Max-Age
 // 2. current_date > expires
 // Expires is in Netscape cookie only !!!
 }
 			}
 		}
+	CLOG( ( ECookie, 0, _L( "<- CCookie::Expired retval : %d"),retval ) );
 	return retval;
 	}
 // ---------------------------------------------------------
 // CCookie::RemoveQuotes
 // ---------------------------------------------------------
 //
 TPtrC8 CCookie::RemoveQuotes( const TDesC8& aDes )
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::RemoveQuotes ") ) );
 	TInt firstChar = 0;					// position of the first character
 	TInt lastChar = aDes.Length() - 1;	// position of the last character
 	TPtrC8 result;
 	if ( lastChar < 0 )	// that is, aDes has a length of zero
 		{
 		else
 			{
 			result.Set( aDes.Mid( firstChar, lastChar - firstChar + 1 ) );
 			}
 		}
+	CLOG( ( ECookie, 0, _L( "<- CCookie::RemoveQuotes result : %d "),result ) );
 return result;
 	}
 // CCookie::ExpiredNetscapeL
 // ---------------------------------------------------------
 //
 TBool CCookie::ExpiredNetscapeL( THTTPHdrVal aAttrVal) const
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::ExpiredNetscapeL ") ) );
 TBool retval( EFalse );
 TPtrC8 datePtr8( aAttrVal.StrF().DesC() );
 TInt dateLen( datePtr8.Length() );
 if( dateLen == 0 )
 {
 else  // invalid Date is expired!
 {
 retval = ETrue;
 }
 CleanupStack::PopAndDestroy( cleanupNum ); // temp1, temp2, desDate, desTime
+CLOG( ( ECookie, 0, _L( "<- CCookie::ExpiredNetscapeL retval : %d "),retval ) );
 return retval;
 }
 // ---------------------------------------------------------
 TInt CCookie::FindTokens( const TDesC8& aString,
 const TDesC8& aTokenSeparators,
 const TInt aTokenCount,
 TInt* aTokens ) const
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::FindTokens ") ) );
 TLex8 lex = aString;
 TChar ch;
 TInt tokenCount( 0 ), ii;
 for(ii=0; ii<aTokenCount; aTokens[ii++] = KErrNotFound) ;
 if( aTokenSeparators.Locate( ch ) != KErrNotFound )
 {
 aTokens[tokenCount++] = lex.Offset()-1;
 }
 }
+CLOG( ( ECookie, 0, _L( "<- CCookie::FindTokens tokenCount : %d"),tokenCount ) );
 return tokenCount;
 }
 // ---------------------------------------------------------
 // CCookie::Persistent
 // ---------------------------------------------------------
 //
 TBool CCookie::Persistent() const
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::Persistent ") ) );
 TBool result( EFalse );
 	THTTPHdrVal attrVal;
 if ( FromNetscapeVersion() )
 {
 result = ETrue;
 }
 }
 }
 }
+CLOG( ( ECookie, 0, _L( "<- CCookie::Persistent result : %d"),result ) );
 return result;
 }
 // ---------------------------------------------------------
 // CCookie::IsUnknownVersion
 // ---------------------------------------------------------
 //
 TBool CCookie::IsUnknownVersion() const
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::IsUnknownVersion ") ) );
 TBool unknownVersion( EFalse );
 THTTPHdrVal attrVal;
 if( Attribute( CCookie::EVersion, attrVal ) != KErrNotFound )
 {
 if( attrVal.StrF().DesC().Compare( KCookieKnownVersion() ) != 0 )
 {
 unknownVersion = ETrue;
 }
 }
+CLOG( ( ECookie, 0, _L( "<- CCookie::IsUnknownVersion unknownVersion : %d"),unknownVersion ) );
 return unknownVersion;
 }
 // ---------------------------------------------------------
 // CCookie::CCookie
 // ---------------------------------------------------------
 //
 CCookie::CCookie( RStringPool aStringPool )
 : iStringPool( aStringPool ), iSetCookie2( EFalse ), iNetscape( EFalse )
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::CCookie ") ) );
 	iReceivedTime.UniversalTime();
+	CLOG( ( ECookie, 0, _L( "<- CCookie::CCookie ") ) );
 	}
 // ---------------------------------------------------------
 // CCookie::ConstructL
 // ---------------------------------------------------------
 //
 void CCookie::ConstructL( RHTTPHeaders aRequestHeaders, TInt aPartIndex,
 						RStringF aFieldName, const TUriC8& aUri )
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::ConstructL ") ) );
 	const TStringTable& commonStringTable = RHTTPSession::GetTable();
 	// Determining if this object is constructed from a Set-Cookie2 HTTP header
 	RStringF setCookie2Name = iStringPool.StringF( HTTP::ESetCookie2,
 commonStringTable );
 {
 		        // if the Port attrib does not exist, leave it blank
 }
 }
 }
+CLOG( ( ECookie, 0, _L( "<- CCookie::ConstructL ") ) );
 	}
 // ---------------------------------------------------------
 // ---------------------------------------------------------
 //
 TInt CCookie::FindAttribute( TCookieAttributeName aAttributeName,
 							TCookieAttribute& aAttribute ) const
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::FindAttribute ") ) );
 	const TInt numAttributes = iAttributes.Count();
 	for ( TInt index = 0; index < numAttributes; ++index )
 		{
 		if ( iAttributes[index].Name() == aAttributeName )
 			{
 			aAttribute = iAttributes[index];
+			CLOG( ( ECookie, 0, _L( "<- CCookie::FindAttribute index : %d"),index ) );
 			return index;
 			}
 		}
+	CLOG( ( ECookie, 0, _L( "<- CCookie::FindAttribute KErrNotFound") ) );
 	return KErrNotFound;
 	}
 // ---------------------------------------------------------
 // CCookie::RemoveAttribute
 // ---------------------------------------------------------
 //
 void CCookie::RemoveAttribute( TInt aIndex )
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::RemoveAttribute aIndex : %d"),aIndex ) );
 	iSize -= ( KCookieAttributePrefixLength + iAttributes[ aIndex ].Size() +
 KCookieAttributeDefaultedLength +
 KCookieAttributeFoundLength );
 	iAttributes[ aIndex ].Close();
 	iAttributes.Remove( aIndex );
+	CLOG( ( ECookie, 0, _L( "<- CCookie::RemoveAttribute aIndex : %d"),aIndex ) );
 	}
 // ---------------------------------------------------------
 // CCookie::RemoveAttribute
 // ---------------------------------------------------------
 //
 void CCookie::RemoveAttribute( TCookieAttributeName aAttributeName )
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::RemoveAttribute - name: %d"), aAttributeName ) );
 TCookieAttribute attribute;
 TInt index( FindAttribute( aAttributeName, attribute ) );
 if( index != KErrNotFound )
 {
 RemoveAttribute( index );
 }
+CLOG( ( ECookie, 0, _L( "<- CCookie::RemoveAttribute - name: %d, index: %d"), aAttributeName, index ) );
 }
 // ---------------------------------------------------------
 // CCookie::GetLocalOffset
 // ---------------------------------------------------------
 //
 TInt CCookie::GetLocalOffset( HBufC8* aDate, TInt& aHour,
 TInt& aMinute, TInt& aLength ) const
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::GetLocalOffset ") ) );
 TInt retval( 0 );
 TInt pos(0);
 //    TInt fwspos(0);
 //    TBool plus( ETrue );
 TPtrC8 datePtr( aDate->Des() );
 lex.Val( aHour );
 TLex8 lex1(temp->Right(2));
 lex1.Val( aMinute );
 CleanupStack::PopAndDestroy( temp ); // temp
 }
+CLOG( ( ECookie, 0, _L( "<- CCookie::GetLocalOffset retval : %d "),retval ) );
 return retval;
 }
 // CCookie::GetMilitaryOffset
 // ---------------------------------------------------------
 //
 TInt CCookie::GetMilitaryOffset( HBufC8* /*aDate*/, TInt& aHour ) const
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::GetMilitaryOffset  ") ) );
 // TODO: Add military timezone handling here...
 TInt retval( KErrNotFound );
 aHour = 0;
+CLOG( ( ECookie, 0, _L( "<- CCookie::GetMilitaryOffset retval : %d "),retval ) );
 return retval;
 }
 // ---------------------------------------------------------
 //
 TInt CCookie::GetTimeZone( HBufC8* aDate, TInt& aHour,
 TInt& aLength ) const
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::GetTimeZone  ") ) );
 TInt retval( 0 );
 TInt zonepos = aDate->Find( KUT() );
 if ( zonepos != KErrNotFound )
 {
 aHour = 0;
 if ( zonepos != KErrNotFound )
 {
 // get the length
 aLength = aDate->Length() - zonepos;
 }
+CLOG( ( ECookie, 0, _L( "<- CCookie::GetTimeZone retval :%d "),retval ) );
 return retval;
 }
 // CCookie::GetCleanedDateTimeLC
 // ---------------------------------------------------------
 //
 HBufC8* CCookie::GetCleanedDateTimeLC( HBufC8* aDate ) const
 {
+CLOG( ( ECookie, 0, _L( "-> CCookie::GetCleanedDateTimeLC ") ) );
 // as http time might contain a "DayOfWeek," optional part
 // which is not understood by the parser, we need to
 // remove it
 TInt pos = aDate->Locate( KDayOfWeekSeparator );
 if ( pos < 0 )
 { // locale offset
 }
 *result = temp->Left( temp->Length() - length);
 // return ( temp->Left( temp->Length() - length).AllocLC() );
 CleanupStack::PopAndDestroy( temp );
+CLOG( ( ECookie, 0, _L( "-> CCookie::GetCleanedDateTimeLC result : %d"),result ) );
 return result;
 }
 											const THTTPHdrVal& aHdrVal,
 											TBool aDefaulted )
 : iName( aName ),
 iDefaulted( aDefaulted )
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::TCookieAttribute") ) );
 	iValue = aHdrVal.Copy();
 	switch ( iValue.Type() )
 		{
 		case THTTPHdrVal::KTIntVal :
 			{
 			iSize = sizeof( TInt );
+			CLOG( ( ECookie, 0, _L( "-> CCookie::TCookieAttribute iSize :%d "),iSize ) );
 			break;
 			}
 		case THTTPHdrVal::KStrVal :
 			{
 			iSize = iValue.Str().DesC().Length();
+			CLOG( ( ECookie, 0, _L( "-> CCookie::TCookieAttribute iSize :%d "),iSize ) );
 			break;
 			}
 		case THTTPHdrVal::KDateVal :
 			{
 			iSize = sizeof( TDateTime );
+			CLOG( ( ECookie, 0, _L( "-> CCookie::TCookieAttribute iSize :%d "),iSize ) );
 			break;
 			}
 		case THTTPHdrVal::KStrFVal :
 			{
 			iSize = iValue.StrF().DesC().Length();
+			CLOG( ( ECookie, 0, _L( "-> CCookie::TCookieAttribute iSize :%d "),iSize ) );
 			break;
 			}
 		default :	// THTTPHdrVal::KNoType
 			{
 			iSize = 0;
+			CLOG( ( ECookie, 0, _L( "-> CCookie::TCookieAttribute iSize :%d "),iSize ) );
 			}
 		}
+	CLOG( ( ECookie, 0, _L( "<- CCookie::TCookieAttribute  ") ) );
 	}
 // ---------------------------------------------------------
 // CCookie::TCookieAttribute::TCookieAttribute
 // ---------------------------------------------------------
 //
 CCookie::TCookieAttribute::TCookieAttribute()
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::TCookieAttribute  ") ) );
+	CLOG( ( ECookie, 0, _L( "<- CCookie::TCookieAttribute  ") ) );
 	}
 // ---------------------------------------------------------
 // CCookie::TCookieAttribute::Close
 // ---------------------------------------------------------
 //
 void CCookie::TCookieAttribute::Close()
 	{
+	CLOG( ( ECookie, 0, _L( "-> CCookie::Close  ") ) );
 	THTTPHdrVal::THTTPValType type = iValue.Type();
 	if ( type == THTTPHdrVal::KStrVal )
 		{
+		CLOG( ( ECookie, 0, _L( "-> CCookie::Close  KStrVal") ) );
 		iValue.Str().Close();
 		}
 	else if ( type == THTTPHdrVal::KStrFVal )
 		{
+		CLOG( ( ECookie, 0, _L( "-> CCookie::Close  KStrFVal") ) );
 		iValue.StrF().Close();
 		}
 	// TBD : iValue = THTTPHdrVal();?
 	iSize = 0;
+	CLOG( ( ECookie, 0, _L( "<- CCookie::Close  ") ) );
 	}
 // ---------------------------------------------------------
 // CCookie::TCookieAttribute::Name

branch	RCL_3
changeset 9	2611c08ee28e
parent 8	fa2fd8b2d6cc
child 10	73e95e652591