// Copyright (c) 2008-2009 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:

// cptpipsockethandler.cpp

// 

//

/**

 @internalComponent

*/

#include "cptpipsockhandlerbase.h"

#include "cptpipconnection.h"

#include "ptpippanic.h"

const TUint32 KPTPIPHeaderSize = 8;

const TUint KMaxPacketSixe   = 16;

const TUint64 KMaxPTPIPPacketSize = 0x18FF4; // 100 KB - 12

//#define MTP_DEBUG_FLOG_HEX_DUMP

#define UNUSED_VAR(a) (a)=(a)

/**

Constructor 

*/

CPTPIPSocketHandlerBase::CPTPIPSocketHandlerBase(CPTPIPConnection& aConnection, TPriority priority ) : 

						CActive(priority),

						iChunkStatus(0),

						iSendChunkData(NULL, 0),

						iSendData(NULL, 0),

						iReceiveChunkData(NULL, 0),

						iPTPPacketLength(0),

						iState(EIdle),

						iPacketBuffer(NULL),

						iPacketSizeMax(NULL),

						iReceiveData(NULL, 0),

						iIsFirstChunk(EFalse),

						iPTPPacketLengthReceived(0),

						iReceiveDataCommit(EFalse),

						iSendHeaderData(NULL, 0),

						iPTPIPDataHeader(NULL),

						iConnection(aConnection),

						iReceiveDataSink(NULL),

						iSendDataSource(NULL),

						iCurrentChunkData(NULL,0,0)

	{

	CActiveScheduler::Add(this);

	}

/**

Second phase constructor.

*/

#ifdef __FLOG_ACTIVE    

void CPTPIPSocketHandlerBase::ConstructL(const TDesC8& aComponentName)

#else

void CPTPIPSocketHandlerBase::ConstructL()

#endif

    {

    __FLOG_OPEN(KMTPSubsystem, aComponentName);

    __FLOG(_L8("CSocketHandler::ConstructL - Entry"));

    iPacketSizeMax = KMaxPacketSixe; 

    iPacketBuffer.ReAllocL(iPacketSizeMax);

    iPTPIPDataHeader = CPTPIPDataContainer::NewL();

    __FLOG(_L8("CSocketHandler::ConstructL - Exit"));

    }

 /**

 Destructor

 */  

 CPTPIPSocketHandlerBase::~CPTPIPSocketHandlerBase()

 {

    __FLOG(_L8("CSocketHandler::~CSocketHandler - Entry"));

    Cancel();

    iPacketBuffer.Close();

    iSocket.Close();

    delete iPTPIPDataHeader;

    __FLOG(_L8("CSocketHandler::~CSocketHandler - Exit"));

    __FLOG_CLOSE;

 }

//

// CActive Functions

//

/**

 This will be called after every chunk is sent or received over the socket. 

*/

