#include <e32svr.h>

#include <u32hal.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

    : iTheLogger(aTheLogger),

      iSendState(EIdle),

      iFlowBlocked(EFalse),

      iNumPacketsInSendQueue(0),

      iObserver(aObserver),

      iMBca(NULL),

      iSender(NULL),

      iReceiver(NULL),

      iLoader(NULL)	  

    {

    }

    {

    CBcaIoController* self = new (ELeave) CBcaIoController(aObserver, aTheLogger);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

    {

    _LOG_L1C1(_L8("CBcaIoController::ConstructL"));

#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

    iSender = CSender::NewL(*this, iTheLogger, iMaxTxPacketSize);

    iReceiver = CReceiver::NewL(*this, iTheLogger, iMaxRxPacketSize);

    iLoader = new (ELeave) CBcaControl(*this, iTheLogger);

    }

    iSendQueue.Free();

    iNumPacketsInSendQueue = 0;

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

    delete iIPTagHeader;

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS

    iLoader->StartLoadL();

	if (iSendState == ESending)

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

    {

    _LOG_L1C1(_L8(">>CBcaIoController::Send"));

    // Check if flow is shutting down

    if (iSendState == EShuttingDown)

        {

        _LOG_L2C1(_L8("    ERROR: Nif is shutting down"));

        // 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)

        {

        _LOG_L2C1(_L8("Packet is too large - discarding"));

        _LOG_L1C1(_L8("<<CSender::Send -> Error"));

        // 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).

        _LOG_L2C1(_L8("<<CBcaIoController::Send - return ContinueSending"));

        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.

        _LOG_L1C1(_L8("    Sender blocked, appending packet to queue"));

        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())

            {

            _LOG_L2C1(_L8("<<CBcaIoController::Send - return StopSending"));

            return ESock::MLowerDataSender::ESendBlocked;

            }

        else

            {

            _LOG_L2C1(_L8("<<CBcaIoController::Send - return ContinueSending"));

            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. 

        {    

        _LOG_L1C1(_L8("    Sender busy, appending packet to queue"));

        AppendToSendQueue(aPdu);

        if (IsSendQueueFull())

            {

            _LOG_L2C1(_L8("<<CBcaIoController::Send - return StopSending"));

            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

        _LOG_L2C1(_L8("     set State to ESending"));

        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

    _LOG_L2C1(_L8("<<CBcaIoController::Send - return ContinueSending"));

    return ESock::MLowerDataSender::ESendAccepted;

    }

void CBcaIoController::SendComplete()

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

 *  to process more packets.

    {

    _LOG_L1C1(_L8(">>CBcaIoController::SendComplete"));

    // 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;

            _LOG_L1C1(_L8("    Packet removed from queue to send"));

            RemoveFromSendQueue(tmpPdu);

            // Update module state

            _LOG_L2C1(_L8("     set State to 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();

                }

            }

        }

    _LOG_L1C1(_L8("<<CBcaIoController::SendComplete"));

    }

void CBcaIoController::ResumeSending()

/**

 *  Flow is being unblocked this will resume sending.

 */

    {

    _LOG_L1C1(_L8(">>CBcaIoController::ResumeSending"));

    // 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;

            _LOG_L1C1(_L8("    Packet removed from queue to send"));

            RemoveFromSendQueue(tmpPdu);

            // Update module state

            _LOG_L2C1(_L8("     set State to ESending"));

            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();

                }

            }

        }

    _LOG_L1C1(_L8("<<CBcaIoController::ResumeSending"));

    }

#ifdef RAWIP_HEADER_APPENDED_TO_PACKETS

void CBcaIoController::SetType(TUint16 aType)

    {

 *  Used to specify the type of the IP header.

 */

    _LOG_L1C1(_L8("CBcaController::SetType"));

    iIPTagHeader->SetType(aType);   

    }

void CBcaIoController::AddHeader(TDes8& aDes)

/**

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

    {

    _LOG_L1C1(_L8("CBcaController::AddHeader"));

    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

 */

    {

    _LOG_L1C1(_L8("CBcaController::RemoveHeader"));

    return (iIPTagHeader->RemoveHeader(aPdu));

    }   

#endif // RAWIP_HEADER_APPENDED_TO_PACKETS