1 /*

     2 * Copyright (c) 2008-2008 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Tracks data transmitted through a network connection.

    15 *

    16 */

    17 

    18 #include <httpstringconstants.h>

    19 #include <mhttpdatasupplier.h>

    20 #include <rhttpheaders.h>

    21 #include "irdebug.h"

    22 

    23 #include "irdatatransfertracker.h"

    24 

    25 // The threshold in bytes after which notifications are sent to observers.

    26 const TInt KIRDataTransferTrackerThreshold = 104858;	// 0.1  MB = 104857.6 bytes (rounded)

    27 const TInt KIRDataTransferTrackerMiniThreshold = 1049;	// 0.01 MB = 1048.57 bytes (rounded)

    28 

    29 // The overhead in bytes per one HTTP header.

    30 const TInt KVRBytesPerHeaderOverhead = 2; // "\r\n"

    31 // The overhead in bytes per one header field in a request.

    32 const TInt KVRBytesPerHeaderFieldOverhead = 4; // ": \r\n"

    33 // The overhead in bytes per one header sent.

    34 const TInt KVRBytesPerHeaderSentOverhead = 4; // "  \r\n"

    35 // The overhead in bytes per one header received.

    36 const TInt KVRBytesPerHeaderReceivedOverhead = 3; // " \r\n"

    37 

    38 // ---------------------------------------------------------------------------

    39 // Two-phased constructor.

    40 // ---------------------------------------------------------------------------

    41 //

    42 CIRDataTransferTracker* CIRDataTransferTracker::NewL()

    43     {

    44 	IRLOG_DEBUG( "CIRDataTransferTracker::NewL - Entering");

    45     CIRDataTransferTracker* self = new ( ELeave ) CIRDataTransferTracker;

    46     CleanupStack::PushL( self );

    47     self->ConstructL();

    48     CleanupStack::Pop( self );

    49 	IRLOG_DEBUG( "CIRDataTransferTracker::NewL - Exiting");

    50     return self;

    51     }

    52 

    53 // ---------------------------------------------------------------------------

    54 // Constructor.

    55 // ---------------------------------------------------------------------------

    56 //

    57 CIRDataTransferTracker::CIRDataTransferTracker()

    58     {

    59 	IRLOG_DEBUG( "CIRDataTransferTracker::CIRDataTransferTracker - Entering");

    60 	bThresholdCrossed = EFalse;

    61 	IRLOG_DEBUG( "CIRDataTransferTracker::CIRDataTransferTracker - Exiting");

    62     }

    63 

    64 // ---------------------------------------------------------------------------

    65 // Second-phase constructor.

    66 // ---------------------------------------------------------------------------

    67 //

    68 void CIRDataTransferTracker::ConstructL() const

    69     {

    70     IRLOG_DEBUG( "CIRDataTransferTracker::ConstructL");

    71 	return;

    72     }

    73 

    74 // ---------------------------------------------------------------------------

    75 // Destructor.

    76 // ---------------------------------------------------------------------------

    77 //

    78 CIRDataTransferTracker::~CIRDataTransferTracker()

    79     {

    80     	IRLOG_DEBUG( "CIRDataTransferTracker::~CIRDataTransferTracker - Entering");

    81     	iObserver = NULL;

    82         IRLOG_DEBUG( "CIRDataTransferTracker::~CIRDataTransferTracker - Exiting");

    83 

    84     }

    85 

    86 // ---------------------------------------------------------------------------

    87 // From class MIRDataTransferTracker.

    88 // Sets the observer.

    89 // ---------------------------------------------------------------------------

    90 //

    91 void CIRDataTransferTracker::SetObserver( MIRDataTransferObserver* aObserver )

    92     {

    93     IRLOG_DEBUG( "CIRDataTransferTracker::SetObserver - Entering");

    94     iObserver = aObserver;

    95     IRLOG_DEBUG( "CIRDataTransferTracker::SetObserver - Exiting");

    96     }

    97 

    98 // ---------------------------------------------------------------------------

    99 // From class MIRDataTransferTracker.

   100 // Returns the current transferred data amounts.

   101 // ---------------------------------------------------------------------------

   102 //

   103 const MIRDataTransferTracker::TIRDataTransferPckg& CIRDataTransferTracker::TransferredData() const

   104     {

   105     IRLOG_DEBUG( "CIRDataTransferTracker::TIRDataTransferPckg");

   106     return iPckg;

   107     }

   108 

   109 // ---------------------------------------------------------------------------

   110 // From class MIRDataTransferTracker.

   111 // Binds this to track the supplied HTTP session.

   112 // ---------------------------------------------------------------------------

   113 //

   114 void CIRDataTransferTracker::BindL( RHTTPSession aSession, TIRTransferCategory aCategory )

   115     {

   116     IRLOG_DEBUG2( "CIRDataTransferTracker::BindL() - aCategory = %d", static_cast<TInt>( aCategory ) );

   117 

   118     aSession.ConnectionInfo().SetPropertyL(

   119         aSession.StringPool().StringF( HTTP::ESessionId, aSession.GetTable() ), 

   120         	THTTPHdrVal( aCategory ) );

   121     aSession.FilterCollection().AddFilterL(

   122         *this, THTTPEvent::EAnyTransactionEvent, MHTTPFilter::EClientFilters, RStringF() );

   123     IRLOG_DEBUG( "CIRDataTransferTracker::BindL - Exiting");

   124     }

   125 

   126 // ---------------------------------------------------------------------------

   127 // From class MIRDataTransferTracker.

   128 // Handles raw data transfers.

   129 // ---------------------------------------------------------------------------

   130 //

   131 void CIRDataTransferTracker::RawDataTransferredL( TInt aBytesSent, TInt aBytesReceived, 

   132 												  TIRTransferCategory aCategory )

   133     {

   134     IRLOG_DEBUG( "CIRDataTransferTracker::RawDataTransferredL - Entering");

   135     ProcessDataL( aBytesSent, aBytesReceived, aCategory );

   136     IRLOG_DEBUG( "CIRDataTransferTracker::RawDataTransferredL - Exiting");

   137     }

   138 

   139 // ---------------------------------------------------------------------------

   140 // From class MHTTPFilter.

   141 // Invoked when HTTP transactions are sent or received.

   142 // ---------------------------------------------------------------------------

   143 //

   144 void CIRDataTransferTracker::MHFRunL(const RHTTPTransaction aTransaction, const THTTPEvent& aEvent)

   145     {

   146     IRLOG_DEBUG2( "CIRDataTransferTracker::MHFRunL() - aEvent.iStatus = %d", aEvent.iStatus );

   147 

   148     RHTTPSession session = aTransaction.Session();

   149 

   150     THTTPHdrVal categoryVal;

   151 

   152     if( session.ConnectionInfo().Property(

   153         session.StringPool().StringF( HTTP::ESessionId, session.GetTable() ), categoryVal ) )

   154         {

   155         TIRTransferCategory category = static_cast<TIRTransferCategory>( categoryVal.Int() );

   156 

   157         switch ( aEvent.iStatus )

   158             {

   159             case THTTPEvent::EGotResponseHeaders:

   160                 ParseHeaderSizeL( aTransaction, category );

   161                 break;

   162             case THTTPEvent::EGotResponseBodyData:

   163                 ParseBodySizeL( aTransaction, category );

   164                 break;

   165             default:

   166                 break;

   167             }

   168         }

   169     IRLOG_DEBUG( "CIRDataTransferTracker::MHFRunL - Exiting");

   170     }

   171 

   172 // ---------------------------------------------------------------------------

   173 // Calculates the header field sizes in bytes from the specified headers.

   174 // ---------------------------------------------------------------------------

   175 //

   176 TInt CIRDataTransferTracker::HeaderSize( const RHTTPTransaction aTransaction, 

   177 										 RHTTPHeaders aHeaders )

   178     {

   179     IRLOG_DEBUG( "CIRDataTransferTracker::HeaderSize - Entering");

   180     TInt size = KVRBytesPerHeaderOverhead;

   181 

   182     RStringPool stringPool = aTransaction.Session().StringPool();

   183 

   184     THTTPHdrFieldIter it = aHeaders.Fields();

   185     it.First();

   186 

   187     while ( !it.AtEnd() )

   188         {

   189         RStringF key = stringPool.StringF( it() );

   190 

   191         TPtrC8 ptr;

   192         aHeaders.GetRawField( key, ptr );

   193 

   194         size += key.DesC().Size();

   195         size += ptr.Size();

   196         size += KVRBytesPerHeaderFieldOverhead;

   197 

   198         ++it;

   199         }

   200     IRLOG_DEBUG( "CIRDataTransferTracker::HeaderSize - Exiting");

   201     return size;

   202 

   203     }

   204 

   205 // ---------------------------------------------------------------------------

   206 // Parses the header sizes (both request and response) of the supplied HTTP

   207 // transaction, logging it under the specified category.

   208 // ---------------------------------------------------------------------------

   209 //

   210 void CIRDataTransferTracker::ParseHeaderSizeL( const RHTTPTransaction aTransaction, 

   211 								   			   TIRTransferCategory aCategory )

   212     {

   213     IRLOG_DEBUG2( "CIRDataTransferTracker::ParseHeaderSizeL() - aCategory = %d", static_cast<TInt>( aCategory ) );

   214 

   215     RHTTPSession session = aTransaction.Session();

   216 

   217     // Parse the request size first.

   218 

   219     RHTTPRequest request = aTransaction.Request();

   220     TInt sent = HeaderSize( aTransaction, request.GetHeaderCollection() );

   221 

   222     // Now that the actual header fields are parsed we have to manually extract the original request.

   223     // The format of the request is "%S %S %S\r\n", where the first string is the method (GET or POST),

   224     // the second is the full URI of the request, and the third the HTTP protocol version in use.

   225 

   226     RStringF http = session.StringPool().StringF( HTTP::EHttp11, session.GetTable() );

   227 

   228     sent += request.Method().DesC().Size();

   229     sent += request.URI().UriDes().Size();

   230     sent += http.DesC().Size();

   231     sent += KVRBytesPerHeaderSentOverhead;

   232 

   233     // Proceed to parse the response size.

   234 

   235     RHTTPResponse response = aTransaction.Response();

   236     TInt received = HeaderSize( aTransaction, response.GetHeaderCollection() );

   237 

   238     // Now that the actual header fields of the response are parsed, we have to manually extract the

   239     // original response. The format of the response is "%S %d %S\r\n", where the first string is the HTTP

   240     // protocol version, the first integer is the HTTP status code, and the second string is the

   241     // status text.

   242 

   243     TBuf8<KDefaultRealWidth> responseCode;

   244     responseCode.AppendNum( static_cast<TInt64>( response.StatusCode() ) );

   245 

   246     received += session.StringPool().StringF( HTTP::EHttp11, session.GetTable() ).DesC().Size();

   247     received += responseCode.Size(); // Contains the byte for the trailing space as is, so need not add it as overhead below.

   248     received += response.StatusText().DesC().Size();

   249     received += KVRBytesPerHeaderReceivedOverhead;

   250 

   251     ProcessDataL( sent, received, aCategory );

   252     IRLOG_DEBUG( "CIRDataTransferTracker::ParseHeaderSizeL - Exiting");

   253 

   254     }

   255 

   256 // ---------------------------------------------------------------------------

   257 // Parses the body size of the supplied HTTP transaction, logging it under the specified category.

   258 // ---------------------------------------------------------------------------

   259 //

   260 void CIRDataTransferTracker::ParseBodySizeL(const RHTTPTransaction aTransaction, 

   261 											TIRTransferCategory aCategory )

   262     {

   263     IRLOG_DEBUG2( "CIRDataTransferTracker::ParseBodySizeL() - aCategory = %d", static_cast<TInt>(aCategory) );

   264 

   265     ASSERT( aTransaction.Response().HasBody() );

   266 

   267     TPtrC8 ptr;

   268     aTransaction.Response().Body()->GetNextDataPart( ptr );

   269 

   270     ProcessDataL( 0, ptr.Size(), aCategory );

   271     IRLOG_DEBUG( "CIRDataTransferTracker::ParseBodySizeL - Exiting");

   272     }

   273 

   274 // ---------------------------------------------------------------------------

   275 // Processes raw data sent and/or received via the connection.

   276 // ---------------------------------------------------------------------------

   277 //

   278 void CIRDataTransferTracker::ProcessDataL( TInt aBytesSent, TInt aBytesReceived, 

   279 										   TIRTransferCategory aCategory )

   280     {

   281     IRLOG_DEBUG4( "CIRDataTransferTracker::ProcessDataL() - aBytesSent = %d, aBytesReceived = %d, aCategory = %d",

   282         aBytesSent, aBytesReceived, static_cast<TInt>(aCategory) );

   283 

   284     switch ( aCategory )

   285         {

   286         case MIRDataTransferTracker::EIRTransferCategoryIsds:

   287             iPckg.iBytesSentIsds += aBytesSent;

   288             iPckg.iBytesReceivedIsds += aBytesReceived;

   289             break;

   290         case MIRDataTransferTracker::EIRTransferCategoryAudio:

   291             iPckg.iBytesSentAudio += aBytesSent;

   292             iPckg.iBytesReceivedAudio += aBytesReceived;

   293             break;

   294         default:

   295             iPckg.iBytesSentUnknown += aBytesSent;

   296             iPckg.iBytesReceivedUnknown += aBytesReceived;

   297             break;

   298         }

   299 

   300     iPckg.iBytesSentTotal += aBytesSent;

   301     iPckg.iBytesReceivedTotal += aBytesReceived;

   302 

   303     iBytesSinceLastNotification += aBytesSent + aBytesReceived;

   304 

   305     DispatchNotificationL();

   306     IRLOG_DEBUG( "CIRDataTransferTracker::ProcessDataL() - Exiting");

   307     }

   308 

   309 // ---------------------------------------------------------------------------

   310 // Dispatches the notification of the data transfer conditionally.

   311 // ---------------------------------------------------------------------------

   312 //

   313 void CIRDataTransferTracker::DispatchNotificationL()

   314     {

   315     IRLOG_DEBUG2( "CIRDataTransferTracker::DispatchNotificationL() - iBytesSinceLastNotif = %d",

   316         iBytesSinceLastNotification );

   317 

   318 	// Set flag when Byte Counter crosses first threshold 0.1 MB

   319 	if( bThresholdCrossed == EFalse && 

   320 		(iPckg.iBytesSentTotal+iPckg.iBytesReceivedTotal) >= KIRDataTransferTrackerThreshold )

   321 		bThresholdCrossed = ETrue;

   322 

   323 	// Smooth updates to each 0.01 MB

   324 	if( /*bThresholdCrossed == EFalse &&*/ iBytesSinceLastNotification >= KIRDataTransferTrackerMiniThreshold)

   325         {

   326         if ( iObserver )

   327             {

   328             iObserver->HandleDataTransferEventL( iPckg );

   329             }

   330         iBytesSinceLastNotification = 0;

   331         }

   332 

   333 

   334 	// Streaming updates to each 0.1 MB afterwards

   335     else if ( iBytesSinceLastNotification >= KIRDataTransferTrackerThreshold )

   336         {

   337         if ( iObserver )

   338             {

   339             iObserver->HandleDataTransferEventL( iPckg );

   340             }

   341         iBytesSinceLastNotification = 0;

   342         }

   343     IRLOG_DEBUG( "CIRDataTransferTracker::DispatchNotificationL() - Exiting");

   344 

   345     }