void CPTPIPSocketHandlerBase::RunL()

	{

	__FLOG(_L8("RunL - Entry"));

    __FLOG_VA((_L8("Current State is 0x%08X, and status is %d"), iState, iStatus.Int()));	

	switch ( DataStreamDirection() )

		{

	case EReceivingState:

        __FLOG_VA((_L8("Receive data completion status = %d"), iStatus.Int()));

        if (iState == EReceiveFastInProgress)

        	{

        	InitiateFirstChunkReceiveL(); 

        	}

        else if (iStatus != KErrNone)

            {

            // Abnormal completion.

            __FLOG_VA((_L8("PTPIP Error: Receive data completed with error = %d"), iStatus.Int()));

            SetState(EReceiveComplete);

            }

        else if (iState != EReceiveComplete)

            {

	        // Update the chunk data length. We use the iReceiveData variable with the socket 

	        // so only its length gets updated on receive. 

	        // However during remaining processing we use iReceiveChunkData, so update its len.

            iReceiveChunkData.SetLength(iReceiveChunkData.Length() + iReceiveData.Length());

            if (iIsFirstChunk)

	            {

	            // process the first chunk.

	            ProcessFirstReceivedChunkL();  

	            }

	        else

		        {

		        ResumeReceiveDataStreamL(); 

		        }

            }

        if (iState == EReceiveComplete)

            {             

            // Save the pointer to the last populated location on the current chunk            

            iCurrentChunkData.Set(iReceiveChunkData);             

            // Reset the receive data stream and notify the connection.

            MMTPType& data(*iReceiveDataSink);

            ResetReceiveDataStream();

            TRAPD(err, ReceiveDataCompleteL(iStatus.Int(), data));

            if (err != KErrNone)

            	{

            	__FLOG_VA((_L8("Framework threw an error from ReceiveDataCompleteL = %d"), err)); 

            	ReceiveDataCompleteL(err, data);

            	}

            }

        break;

	case ESendingState:

		// Special case for handling the sending of init ack, handled in the derived class.

		if (HandleInitAck())

			{

			ResetSendDataStream();

			break;

			}

        __FLOG_VA((_L8("Send data stream completion status = %d"), iStatus.Int())); 

        if (iStatus != KErrNone)

            {

            // Abnormal completion.

            SetState(ESendComplete);

            }

		else

			{

            ProcessSendDataL(); 

            }

         if (iState == ESendComplete)

            {

            // Reset the send data stream and notify the connection.

            const MMTPType& data(*iSendDataSource);

            ResetSendDataStream();

            TRAPD(err, SendDataCompleteL(iStatus.Int(), data));

            if (err != KErrNone)

            	{

            	__FLOG_VA((_L8("Framework threw an error from SendDataCompleteL = %d"), err)); 

            	SendDataCompleteL(err, data);

            	}

            }

        break;

	case ESendDataState:

		if (iStatus != KErrNone)

            {

            // Abnormal completion.

            SetState(ESendDataComplete);

            }

 		else if (iState == ESendingDataHeader)

			{

			SetState(ESendingDataPacket);	

			}

		else if (iState == ESendingDataPacket)

			{

			SetState(ESendingDataHeader);		

			}

		else if (iState == ESendDataPacketCompleting)

			{

			SetState(ESendDataComplete);	

			}

		if (iState == ESendDataComplete || iState == ESendDataCancelled)

            {

            // Reset the send data stream and notify the connection.

            const MMTPType& data(*iSendDataSource);

            ResetSendDataStream();

            SendDataCompleteL(iStatus.Int(), data);

            }

   		else

	        {

	        CreateAndSendDataPacketsL();	

	        }

		break;

	default:

		__FLOG_VA((_L8("PTPIP ERROR: Invalid state of the sockethandler: RunL should not be called with 0x%08X state"), iState));	

        Panic(EPTPIPBadState);

		break;

		}// switch

    __FLOG_VA((_L8("IsActive = %d"), IsActive()));

	__FLOG(_L8("RunL - Exit"));

	}

/**

Tell the Asynchronous Service provider to cancel all outstanding operations. 

*/

void CPTPIPSocketHandlerBase::DoCancel()

	{

	__FLOG(_L8("DoCancel - Entry"));

    switch (iState & EStateDirection)

        {

    case EReceivingState:

        __FLOG(_L8("Cancelling receive on the socket"));

        iSocket.CancelRecv();

        ResetReceiveDataStream();

        break;

    case ESendingState:    

        __FLOG(_L8("Cancelling send on the socket"));

        iSocket.CancelSend();

        ResetSendDataStream();

        break;

    case ESendDataState:

	    __FLOG(_L8("Cancelling send on the socket"));

	    iSocket.CancelSend();

	    ResetSendDataStream();

	    break;

    default:

        break;

		}

	__FLOG(_L8("DoCancel - Exit"));

	}

/**

This is invoked when a panic occurs during RunL. 

To handle this , all operations are cancelled, and if we were processing

a send or recv operation, we complete it with the error code. 

@param - The error code with which RunL left

*/

