// Copyright (c) 2004-2010 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:

// Implements the interface to BCA.

// 

//

/**

 @file BcaIoController.cpp

*/

#include <e32uid.h>

#include <nifmbuf.h>

#include <e32svr.h>

#include <u32hal.h>

#include "Constants.h"

#include "BcaIoController.h"

#include "Sender.h"

#include "Receiver.h"

const TUint KDefaultSendQueueSize=5;

#ifdef __EABI__

// Patch data is used and KMaxTxIPPacketSize and KMaxRxIPPacketSize can be modified to a different value in RawIpNif.iby file

extern const TInt KMaxSendQueueLen = KDefaultSendQueueSize;

extern const TInt KMaxTxIPPacketSize = KMaxIPPacket + KIPTagHeaderLength;

extern const TInt KMaxRxIPPacketSize = KMaxIPPacket + KIPTagHeaderLength;

#endif

/**

 * Constructor. 

 *

 * @param aObserver Reference to the observer of this state machine

 */

      iFlowBlocked(EFalse),

      iNumPacketsInSendQueue(0),

      iObserver(aObserver),

      iMBca(NULL),

      iSender(NULL),

      iReceiver(NULL),

      iLoader(NULL)	  

    {

    }

/**

 * Two-phase constructor. Creates a new CBcaIoController object, performs 

 * second-phase construction, then returns it.

 *

 * @param aObserver The observer, to which events will be reported

 * @return A newly constructed CBcaIoController object

 */

void CBcaIoController::ConstructL()

/**

 * Second-phase constructor. Creates all the state objects it owns.

 */

    {

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

    iIPTagHeader = new (ELeave) CIPTagHeader(iTheLogger);

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

#if defined __EABI__

    // Default value for queue length

    iMaxSendQueueLen = KMaxSendQueueLen;

    // Default value for Tx and Rx packet size

    iMaxTxPacketSize = KMaxTxIPPacketSize;

    iMaxRxPacketSize = KMaxRxIPPacketSize;

#else // WINS

    // Set default values in case patch is not present in epocrawip.ini

    iMaxSendQueueLen = KDefaultSendQueueSize;    

    iMaxTxPacketSize = KMaxIPPacket + KIPTagHeaderLength;

    iMaxRxPacketSize = KMaxIPPacket + KIPTagHeaderLength;

    // for the emulator process is patched via the epocrawip.ini file

    UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"rawip_KMaxSendQueueLen",&iMaxSendQueueLen);

    UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"rawip_KMaxTxIPPacketSize",&iMaxTxPacketSize);

    UserSvr::HalFunction(EHalGroupEmulator,EEmulatorHalIntProperty,(TAny*)"rawip_KMaxRxIPPacketSize",&iMaxRxPacketSize);

#endif

    // end note

    }

CBcaIoController::~CBcaIoController()

/**

 * Destructor.

 */

	{

    iSendQueue.Free();

    iNumPacketsInSendQueue = 0;

	delete iReceiver;

	delete iSender;

	delete iLoader;

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

    delete iIPTagHeader;

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

	}

/** sets the BCA Stack name

* @param aBcaStack Text composed of bca stack and next bca names

*/	

void CBcaIoController::SetBcaStackAndName(const TDesC& aBcaStack, const TDesC& aBcaName)

	{

	iBcaName.Set(aBcaName);

	iBcaStack.Set(aBcaStack);

	}

void CBcaIoController::StartL()

/**

 *  Used to kick off the initialisation for this module

 */

	{

    iLoader->StartLoadL();

	}

void CBcaIoController::Stop(TInt aError)

/**

 *  Used to shutdown this module. This will cancel all the outstanding 

 *  requests on the active objects owned by this module and shutdown.

 * @param aError the passed in error code as to why Stop has been called

 */

	{

	//Stop all the active objects

	iReceiver->Cancel();

	if (iSendState == ESending)

		{

		iSender->Cancel();

		}

	// Update module state

	SendState(EShuttingDown);

    iLoader->ShutdownBca(aError);  

	}

ESock::MLowerDataSender::TSendResult CBcaIoController::Send(RMBufChain& aPdu)

/**

 *  This method is called by CRawIPFlow in order to send a packet down

 *  to the BCA. 

 *

 *  @param aPdu a data packet

 */

    {

    // Check if flow is shutting down

    if (iSendState == EShuttingDown)

        {

        // when the flow is destroyed the memory for this packet will be 

        // cleaned up - just tell the layers above to stop sending.

        aPdu.Free();

        return ESock::MLowerDataSender::ESendBlocked;

        }

    // check that this packet isnt too big - If it is, we dont want to send it or

    // add it to our queue

    if ((aPdu.Length() - aPdu.First()->Length()) > iMaxTxPacketSize)

        {

        // in debug panic - this should not happen, MTU on the uplink should

        // be strictly enforced

        __ASSERT_DEBUG(ETrue,Panic(KFlowInvalidULPacketSize));

        aPdu.Free();

        // may be counter intuitive, however the only options here are either 

        // send accepted or blocked (MLowerDataSender).

        return ESock::MLowerDataSender::ESendAccepted;

        }

    // transmit flow control.

    if (iFlowBlocked)

        {

        // Transmit is off for this flow - we must have received a block

        // message from our control.  append this message to the queue

        // and tell the layer above it to kindly stop sending.

        AppendToSendQueue(aPdu);

        // may be a bit counter-intuitive, however, even if the flow is blocked

        // there is no reason not to ask for more data as long as our send

        // queue isn't full.

        if (IsSendQueueFull())

            {

            return ESock::MLowerDataSender::ESendBlocked;

            }

        else

            {

            return ESock::MLowerDataSender::ESendAccepted;       

            }

        }

    // transmit is on for this flow.  send a packet or queue it

    // if we're already sending one.

    if (iSendState == ESending)

        // If this happens, it means that TCP/IP has sent us an IP packet

        // while we're still sending the previous one. 

        {    

        AppendToSendQueue(aPdu);

        if (IsSendQueueFull())

            {

            return ESock::MLowerDataSender::ESendBlocked;

            }

        }

    else

        {

        // if we're idle, then we must not be sending.  If we're not idle

        // then the SendComplete() will handle sending any additional 

        // packets that might have been queued onto the send queue.

        // Update module state

        iSendState = ESending;

        iSender->Send(aPdu);

        }

    // if our send queue isn't full, then the send is accepted

    // otherwise, block this flow until we have room for the next

    // packet

    return ESock::MLowerDataSender::ESendAccepted;

    }

