/** @file
* Copyright (c) 2005-2006 Nokia Corporation and/or its subsidiary(-ies). 
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies  this distribution, and is available 
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  CUpnpHttpChunkFileTransferReader is a class responsible for 
*                asynchronous TCP reading and controlling data
*
*/



#include "upnphttpsession.h"
#define KLogFile _L("DLNAWebServer.txt")
#include "upnpcustomlog.h"
#include "upnphttpfiletransferreader.h"
#include "upnphttpchunkfiletransferreader.h"
#include "upnphttpchunkparser.h"
#include "upnphttpfileaccess.h"
#include "inet6err.h"

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::NewL
// Factory method.
// ---------------------------------------------------------------------------
//
CUpnpHttpChunkFileTransferReader* CUpnpHttpChunkFileTransferReader::NewL( 
                                                    CUpnpTcpSession& aSession,
                                                    RSocket& aSocket,
                                                    TThreadPriority aPriority,
                                                    TInt aReadPortion,
                                                    TInt aBufferSize)
    {
    CUpnpHttpChunkFileTransferReader* self = new ( ELeave ) 
                    CUpnpHttpChunkFileTransferReader( aSession, aSocket,
                                             aPriority, aReadPortion, aBufferSize);
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }
    
// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::CUpnpHttpChunkFileTransferReader
// C++ constructor.
// ---------------------------------------------------------------------------
//
CUpnpHttpChunkFileTransferReader::CUpnpHttpChunkFileTransferReader( CUpnpTcpSession& aSession,
                                              RSocket& aSocket,
                                              TThreadPriority aPriority,
                                              TInt aReadPortion,
                                              TInt aBufferSize)
    :CUpnpHttpFileTransferReader( aSession, aSocket,
               aPriority, aReadPortion, aBufferSize + aReadPortion),
    iDecoded(0)
    {        
    }

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::ConstructL
// Two-phased constructor
// constructor that can leave. Used from derived classes.
// ---------------------------------------------------------------------------
//
void CUpnpHttpChunkFileTransferReader::ConstructL()
    {   
    BaseConstructL();
    
    iParser = CUpnpHttpChunkParser::NewL();
    }    
// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::~CUpnpHttpChunkFileTransferReader
// Destructor.
// ---------------------------------------------------------------------------
//
CUpnpHttpChunkFileTransferReader::~CUpnpHttpChunkFileTransferReader()
    {        
    delete iParser;    
    }

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::RemainingBytes
// Returns the remaining numbers of bytes to read
// ---------------------------------------------------------------------------
//
TInt CUpnpHttpChunkFileTransferReader::RemainingBytes()
    {
    if( !iSession.FileAccess() )
        return KErrNone;

    return ( iSession.FileAccess()->TransferTotal()-iSession.FileAccess()->BytesWritten() );
    }
    
// ---------------------------------------------------------------------------
// CUpnpHttpFileTransferReader::Start
// Starts reading.
// ---------------------------------------------------------------------------
//    
void CUpnpHttpChunkFileTransferReader::StartL()
    {    
    LOGS1( "%i, CUpnpHttpFileTransferReader::Start", iSession.Id() );
    
    // Initiate a new read from socket into iBuffer
    if ( !IsActive() )
    {
          
          //checks buffer buffer is not empty   
         if(iCacheBuffer.Length() > 0) 
            {
            //check buffer session should be finished
            iIsFinished = HandleL();
            if(iIsFinished)
                {
                Finish();

                if( iSession.FileAccess() )
                    iSession.FileAccess()->SetChunkCompleted( iIsFinished );
                }
            //if not issue reading
            else
                {
                IssueRead();
                iSession.StartTimeoutTimer(ETrue);
                }
        
            }
        else
            {
            IssueRead();
            }
        
    }
    } 

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::ReadBufferSize
// Returns the maximum size of bytes to read for once
// ---------------------------------------------------------------------------
//
TInt CUpnpHttpChunkFileTransferReader::ReadBufferSize()
    {
    return(AvailableSpace());
    }
        
// -----------------------------------------------------------------------------
// CUpnpHttpChunkParser::Parse
// Decoding the chunked-encoded buffer
// -----------------------------------------------------------------------------
//
TInt CUpnpHttpChunkFileTransferReader::Parse( TDes8& aBuffer, TInt& aPos )
    {    
    if( aPos >= aBuffer.Length() )
        {
        iParser->SetErrorState();
        return ETrue;
        }
    return iParser->Parse( aBuffer, aPos );
    }
    
// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::HandleL
// Handles data in buffer, returns if file transfer has finished
// ---------------------------------------------------------------------------
//
TBool CUpnpHttpChunkFileTransferReader::HandleL()
    {
    TInt error = KErrGeneral;
        
    error = Parse(iCacheBuffer, iDecoded);
            
    if( error == KErrNone && iSession.FileAccess() )
        {
        if ( iSession.FileAccess()->TransferTotal() == KErrNotFound )
            {
            iSession.FileAccess()->SetTransferTotal( 0 );
            }
        //parser finished decoding - writing all bytes
        if ( iParser->IsFinished() )
            {
            error = HandleReadDataL( iDecoded );
            }
        //buffer almost full - writing a fixed block of decoded data
        else if ( iBufferSize - iDecoded <= iReadBufferSize )
            {
            error = HandleReadDataL( iBufferSize - iReadBufferSize );
            }
    }
    iCacheBuffer.ReAllocL( iBufferSize );
    
    if( error != KErrNone )
        {        
        iSession.FileTransferReaderErrorL( error );
        return ETrue;
        }
    else if( iParser->IsFinished() )
        {
        if ( iSession.FileAccess() )
            {
            iSession.FileAccess()->SetChunkCompleted( ETrue );
            }
        iSession.FileTransferReaderDoneL();
        return ETrue;
        }
            
    return EFalse;
    }

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::HandleReadDataL
// Handles read data - trims the buffer and save data to file
// ---------------------------------------------------------------------------
//
TInt CUpnpHttpChunkFileTransferReader::HandleReadDataL( TInt aPieceToRead )
    {        
    //reads decoded data
    TPtr8 ptr = iCacheBuffer.LeftTPtr( aPieceToRead );
    
    //saves decoded data
    TInt error = iSession.FileAccess()->SaveL( ptr );
    iSession.FileAccess()->SetTransferTotal( 
        iSession.FileAccess()->TransferTotal() + aPieceToRead );
    
    //saved data are cut from buffer
    iCacheBuffer.Delete( 0, aPieceToRead );
  
    //position adjusted to the number of still encoded bytes        
    iDecoded -= aPieceToRead;			

    return error;
    }    

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::Finish
// On finishing the file transfer
// ---------------------------------------------------------------------------
//
void CUpnpHttpChunkFileTransferReader::Finish()
    {        
    CUpnpHttpFileTransferReader::Finish();    
    }    

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::RunL
// From class CActive.
// Function is called as a callback when the issued reading is completed.
// ---------------------------------------------------------------------------
//
void CUpnpHttpChunkFileTransferReader::RunL()
    {
    LOGS2( "%i, CUpnpHttpChunkFileTransferReader::RunL(), iStatus %i",
            iSession.Id(), iStatus.Int() );

    // Active object request complete handler
    switch ( iStatus.Int() )
        {
        case KErrNone:
            iRetryErrorCount = 0;
            iCancelTimer->Cancel();
 
           iSession.TimerCancel();
           iCacheBuffer.SetLength( iCacheBuffer.Length() + iLen() );            
           iIsFinished = HandleL();                                           
            
            if(!iIsFinished)
                {
                IssueRead();
                iSession.StartTimeoutTimer(ETrue);
                }
            else
                 Finish();                                     
            break;
        
        case KErrCancel:
            if(iCancelFromTimer) 
                {          
                IssueRead();
                iCancelFromTimer = EFalse;
                }
            break;
        case KErrEof:
            iSession.TimerCancel();
            iCacheBuffer.SetLength( iLen() );                    
            iIsFinished = HandleL();            
            
            if(iIsFinished)
                {
                iSession.HandleErrorL( iStatus.Int() );
                break;
                }
           case KErrNoMemory:
        case KErrNotReady:
        case KErrInet6AddressExpired:
            if( iRetryErrorCount < KMaxRetryErrors )
                {
                iRetryTimer->Cancel();
                iRetryTimer->After( KRetryWaitTime * ++iRetryErrorCount, EFalse );
                break;
                }         
            
        default:            
            iIsFinished = ETrue;
            iIsActivated = EFalse;            
            iSession.HandleErrorL( iStatus.Int() );
            break;
        }
        if( iSession.FileAccess() )
            iSession.FileAccess()->SetChunkCompleted( iIsFinished );
    }

// -----------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::RunError
// From CActive.
// Invoked when RunL leaves.
// -----------------------------------------------------------------------------
//
TInt CUpnpHttpChunkFileTransferReader::RunError( TInt aErr )
    {
    LOGS1("CUpnpHttpChunkFileTransferReader::RunError(%d)", aErr);
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::Reset
// Makes reader ready to start reading new content
// ---------------------------------------------------------------------------
//
void CUpnpHttpChunkFileTransferReader::Reset()
    {    
    iCacheBuffer.SetLength(0);
    iDecoded = 0;
    iParser->Reset();
    }

// ---------------------------------------------------------------------------
// CUpnpHttpChunkFileTransferReader::ReadFromSocket
// Reads from the socket
// ---------------------------------------------------------------------------
//
void CUpnpHttpChunkFileTransferReader::ReadFromSocket()
    {    
    Deque();
    CActiveScheduler::Add(this);
    
    iReceivePtr.Set( (TUint8*)iCacheBuffer.RightTPtr( 0 ).Ptr(), ReadBufferSize(), ReadBufferSize() );
    StartCancelTimer();
    iSocket.RecvOneOrMore( iReceivePtr,0,iStatus,iLen);       
    SetActive();
    }        
       
//  End of File