TInt CPTPIPSocketHandlerBase::RunError(TInt aError)

	{

	__FLOG(_L8("RunError - Entry"));

    __FLOG_VA((_L8("Error reported is  %d and state is 0x%08X, and status is %d"), aError, iState, iStatus.Int()));

    // Cancel any outstanding request.

    Cancel();  

    // Notify the protocol layer of the error.

    TInt32 streamDirection = DataStreamDirection();

    if (streamDirection == EReceivingState)

	    {

		__FLOG(_L8("Error in EReceivingState"));            

        // Notify the connection and reset the receive data stream.

        MMTPType& data(*iReceiveDataSink);

        ResetReceiveDataStream();

        TRAPD(err, ReceiveDataCompleteL(aError, data));

        UNUSED_VAR(err);

	    }

	else if (streamDirection == ESendingState || (streamDirection == ESendDataState))

		{

		__FLOG(_L8("Error in ESendingState"));

        // Notify the connection and reset the send data stream.

        const MMTPType& data(*iSendDataSource);

        ResetSendDataStream();

        TRAPD(err, SendDataCompleteL(aError, data));

        UNUSED_VAR(err);

		}

    // We are neither in sending nor receiving state, the error in RunL

    // must have originated from the MTP framework, tell the connection 

    // to stop.

	else 

		{

		Connection().HandleError(aError);

		}

	__FLOG(_L8("RunError - Exit"));

	return KErrNone;

	}

//

// Send Data Functions

//

/**

This sends the data over the socket. The buffer is provided by the MTP fw.

@param aData - The data buffer to be sent

@param aTransactionId - The id of the current onging transaction. This is needed 

 in case the data in R to I phase has to be split into multiple PTPIP data packets

 In such a case the PTPIP Data packet header needs to be created which contains the tran id. 

*/

void CPTPIPSocketHandlerBase::SendDataL(const MMTPType& aData, TUint32 aTransactionId )

	{

	__FLOG(_L8("SendDataL - Entry"));

    iSendDataSource = &aData;

	TUint64 size = iSendDataSource->Size();

    __FLOG_VA((_L8("Size of total data to be sent = %ld bytes"), size));

	// if the data is less than KMaxPTPIPPacketSize then it can be sent in a shot, 

	// Currently the ptp ip packet has the end data packet already, so it can be sent directly. 

	if ( size < KMaxPTPIPPacketSize)

		{

		__FLOG(_L8("Size of data is less than KMaxPTPIPPacketSize, sending as one ptpip packet."));

	    SetState(ESendInitialising);

		ProcessSendDataL();

		}

	// if the data is greater than KMaxPTPIPPacketSize then it needs to be split into 

	// multiple packets. The PTPIP header will be locally created , and sent

	// and then one chunk will be sent as one PTPIP packet.

	else 

		{

		__FLOG(_L8("Size of data is more than KMaxPTPIPPacketSize, sending as multiple ptpip packets."));

		iPTPIPDataHeader->SetUint32L(CPTPIPDataContainer::ETransactionId, aTransactionId);

		iPTPIPDataHeader->SetPayloadL(NULL);

		// We can ignore this header, since we create our own while sending each packet.

		iChunkStatus = iSendDataSource->FirstReadChunk(iSendChunkData);

		SetState(ESendingDataHeader);

		CreateAndSendDataPacketsL();

		}

	__FLOG(_L8("SendDataL - Exit"));

	}

/**

Using the same algo as the USB send, to buffer into a local buffer, and sending 

only when buffer exceeds the max socket send size, or all chunks have been buffered. 

*/

