/** @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:  CUpnpHttpFileTransferWriter is a class responsible for 

*                   asynchronous writing to a socket owned by CUpnpTcpSession.

*

*/

#include "upnptcpsession.h"

#include "upnphttpfiletransferwriter.h"

#include "upnphttpfileaccess.h"

#define KLogFile _L("DLNAWebServer.txt")

#include "upnpcustomlog.h"

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

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::NewL

// Factory method.

// ---------------------------------------------------------------------------

//

CUpnpHttpFileTransferWriter* CUpnpHttpFileTransferWriter::NewL( CUpnpTcpSession& aSession,

                                                    RSocket& aSocket,

                                                    TThreadPriority aPriority,

                                                    TInt aWriteSize )

    {

    CUpnpHttpFileTransferWriter* self = new ( ELeave ) 

            CUpnpHttpFileTransferWriter( aSession, aSocket, aPriority, aWriteSize );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::CUpnpHttpFileTransferWriter

// C++ constructor.

// ---------------------------------------------------------------------------

//

CUpnpHttpFileTransferWriter::CUpnpHttpFileTransferWriter( CUpnpTcpSession& aSession,

                                              RSocket& aSocket, 

                                              TThreadPriority aPriority,

                                              TInt aWriteSize )

    :CActive( aPriority ),

    iSocket( aSocket ),

    iSession( aSession ),

    iState(EUnknown),

    iSendPointer(NULL,0),

    iWriteSize(aWriteSize)

    {

    LOGS1( "%i, CUpnpHttpFileTransferWriter::CUpnpHttpFileTransferWriter", iSession.Id() );

    // No implementation required

    }

// ---------------------------------------------------------------------------

// CUpnpTcpSessionReader::ConstructL

// Two-phased constructor

// constructor that can leave. Used from derived classes.

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::ConstructL()

    {

    CActiveScheduler::Add( this );   

    iRetryWrite = CUpnpRetryWrite::NewL( iSession, iSocket, this, (TThreadPriority)Priority() );

    iSendBuffer.CreateL( iWriteSize );

    }

// ---------------------------------------------------------------------------

// CUpnpTcpSessionReader::~CUpnpTcpSessionReader

// Destructor.

// ---------------------------------------------------------------------------

//

CUpnpHttpFileTransferWriter::~CUpnpHttpFileTransferWriter()

    {    

    Cancel();    

    iSendBuffer.Close();

    delete iRetryWrite;

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::DoCancel

// From class CActive

// Cancels issued writing request.

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::DoCancel()

    {

    LOGS1( "%i, CUpnpHttpFileTransferWriter::DoCancel", iSession.Id() );

	iState = ECancelled;

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::RunL

// From class CActive

// Function called when issued writing is completed. Function checks if there

// are any write requests left to send and if there are then it issues writing.

// If queue is empty then function informs upper layer that writing is completed.

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::RunL()

    {

    LOGS2( "%i, CUpnpHttpFileTransferWriter::RunL(), iStatus %i", 

    		iSession.Id() , iStatus.Int() );

    // Active object request complete handler

    if ( iStatus == KErrNone )

        {

        switch( iState )

            {

            // Character has been written to socket

            case EHeaders:

            	//100-continue not expected

            	if(!iSession.FileAccess())

            		{

            		Cancel();

            		break;

            		}

            	else 

            		{

            		iState = EContent;            		

            		}

            case EContent:            	

            	SendNextPortionL();            

                break;

            case EFinished:                    	    	

            	iSession.FileTransferWriterDoneL();

            	iSession.StartTimeoutTimer(EFalse);            	                      	

				FinishL();

            	//export finished

            	break;    

            default:                

                break;

            };

        }

    else

        {

           if( (iState == EHeaders || iState == EContent || iState == EFinished) &&

              (iStatus.Int() == KErrNoMemory || iStatus.Int() == KErrNotReady ) )

           {

				iRetryWrite->IssueWriteRetry();

    	   }

		   else

	       {

				// Error: pass it up to session

				iSession.HandleErrorL( iStatus.Int() );

				iState = ECancelled;

			}

        }

    }

// -----------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::RunError

// RunError is called when RunL leaves.

// -----------------------------------------------------------------------------

//

TInt CUpnpHttpFileTransferWriter::RunError( TInt aError )

    {

    LOGS2( "%i, CUpnpHttpFileTransferWriter::RunError %d"

    		, iSession.Id() , aError);

    iState = EFinished;        

    TRAP_IGNORE( HandleErrorL() );

    iSession.StartClosingSession();

    return KErrNone;

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::SendNextWriteRequestL

// Function checks if there are any write requests left and if there are then

// issues writing and removes this request from queue.

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::SendNextPortionL()

    {

    LOGS2( "%i, CUpnpHttpFileTransferWriter::SendNextPortionL(), iState %i",

    		iSession.Id() , iState );

	if( iSession.FileAccess() )

		{

		if( iState == EContent )    	

	    	if( !IsActive() )

	    		{      	

		    	iSendPointer.Set( (TUint8*)iSendBuffer.Ptr(),0,iSendBuffer.MaxLength() );

		        if( iSession.FileAccess()->GetL(iSendPointer,iSendBuffer.MaxLength()) )

		        	{

		        	iState = EFinished;     		

		        	}

				iSession.TimerCancel();        

		        WriteToSocket();

		        iSession.StartTimeoutTimer(ETrue);	       

	    		}

		}

	else

		{

		Cancel();

		}

    }  

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::StartL

// Passes control to the reader

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::StartL()

    {

    iWaiting = EFalse;    

	switch(iState)

		{

			case EUnknown:			

				iState = EHeaders;

				SendHeadersL();

				break;

			case EHeaders:

				if(iSession.FileAccess()->HeadersSent())

					{

					iState = EContent;				

					SendNextPortionL();

					}

				else

					SendHeadersL();

				break;

			default:

				break;

		}

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::StartL

// Sends the HTTP headers of the content

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::SendHeadersL()

    {

    if(iState == EHeaders)

    	if( iSession.FileAccess() )

    		if(!IsActive())

    			{ 

    			//in case session not connected,waiting...

    			if(!iSession.IsConnected())

					{

					iWaiting = ETrue;

					return;

					}   			

				iSendBuffer.Zero();

				if ( ( iSession.FileAccess()->GetHeaders().Length() -

				       iSession.FileAccess()->TransferredBytes()) <= 

		               iSendBuffer.MaxLength() )

					{

					TPtrC8 headerPointer;

					headerPointer.Set(iSession.FileAccess()->GetHeaders());

					headerPointer.Set( headerPointer.Right( 

		            iSession.FileAccess()->GetHeaders().Length()-

		                iSession.FileAccess()->TransferredBytes()) );

					iSendBuffer.Append( headerPointer );			

					iSession.FileAccess()->SetHeadersSent();

                    // Adding file content to the header

                    TInt length = iSendBuffer.MaxLength()-iSendBuffer.Length();

                    HBufC8* tmpBuffer = HBufC8::NewLC(length);

                    iSendPointer.Set(tmpBuffer->Des());

                    if( iSession.FileAccess()->GetL(iSendPointer,length) )

                        {

                        iState = EFinished;

                        }

                    iSendBuffer.Append(iSendPointer);

                    CleanupStack::PopAndDestroy( tmpBuffer );

					}

				else

					{

					TPtrC8 headerPointer;

					headerPointer.Set( iSession.FileAccess()->GetHeaders() );

					headerPointer.Set( headerPointer.Right( 

		            iSession.FileAccess()->GetHeaders().Length() -

		                iSession.FileAccess()->TransferredBytes() ) );

					headerPointer.Set( headerPointer.Left( 

		                iSendBuffer.Length() ) );

					iSendBuffer.Append( headerPointer );				

					iSession.FileAccess()->SetPosOfHeader( 

					    iSession.FileAccess()->TransferredBytes() + headerPointer.Length() );							

					}

		    	iSendPointer.Set((TUint8*)iSendBuffer.Ptr(),iSendBuffer.Length(),iSendBuffer.MaxLength());

    	   		iSession.TimerCancel();        

	        	WriteToSocket();

	        	iSession.StartTimeoutTimer(ETrue);

	        	if(!iHttpPostStarted)

	        		{

	        		iSession.NotifyUpperLayersOnPostL();

	        		iHttpPostStarted = ETrue;

	        		}

    			}

    }          

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::Reset

// Resets the state of the writer

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::Reset()

    {

    iState = EUnknown;  

    iHttpPostStarted = ETrue;  

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::WriteToSocket

// Writes data to socket

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::WriteToSocket()

    {

	Deque();

	CActiveScheduler::Add(this);  

	iSocket.Write(iSendPointer,iStatus);

	SetActive();

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::IsWaiting

// Checks if file transfer writer is in use

// ---------------------------------------------------------------------------

//

TBool CUpnpHttpFileTransferWriter::IsWaiting()

    {

	return iWaiting;

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::IsActivated

// Writes data to socket

// ---------------------------------------------------------------------------

//

TBool CUpnpHttpFileTransferWriter::IsActivated()

    {

	return (!iWaiting && iState!=EUnknown);

    } 

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::IsRetrying

// if waiting to retry writing to a socket

// ---------------------------------------------------------------------------

//

TBool CUpnpHttpFileTransferWriter::IsRetrying()

    {

	return (iRetryWrite->IsStarted());

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::IsCancelled

// Checks if transfer is cancelled

// ---------------------------------------------------------------------------

//

TBool CUpnpHttpFileTransferWriter::IsCancelled()

    {

	return (iState== ECancelled);

    }        

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::FinishL

// Finishes download

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::FinishL()

    {

	iSession.FileTransferWriterHandleMoreL();

    }    

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::HandleErrorL

// Handles RunL error

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::HandleErrorL()

    {

    iSession.FileTransferWriterDoneL(); // 200ok to upper layers + delete iFileServe    

    FinishL();                          // serving uotstanding requests  

    }

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::SetPostNotify

// Post notify will be sent

// ---------------------------------------------------------------------------

//

void CUpnpHttpFileTransferWriter::SetPostNotify()

    {

	iHttpPostStarted = EFalse;

    }    

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::RetryWriteFailL

// 

// ---------------------------------------------------------------------------

//    

void CUpnpHttpFileTransferWriter::RetryWriteFailL( TInt aError )

	{

	// Error: pass it up to session

	iSession.HandleErrorL( aError );

    iState = ECancelled;

	}

// ---------------------------------------------------------------------------

// CUpnpHttpFileTransferWriter::RetryWriteSucceed

// 

// ---------------------------------------------------------------------------

// 

void CUpnpHttpFileTransferWriter::RetryWriteSucceed()

	{

	WriteToSocket();

	}

//  End of File