void CBcaIoController::SendComplete()

/**

 *  A packet has finished sending - check to see if we need

 *  to process more packets.

 */

    {

    // if we've been blocked while in the middle of a 

    // send - don't continue sending, this will happen

    // when the flow is resumed.

    iSendState = EIdle;

    // are we available to transmit?

    if (iFlowBlocked == EFalse)

        {

        // flow transmit is on

        TBool resumeSending = EFalse;

        // if the queue is full, it means that while a packet was

        // outstanding in BCA, we've filled up our send queue and

        // informed the upper layers to stop sending.

        if (IsSendQueueFull())

            {

            resumeSending = ETrue;

            }

        // if the queue has anything inside it, we need to send the 

        // first packet in the queue.  note: the resumeSending check is to 

        // short circuit this so we don't check the queue length twice

        // in the case that it is full

        if ((resumeSending) || (!IsSendQueueEmpty()))

            {

            iSendState = ESending;

            RMBufChain tmpPdu;

            RemoveFromSendQueue(tmpPdu);

            // Update module state

            iSender->Send(tmpPdu);

            // if the queue was full, again, we told the upper layers

            // to stop sending, we need to resume this flow.  order is

            // important as we don't want to get a packet before we've 

            // given one to BCA to send.

            if (resumeSending)

                {

                iObserver.ResumeSending();

                }

            }

        }

    }

void CBcaIoController::ResumeSending()

/**

 *  Flow is being unblocked this will resume sending.

 */

    {

    // allows for normal SendComplete behaviour if there is

    // a packet outstanding with BCA

    iFlowBlocked = EFalse;

    // If the send state is idle, then there isn't a packet

    // outstanding, check the send queue to see if there are

    // packets to send.

    if (iSendState == EIdle)

        {

        // flow transmit is on

        TBool resumeSending = EFalse; 

        if (IsSendQueueFull())

            {

            resumeSending = ETrue;

            }

        // if the queue has anything inside it, we need to send the 

        // first packet in the queue.  note: the resumeSending check is to 

        // short circuit this so we don't check the queue length twice

        // in the case that it is full

        if ((resumeSending) || (!IsSendQueueEmpty()))

            {

            RMBufChain tmpPdu;

            RemoveFromSendQueue(tmpPdu);

            // Update module state

            iSendState = ESending;

            iSender->Send(tmpPdu);

            // if the queue was full, again, we told the upper layers

            // to stop sending, we need to resume this flow.  order is

            // important as we don't want to get a packet before we've 

            // given one to BCA to send.

            if (resumeSending)

                {

                iObserver.ResumeSending();

                }

            }

        }

    }

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

void CBcaIoController::SetType(TUint16 aType)

    {

/**

 *  Used to specify the type of the IP header.

 */

    iIPTagHeader->SetType(aType);   

    }

void CBcaIoController::AddHeader(TDes8& aDes)

/**

 *  Used to add the IP header to the packet before sending to the BCA.

 */

    {

    iIPTagHeader->AddHeader(aDes);

    }

TUint16 CBcaIoController::RemoveHeader(RMBufChain& aPdu)

/**

 *  Used to remove the IP header from the received the packet before sending to the 

 *  TCP/IP layer.  

 * @return The IP header that has been removed from the packet

 */

    {

    return (iIPTagHeader->RemoveHeader(aPdu));

    }   

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

/**

 * Constructor. Performs standard active object initialisation.

 *

 * @param aObserver Reference to the observer of this state machine

 */

	: CActive(EPriorityStandard), 

	  iObserver(aObserver), 

	  iMBca(NULL),

	  iState(EIdling),

	  iError(KErrNone)

	{

	CActiveScheduler::Add(this);

	}

CBcaControl::~CBcaControl()

/**

 * Destructor.

 */

	{

	Cancel();

	if(iMBca)

		{

        //If the Bca is still open, close it

        if(EBcaOpened == iState)

            {

            iMBca->Close();

            }

        //delete the BCA instance

		iMBca->Release();	

		}

	// Library will be Closed when iBcaDll is destroyed.

	}

void CBcaControl::RunL()

/**

 *  Called after request is completed. 

 *  

 */

	{

	switch (iState)

		{

		//in this state, Ioctl is called to set IAP ID, check the result of

		// Ioctl, then either set the BCA stack with another Ioctl call, 

		// open the BCA (if there's no BCA stack to set), or stop the NIF.

		case EIdling:

			{

			if(iStatus == KErrNone || iStatus == KErrNotSupported)

				{

				if(iStatus == KErrNotSupported)

					{

					}

				else

					{