void CPTPIPSocketHandlerBase::ProcessSendDataL()

	{

	__FLOG(_L8("ProcessSendDataL - Entry"));	

    iSendData.Set(KNullDesC8);

    TUint chunkAvailableLen(iSendChunkData.Length());

    if (!chunkAvailableLen)

        {    

        // Fetch the next read data chunk. 

        switch (iState)

            {

        case ESendInitialising:

            __FLOG(_L8("Fetching first read data chunk"));

            iChunkStatus = iSendDataSource->FirstReadChunk(iSendChunkData);

            iPacketBuffer.Zero();

            break;

        case ESendInProgress:

            __FLOG(_L8("Fetching next read data chunk"));

            iChunkStatus = iSendDataSource->NextReadChunk(iSendChunkData);

            break;

        case ESendCompleting:

            break;            

        case EIdle:

        default:

            __FLOG(_L8("Invalid send data stream state"));

            Panic(EPTPIPBadState);

            break;

            }

        // Fetch the new chunk data size available.

        chunkAvailableLen = iSendChunkData.Length();

        // Update data stream state.

        switch (iChunkStatus)

            {

        case KErrNone:

            SetState(ESendInProgress);

            break;

        case KMTPChunkSequenceCompletion:

            if (iState == ESendCompleting)

                {

                SetState(ESendComplete);

                }

            else

                {

                SetState(ESendCompleting);

                }

            break;

          case KErrNotFound:// CMTPTypeFile returns this when it has zero length

        	if( 0 == iSendChunkData.Length() )

        		{

                if (iState == ESendCompleting)

                {

                SetState(ESendComplete);

                }

            else

                {

                SetState(ESendCompleting);

                }

                }  

                break;

        default:

            User::Leave(iChunkStatus);

            break;

            }          

        }

    __FLOG_VA((_L8("Chunk status = %d"), iChunkStatus));

    // Process the buffered residual and/or available chunk data.

    TUint bufferedLen(iPacketBuffer.Length());

    TUint chunkIntegralLen((chunkAvailableLen / iPacketSizeMax) * iPacketSizeMax);

    TUint chunkResidualLen(chunkAvailableLen % iPacketSizeMax);

    __FLOG_VA((_L8("Buffered residual data = %d bytes"), bufferedLen));

    __FLOG_VA((_L8("Chunk data available = %d bytes"), chunkAvailableLen));

    __FLOG_VA((_L8("Chunk data packet integral portion = %d bytes"), chunkIntegralLen));

    __FLOG_VA((_L8("Chunk data packet residual portion = %d bytes"), chunkResidualLen));

    if (bufferedLen)

        {

        // Data is buffered in the packet buffer. Fill the available packet buffer space.

        if (chunkAvailableLen)

            {

            // Fill the packet buffer.

            TUint consumedLen(0);

            TUint unconsumedLen(0);

            TUint capacity(iPacketBuffer.MaxLength() - iPacketBuffer.Length());

            if (chunkAvailableLen > capacity)

                {

                consumedLen     = capacity;

                unconsumedLen   = (chunkAvailableLen - consumedLen);              

                }

            else

                {

                consumedLen = chunkAvailableLen;

                }

            __FLOG_VA((_L8("Buffering %d bytes"), consumedLen));

            iPacketBuffer.Append(iSendChunkData.Left(consumedLen));

            // Update the available chunk data to reflect only the unconsumed portion.

            __FLOG_VA((_L8("Residual chunk data = %d bytes"), unconsumedLen));

            if (unconsumedLen)

                {

                iSendChunkData.Set(iSendChunkData.Right(unconsumedLen));

                }

            else

                {

                iSendChunkData.Set(NULL, 0);                    

                }

            }

        // Send the packet buffer when full.

        if ((iState == ESendCompleting) || (iPacketBuffer.Size() == iPacketBuffer.MaxSize()))

            {

            iSendData.Set(iPacketBuffer);

            iPacketBuffer.Zero();

            }

        }

    else if (iState == ESendInProgress)

        {

        // Send the chunk data packet integral portion.

        if (chunkIntegralLen)

            {

            iSendData.Set(iSendChunkData.Left(chunkIntegralLen));   

            }

        // Buffer the chunk data packet residual portion.

        if (chunkResidualLen)

            {

            __FLOG_VA((_L8("Buffering %d bytes"), chunkResidualLen));

            iPacketBuffer.Append(iSendChunkData.Right(chunkResidualLen));  

            }

        // All data has been consumed and/or buffered.

        iSendChunkData.Set(NULL, 0);

        }

    else if (iState == ESendCompleting)

        {

        // Send all available chunk data.

        iSendData.Set(iSendChunkData);

        // All data has been consumed.

        iSendChunkData.Set(NULL, 0);

        }

    // Send the available data or reschedule to process the next chunk.

    TUint sendBytes(iSendData.Length());

    if (sendBytes)

        {

        __FLOG_VA((_L8("Send data length = %d bytes"), iSendData.Length()));

#ifdef MTP_DEBUG_FLOG_HEX_DUMP 

        __FLOG_HEXDUMP((iSendData, _L8("Sending data on socket ")));

#endif

        iSocket.Send(iSendData, 0, iStatus);

        SetActive(); 

        __FLOG(_L8("Request issued"));

        }

    else if (iState != ESendComplete)

        {    

        iStatus = KRequestPending;

		CompleteSelf(KErrNone);      

		}