/*

 * Copyright (c) 2006-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: CSocketsWrite is an active object which implements data

 * sending through an already open socket using UDP or TCP

 *

 */

// INCLUDE FILES

#include <e32svr.h>

#include "SocketsWrite.h"

#include "TimeOutTimer.h"

#include "ConnTest.pan"

#include "uinotify.h"

#include "Utils.h"

#include "conntest.hrh"

#include "datasendnotifyhandler.h"

// CONSTANTS

static const TInt KTimeOut = 30000000; // 30 seconds time-out

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

// CSocketsWrite::NewL(MUINotify& aConsole, RSocket& aSocket, MDataSendNotifyHandler& aSendHandler)

// EPOC two phased constructor

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

//

CSocketsWrite* CSocketsWrite::NewL( MUINotify& aConsole, 

        RSocket& aSocket, 

        MDataSendNotifyHandler& aSendHandler )

    {

    CSocketsWrite* self = CSocketsWrite::NewLC(aConsole, aSocket, aSendHandler);

    CleanupStack::Pop(self);

    return self;

    }

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

// CSocketsWrite::NewLC(MUINotify& aConsole, RSocket& aSocket, MDataSendNotifyHandler& aSendHandler)

// EPOC two phased constructor

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

//

CSocketsWrite* CSocketsWrite::NewLC( MUINotify& aConsole, 

        RSocket& aSocket, 

        MDataSendNotifyHandler& aSendHandler )

    {

    CSocketsWrite* self = new (ELeave) CSocketsWrite(aConsole, aSocket, aSendHandler);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// CSocketsWrite::CSocketsWrite(MUINotify& aConsole, RSocket& aSocket, MDataSendNotifyHandler& aSendHandler)

// Constructor

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

//

CSocketsWrite::CSocketsWrite( MUINotify& aConsole, 

        RSocket& aSocket, 

        MDataSendNotifyHandler& aSendHandler ):

        CActive(EPriorityStandard),

        iSocket(aSocket),

        iConsole(aConsole),

        iPackets(0),

        iPacketSize(0),

        iReqBodySubmitBufferPtr(0,0),

        iSendHandler(aSendHandler)

    {

    }

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

// CSocketsWrite::~CSocketsWrite()

// Destructor

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

//

CSocketsWrite::~CSocketsWrite()

    {

    Cancel();

    delete iReqBodySubmitBuffer;

    delete iTimer;

    iTimer = NULL;

    if(iTransferBuffer)

        {

        delete iTransferBuffer;

        iTransferBuffer = NULL;

        }

    if(iWriteBuffer)

        {

        delete iWriteBuffer;

        iWriteBuffer = NULL;

        }

    }

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

// CSocketsWrite::ConstructL()

// EPOC two-phased constructor

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

//

void CSocketsWrite::ConstructL()

    {

    CActiveScheduler::Add(this);

    iTransferBuffer = HBufC8::NewL(KMaxSendBuffer);

    iWriteBuffer = HBufC8::NewL(KMaxSendBuffer);

    iTimeOut = KTimeOut; 

    iTimer = CTimeOutTimer::NewL(10, *this);

    iWriteStatus = EWaiting;

    }

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

// CSocketsWrite::RunL()

// Called when request has completed.

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

//

void CSocketsWrite::RunL()

    {

    if(!iFlood)

        {   

        RDebug::Print(_L("ConnTest: CSocketsWrite::RunL - iStatus = %d"), iStatus.Int());

        }

    // Active object request complete handler

    if (iStatus == KErrNone)

        {

        switch(iWriteStatus)

            {

            // Character has been written to socket

            case ESending:

                if(!iFlood)

                    SendNextPacket();

                else

                    DoFloodWrite();

                break;

            default:

                User::Panic(KPanicSocketsWrite, EConnTestBadStatus);

                break;

            };

        }

    else 

        {

        // Error: pass it up to user interface

        iTimer->Cancel();

        TBuf<50> err;

        err.Format(_L("\nCSocketsWrite error %d\n"), iStatus.Int());

        //iConsole.ErrorNotify(_L("\nCSocketsWrite error"), iStatus.Int());

        iConsole.PrintNotify(err);

        iWriteStatus = ECommsFailed;

        }

    }

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

// CSocketsWrite::DoCancel()

// Cancel ongoing requests.

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

//

void CSocketsWrite::DoCancel()

    {	

    RDebug::Print(_L("CSocketsWrite::DoCancel"));

    // Cancel asychronous write request

    iSocket.CancelWrite();

    iTimer->Cancel();

    }

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

// CSocketsWrite::IssueWriteL()

// Add data into buffer for sending.

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

//

void CSocketsWrite::IssueWriteL(const TDesC8& aData, TInetAddr* aAddress, TUint aProtocol)

    {

    RDebug::Print(_L("ConnTest: CSocketsWrite::IssueWriteL - aData.Length = %d"), aData.Length());

    iFlood = EFalse;

    iAddress = aAddress;

    iProtocol = aProtocol;

    // Write data to a stream socket

    if ((aData.Length() + iTransferBuffer->Length()) > iTransferBuffer->Des().MaxLength())

        {

        RDebug::Print(_L("ConnTest: CSocketsWrite::IssueWriteL - data doesn't fit in the transferbuffer"));

        RDebug::Print( _L( 

                "ConnTest: CSocketsWrite::IssueWriteL - data length = %d, buffer length = %d, buffer max length = %d"),

                aData.Length(), iTransferBuffer->Length(), iTransferBuffer->Des().MaxLength() );

        // Not enough space in buffer

        User::Leave(KErrOverflow);

        }

    // Add new data to buffer

    iTransferBuffer->Des().Append(aData);

    if (!IsActive())

        {

        SendNextPacket();

        }

    }

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

// CSocketsWrite::IssueWriteL()

// Flood data over socket

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

//

void CSocketsWrite::IssueWriteL( const TDesC8& aData, 

        TInetAddr* aAddress, 

        TUint aProtocol, 

        TInt aCount )

    {

    RDebug::Print(_L("ConnTest: CSocketsWrite::IssueWriteL - flood, packet count=%d"), aCount);

    RDebug::Print(_L("ConnTest: CSocketsWrite::IssueWriteL - aData.Length = %d"), aData.Length());

    iFlood = ETrue;

    iCount = 0;

    iPackets = aCount;

    iPacketSize = aData.Length();

    iAddress = aAddress;

    iProtocol = aProtocol;

    // Write data to a stream socket

    if (aData.Length() > iTransferBuffer->Des().MaxLength())

        {

        // Not enough space in buffer

        User::Leave(KErrOverflow);

        }

    // Add new data to buffer

    iTransferBuffer->Des().Zero();

    iTransferBuffer->Des().Append(aData);

    iWriteBuffer->Des().Copy(*iTransferBuffer);

    if (!IsActive())

        {

        DoFloodWrite();

        }

    }

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

// CSocketsWrite::IssueWriteL()

// Add data into buffer for sending POST request, initializes body data.

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

//

void CSocketsWrite::IssueWriteL( const TDesC8& aData, 

        TInetAddr* aAddress, 

        TUint aProtocol, 

        TInt aPacketSize, 

        TInt aPackets )

    {

    RDebug::Print(_L("ConnTest: CSocketsWrite::IssueWriteL - aData.Length = %d"), aData.Length());

    iFlood = EFalse;

    iPackets = aPackets;

    iPacketSize = aPacketSize;

    delete iReqBodySubmitBuffer;

    iReqBodySubmitBuffer = NULL;

    iReqBodySubmitBuffer = HBufC8::NewMaxL(KSendDataSize);

    iReqBodySubmitBufferPtr.Set(iReqBodySubmitBuffer->Des());

    // Create body chunk

    Utils::CreateDataChunk(iReqBodySubmitBufferPtr, iPacketSize);

    iDataChunkCount = 0;

    IssueWriteL(aData, aAddress, aProtocol);

    }

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

// CSocketsWrite::SendNextPacket()

// Write data from buffer to socket.

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

//

void CSocketsWrite::SendNextPacket()

    {

    RDebug::Print(_L("ConnTest: CSocketsWrite::SendNextPacket - iTransferBuffer.Length = %d, iPackets = %d"), iTransferBuffer->Length(), iPackets);

    iTimer->Cancel(); // Cancel TimeOut timer

    iWriteStatus = EWaiting;

    if (iTransferBuffer->Length() > 0)

        {

        // Move data from transfer buffer to actual write buffer

        iWriteBuffer->Des().Copy(*iTransferBuffer);

        iTransferBuffer->Des().Zero();

        switch(iProtocol)

            {

            case KProtocolInetTcp:

                iSocket.Write(*iWriteBuffer, iStatus); // Initiate actual write

                break;

            case KProtocolInetUdp:

                iSocket.SendTo(*iWriteBuffer, *iAddress, 0, iStatus);

                break;

            }

        iSendHandler.NotifySend(iWriteBuffer->Length());

        // Request timeout

        iTimer->After(iTimeOut);

        SetActive();

        iWriteStatus = ESending;

        }

    else if(iPackets)

        {

        // We are sending body data, i.e. this is POST request

        if(iDataChunkCount == 0)

            {

            iConsole.PrintNotify(_L("Sending body...\n"));

            iSentBytes = 0;

            iStartTime.UniversalTime();

            }

        TBool noMoreData = iDataChunkCount < iPackets ? EFalse : ETrue;

        ++iDataChunkCount;

        if(noMoreData)

            {

            // Throughput calculation

            TBuf8<128> b(_L8("Body sent\n"));

            Utils::CalculateThroughput(b, iStartTime, iSentBytes);

            b.Append(_L("\n\n"));

            iConsole.PrintNotify(b);

            iPackets = 0;

            iPacketSize = 0;

            iSentBytes = 0;

            return;

            }

        iSentBytes += iReqBodySubmitBufferPtr.Length();

        iSocket.Write(iReqBodySubmitBufferPtr, iStatus); 

        SetActive();

        iWriteStatus = ESending;

        }

    }

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

// CSocketsWrite::DoFloodWrite()

// Floods the data to the socket

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

//

void CSocketsWrite::DoFloodWrite()

    {

    //RDebug::Print(_L("ConnTest: CSocketsWrite::DoFloodWrite: %d"),iCount); // eats CPU

    iTimer->Cancel(); // Cancel TimeOut timer

    iWriteStatus = EWaiting;

    if (iCount != iPackets)

        {

        if( iTransferBuffer->Length() > 0)

            {

            switch(iProtocol)

                {

                case KProtocolInetTcp:

                    iSocket.Write(*iWriteBuffer, iStatus); // Initiate actual write

                    break;

                case KProtocolInetUdp:

                    {

                    TUint32* seqNumberPointer = (TUint32*)(iTransferBuffer->Des().Ptr());

                    *seqNumberPointer = ByteOrder::Swap32( iCount ); // put sequence number into to the packet

                    iSocket.SendTo(*iTransferBuffer, *iAddress, 0, iStatus);

                    break;

                    }

                default:

                    iConsole.ErrorNotify(_L("Unsupproted protocol\n\n"),KErrNotSupported );

                    return;

                }

            iCount++;

            iTimer->After(iTimeOut);

            SetActive();

            iWriteStatus = ESending;

            }

        }

    else

        {

        iTransferBuffer->Des().Zero();

        iWriteBuffer->Des().Zero();

        iSendHandler.NotifySend(iPacketSize*iPackets);   

        iFlood = EFalse;

        iCount = 0;

        iPackets = 0;

        iPacketSize = 0; 	    

        }

    }

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

// CSocketsWrite::TimerExpired()

// Timeout, show error notification.

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

//

void CSocketsWrite::TimerExpired()

    {

    Cancel();

    iWriteStatus = ECommsFailed;

    iConsole.ErrorNotify(_L("Write operation timed out\n"), KErrTimedOut);

    }