/*

* Copyright (c) 2002-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:  Implements functions for LAN interface

*

*/

/*

* %version: 24 %

*/

#include <f32file.h>

#include <e32std.h> // for TTime

#include <nifvar.h>

#include <nifutl.h>

#include <es_mbuf.h>

#include <nifmbuf.h>

#include <comms-infras/nifprvar.h>

#include <comms-infras/connectionsettings.h>  // for KSlashChar

#include <commdb.h>

#include "WlanProto.h"

#include "carddrv.h"

#include <in_sock.h> // Header is retained, but in_sock.h is modified for ipv6

#include "CLanIp4Bearer.h"

#include "CLanIp6Bearer.h"

#include <cdbcols.h>

#include <cdblen.h>

#include "CLanxBearer.h"

#include "WlanProvision.h"

#include <comms-infras/ss_metaconnprov.h> // for SAccessPointConfig

#include <comms-infras/linkmessages.h>

#include <elements/nm_messages_base.h>

#include <elements/nm_messages_child.h>

// From old wlan implementation

#include <ip4_hdr.h>

#include <ip6_hdr.h>

#include <centralrepository.h>

#include "am_debug.h"

#include "EtherCardApi.h"

#include "wlandevicesettingsinternalcrkeys.h"

#include "NifWLMServerIf.h"

using namespace ESock;

using namespace Messages;

_LIT8(KDescIp, "ip");

_LIT8(KDescIcmp, "icmp");

_LIT8(KDescIp6, "ip6");

const TInt KLanxBearerPtrArrayGranularity = 2;

const TInt KContinueSending = 1;

const TInt KMaxDSCPValues = 64;

/**

 * Mapping of user priority values to the corresponding access classes.

 */

const TWlmAccessClass KUPtoAC[E8021DUserPriorityMax] =

    {

    EWlmAccessClassBestEffort,      // E8021DUserPriorityBE

    EWlmAccessClassBackground,      // E8021DUserPriorityBK1

    EWlmAccessClassBackground,      // E8021DUserPriorityBK2

    EWlmAccessClassBestEffort,      // E8021DUserPriorityEE

    EWlmAccessClassVideo,           // E8021DUserPriorityCL

    EWlmAccessClassVideo,           // E8021DUserPriorityVI

    EWlmAccessClassVoice,           // E8021DUserPriorityVO

    EWlmAccessClassVoice,           // E8021DUserPriorityNC

    };

/**

 * Mapping of access class transitions on packet downgrade.

 */

const TWlmAccessClass KNextAC[EWlmAccessClassMax] =

    {

    EWlmAccessClassBackground,      // EWlmAccessClassBestEffort -> EWlmAccessClassBackground

    EWlmAccessClassMax,             // EWlmAccessClassBackground -> EWlmAccessClassMax

    EWlmAccessClassBestEffort,      // EWlmAccessClassVideo -> EWlmAccessClassBestEffort

    EWlmAccessClassVideo            // EWlmAccessClassVoice -> EWlmAccessClassVideo

    };

/**

 * Mapping of IP TOS (DSCP) bits to the corresponding user priority values.

 */

const T8021DPriority KDSCPtoUP[KMaxDSCPValues] =

    {

    /* DSCP bits as binary format, DSCP byte in IPv4 packet as HEX */

    /* 000000, 0x00 */E8021DUserPriorityBE,  /* 000001, 0x04 */E8021DUserPriorityBE,  

    /* 000010, 0x08 */E8021DUserPriorityBE,  /* 000011, 0x0C */E8021DUserPriorityBE,

    /* 000100, 0x10 */E8021DUserPriorityBE,  /* 000101, 0x14 */E8021DUserPriorityBE,  

    /* 000110, 0x18 */E8021DUserPriorityBE,  /* 000111, 0x1C */E8021DUserPriorityBE,

    /* 001000, 0x20 */E8021DUserPriorityBK1, /* 001001, 0x24 */E8021DUserPriorityBK1,  

    /* 001010, 0x28 */E8021DUserPriorityEE,  /* 001011, 0x2C */E8021DUserPriorityEE,

    /* 001100, 0x30 */E8021DUserPriorityEE,  /* 001101, 0x34 */E8021DUserPriorityEE,  

    /* 001110, 0x38 */E8021DUserPriorityEE,  /* 001111, 0x3C */E8021DUserPriorityEE,

    /* 010000, 0x40 */E8021DUserPriorityEE,  /* 010001, 0x44 */E8021DUserPriorityEE,  

    /* 010010, 0x48 */E8021DUserPriorityEE,  /* 010011, 0x4C */E8021DUserPriorityEE,

    /* 010100, 0x50 */E8021DUserPriorityEE,  /* 010101, 0x54 */E8021DUserPriorityEE,  

    /* 010110, 0x58 */E8021DUserPriorityEE,  /* 010111, 0x5C */E8021DUserPriorityEE,

    /* 011000, 0x60 */E8021DUserPriorityVI,  /* 011001, 0x64 */E8021DUserPriorityVI,  

    /* 011010, 0x68 */E8021DUserPriorityVI,  /* 011011, 0x6C */E8021DUserPriorityVI,

    /* 011100, 0x70 */E8021DUserPriorityVI,  /* 011101, 0x74 */E8021DUserPriorityVI,  

    /* 011110, 0x78 */E8021DUserPriorityVI,  /* 011111, 0x7C */E8021DUserPriorityVI,

    /* 100000, 0x80 */E8021DUserPriorityVI,  /* 100001, 0x84 */E8021DUserPriorityVI,  

    /* 100010, 0x88 */E8021DUserPriorityVI,  /* 100011, 0x8C */E8021DUserPriorityVI,

    /* 100100, 0x90 */E8021DUserPriorityVI,  /* 100101, 0x94 */E8021DUserPriorityVI,  

    /* 100110, 0x98 */E8021DUserPriorityVI,  /* 100111, 0x9C */E8021DUserPriorityVI,

    /* 101000, 0xA0 */E8021DUserPriorityCL,  /* 101001, 0xA4 */E8021DUserPriorityCL,  

    /* 101010, 0xA8 */E8021DUserPriorityCL,  /* 101011, 0xAC */E8021DUserPriorityCL,

    /* 101100, 0xB0 */E8021DUserPriorityCL,  /* 101101, 0xB4 */E8021DUserPriorityCL,  

    /* 101110, 0xB8 */E8021DUserPriorityVO,  /* 101111, 0xBC */E8021DUserPriorityVO,

    /* 110000, 0xC0 */E8021DUserPriorityNC,  /* 110001, 0xC4 */E8021DUserPriorityNC,  

    /* 110010, 0xC8 */E8021DUserPriorityNC,  /* 110011, 0xCC */E8021DUserPriorityNC,

    /* 110100, 0xD0 */E8021DUserPriorityNC,  /* 110101, 0xD4 */E8021DUserPriorityNC,  

    /* 110110, 0xD8 */E8021DUserPriorityNC,  /* 110111, 0xDC */E8021DUserPriorityNC,

    /* 111000, 0xE0 */E8021DUserPriorityNC,  /* 111001, 0xE4 */E8021DUserPriorityNC,  

    /* 111010, 0xE8 */E8021DUserPriorityNC,  /* 111011, 0xEC */E8021DUserPriorityNC,

    /* 111100, 0xF0 */E8021DUserPriorityNC,  /* 111101, 0xF4 */E8021DUserPriorityNC,  

    /* 111110, 0xF8 */E8021DUserPriorityNC,  /* 111111, 0xFC */E8021DUserPriorityNC

    };

/**

 * Inactivity timeouts per access class.

 */

const TUint KTsInactivityTime[EWlmAccessClassMax] =

    {

    600000000,    // 600 seconds for EWlmAccessClassBestEffort

    600000000,    // 600 seconds for EWlmAccessClassBackground

    120000000,    // 120 seconds for EWlmAccessClassVideo

    30000000,     // 30 seconds for EWlmAccessClassVoice

    };

EXPORT_C CLANLinkCommon::CLANLinkCommon(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf)

  : CSubConnectionFlowBase(aFactory, aSubConnId, aProtocolIntf), iMMState(EStopped)

    {

    DEBUG("CLANLinkCommon::CLANLinkCommon()");

    LOG_NODE_CREATE(KWlanLog, CLANLinkCommon);

    }

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

// CLANLinkCommon::LoadPacketDriverL

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

//

void CLANLinkCommon::LoadPacketDriverL()

    {

    DEBUG("CLANLinkCommon::LoadPacketDriverL() - Creates only new class instance");

    iPktDrv = CPcCardPktDrv::NewL( this ); 

    }

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

// CLANLinkCommon::NewL

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

//

EXPORT_C CLANLinkCommon* CLANLinkCommon::NewL(CSubConnectionFlowFactoryBase& aFactory, const TNodeId& aSubConnId, CProtocolIntfBase* aProtocolIntf)

    {

    DEBUG("CLANLinkCommon::NewL()");

    CLANLinkCommon* s=new (ELeave) CLANLinkCommon(aFactory, aSubConnId, aProtocolIntf);

    CleanupStack::PushL(s);

    s->ConstructL();

    CleanupStack::Pop(s);

    return s;

    }

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

// CLANLinkCommon::ReadMACSettings

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

//

TBool CLANLinkCommon::ReadMACSettings()

    {

    DEBUG("CLANLinkCommon::ReadMACSettings()");

    TBuf8<KMACByteLength> drvMacAddr;

    TUint8* config=iPktDrv->GetInterfaceAddress();

    drvMacAddr.Append(&config[0],KMACByteLength); // First 3 bytes of config not part of address

    iMacAddr.Copy(drvMacAddr); // update Ethints copy of the MAC address

    TUint bearerLim = iBearers->Count();

    for(TUint index=0;index<bearerLim;index++)

        {

        CLanxBearer* bearer=(*iBearers)[index];

        bearer->UpdateMACAddr();

        }

    // check that the macaddress has been passed and is not 0;

    return CheckMac(iMacAddr); // wrong.

    }

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

// CLANLinkCommon::Mtu

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

//

TUint CLANLinkCommon::Mtu() const 

    {

    DEBUG("CLanLinkCommon::Mtu()");

    TInt err = KErrNone;

    CRepository* repository = NULL;

    TRAP( err, repository = CRepository::NewL( KCRUidWlanDeviceSettingsRegistryId ) );

    if( err != KErrNone )

        {

        DEBUG1( "Could not access repository (%d), using default value for mtu(1500)", err );

        return KEtherMaxDataLen;

        }

    // No need to use CleanupStack because no possibility to leave

    TInt temp = 0;

    err = repository->Get( KWlanMTU, temp );

    if( err == KErrNone ) 

        {

        delete repository;

        DEBUG1("MTU value from cenrep is:%d", temp);

        if( temp > KEtherMaxDataLen || temp <= 0 )

            {

            DEBUG("MTU from cenrep is out of range 1-1500, setting it to 1500");

            temp = KEtherMaxDataLen;

            }

        return temp;

        }

    else

        {

        DEBUG1( "Could not access repository (%d), using default value for mtu(1500)", err );

        delete repository;

        return KEtherMaxDataLen;

        } 

    }

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

// CLANLinkCommon::ConstructL

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

//

EXPORT_C void CLANLinkCommon::ConstructL()

    {

    DEBUG("CLANLinkCommon::ConstructL()");

    // Initialise class members that do not need to be read from the database

    iBearers = new (ELeave) CLanxBearerPtrArray(KLanxBearerPtrArrayGranularity);

    iEtherType = EStandardEthernet;

    iOnlyThisBearer = NULL;

    }

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

// CLANLinkCommon::~CLANLinkCommon

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

//

EXPORT_C CLANLinkCommon::~CLANLinkCommon()

    {

    DEBUG("CLANLinkCommon::~CLANLinkCommon()");

    delete iPktDrv;

    ASSERT(0 == iBearers->Count());

    delete iBearers;

    delete iPeriodic;

    delete iWLMServerCommon;

	for( TUint idx( 0 ); idx < EWlmAccessClassMax; ++idx )

	    {

	    delete iAcArray[idx];	    

	    }

    LOG_NODE_DESTROY(KWlanLog, CLANLinkCommon);

    }

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

// CLANLinkCommon::CheckMac

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

//

TBool CLANLinkCommon::CheckMac(TDes8& aMacAddr)

    {

    DEBUG("CLANLinkCommon::CheckMac()");

    TUint MacBytes = 6;

    for (TUint i=0;i<MacBytes;i++)

        {

        if (aMacAddr[i] != 0)

            {

            return ETrue;

            }

        }

    return EFalse;

    }

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

// CLANLinkCommon::AcTrafficModeChanged

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

//

void CLANLinkCommon::AcTrafficModeChanged(

    TWlmAccessClass aAccessClass,

    TWlmAcTrafficMode aMode )

    {

    DEBUG( "CLANLinkCommon::AcTrafficModeChanged()" );

    iAcArray[aAccessClass]->SetTrafficMode( aMode );

    }

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

// CLANLinkCommon::AcTrafficModeChanged

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

//

void CLANLinkCommon::AcTrafficStatusChanged(

    TWlmAccessClass aAccessClass,

    TWlmAcTrafficStatus aStatus )

    {

    DEBUG( "CLANLinkCommon::AcTrafficStatusChanged()" );

    iAcArray[aAccessClass]->SetTrafficStatus( aStatus );

    }

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

// CLANLinkCommon::LinkLayerUp

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

//

/**

Link Layer Up

Called by the packet driver when it is happy

*/

EXPORT_C void CLANLinkCommon::LinkLayerUp()

    {

    DEBUG("CLANLinkCommon::LinkLayerUp()");

    //some drivers have a valid MAC only after negotiation finishes

    iValidMacAddr = ReadMACSettings();

    PostDataClientStartedMessage();

    /**

     * With the new comms framework, this KLinkLayerOpen always sent and then will be caught and swallowed

     * at the ipproto layer if a netcfgext is being used.

     */

    /**

     * We are forced to signal link layer open from here even though there may not

     * be a configured IP address.  This is a dirty fix because of politics...

     */

    PostProgressMessage(KLinkLayerOpen, KErrNone);

    TUint bearerLim = iBearers->Count();

    for(TUint index=0;index<bearerLim;index++)

        {

        CLanxBearer *bearer=(*iBearers)[index];

        bearer->StartSending((CProtocolBase*)this);

        }

	// Get current traffic status for access classes.

	TWlmAcTrafficStatusArray acArray;

	TInt ret = iWLMServerCommon->GetAcTrafficStatus( acArray );

	if( ret != KErrNone )

	    {

	    DEBUG1( "CLANLinkCommon::LinkLayerUp() - RWLMServer::GetAcTrafficStatus() failed with %d",

	        ret );

	    // Assume all access classes are admitted.

	    for( TUint idx( 0 ); idx < EWlmAccessClassMax; ++idx )

	         {

	         iAcArray[idx]->SetTrafficStatus( EWlmAcTrafficStatusAdmitted );

	         }

	    }

	else

	    {

	    // Update access class instances with the current status.

        for( TUint idx( 0 ); idx < EWlmAccessClassMax; ++idx )

             {

             iAcArray[idx]->SetTrafficStatus( acArray[idx] );

             }

	    }

    }

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

// CLANLinkCommon::LinkLayerDown

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

//

EXPORT_C void CLANLinkCommon::LinkLayerDown(TInt aError, TAction aAction)

/**

Link Layer Down

Called by the packet driver when the link has gone down

@param aError error code

@param aAction whether a reconnect is required or not

*/

    {

    DEBUG("CLANLinkCommon::LinkLayerDown()");

    // If a stop was requested from the SCpr then this LinkLayerDown()

    // was expected. This also means the SCpr has already been sent a

    // TDataClientStopped and the packet driver has been stopped.

    // If on the other hand the stop was not requested a TDataClientGoneDown

    // message needs to be sent to the SCpr and the packet driver still

    // needs a StopInterface call - usually this would mean that aAction

    // is EReconnect

    if (iStopRequested == EFalse && iMMState == EStarted)

        {

        PostProgressMessage(KLinkLayerClosed, aError);

        PostFlowGoingDownMessage(aError, (aAction == EReconnect) ? MNifIfNotify::EReconnect : MNifIfNotify::EDisconnect);

        iPktDrv->StopInterface();

        MaybePostDataClientIdle();

        iMMState = EStopped;

        }

    }

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

// CLANLinkCommon::StopCb

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

//

TInt CLANLinkCommon::StopCb(TAny* aThisPtr)

    {

    DEBUG("CLANLinkCommon::StopCb()");

    CLANLinkCommon* self = static_cast<CLANLinkCommon*>(aThisPtr);

    self->StopInterface();

    return KErrNone;

    }

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

// CLANLinkCommon::StopInterface

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

//

void CLANLinkCommon::StopInterface()

    {

    DEBUG("CLANLinkCommon::StopInterface()");

    if(iPeriodic)

        {

        iPeriodic->Cancel();

        delete iPeriodic;

        iPeriodic = NULL;

        }

    iPktDrv->StopInterface();

    PostProgressMessage(KLinkLayerClosed, iError);

    PostFlowDownMessage(iError);

    MaybePostDataClientIdle();

    }

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

// CLANLinkCommon::EtherFrame

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

//

TInt CLANLinkCommon::EtherFrame(RMBufChain &aPdu, TDesC8& aDestAddr, TUint16 aType, TUint8& aDscp)

    {

    RMBufChain ethHdr;

    TUint etherHeaderSize = (iEtherType==EStandardEthernet) ?

        KEtherHeaderSize : KEtherLLCHeaderSize;

    TRAPD(ret, ethHdr.AllocL(etherHeaderSize));

    if(ret != KErrNone)

        {

        return ret;

        }

    TEtherLLCFrame *hdrBuf = reinterpret_cast<TEtherLLCFrame*>(ethHdr.First()->Buffer());

    //Get the packet info:

    RMBufPktInfo* info = RMBufPacket::PeekInfoInChain(aPdu);

    // Fill in the dest, src Mac addresses:

    hdrBuf->SetDestAddr(aDestAddr);

    hdrBuf->SetSrcAddr(iMacAddr);

    switch(iEtherType)

        {

        case EStandardEthernet:

            BigEndian::Put16((TUint8*)&hdrBuf->iType,aType);

            break;

        case ELLCEthernet:

            // Several fields to fill in. According to nifmbuf.h,

            // info->iLength gives the actual length of the packet.

            BigEndian::Put16((TUint8*)&hdrBuf->iLen,static_cast<TInt16>(info->iLength));

            hdrBuf->iDSAP=KLLC_SNAP_DSAP;

            hdrBuf->iSSAP=KLLC_SNAP_SSAP;

            hdrBuf->iCtrl=KLLC_SNAP_CTRL;

            hdrBuf->SetOUI(0);

            hdrBuf->SetType(aType);

            break;

        default:

            // Can't handle any other kind of Ethernet header.

            return KErrGeneral;

        }

    //Remove the original first Packet - by trimming the info from the packet.

    aPdu.TrimStart(aPdu.Length() - info->iLength); // At this point, info becomes invalid.

    //Extract the DSCP value as aPdu points to IP packet now

    if (KIPFrameType == aType)

        {

        TInet6HeaderIP4 *ipv4hdr = (TInet6HeaderIP4 *)aPdu.First()->Ptr();

        TUint8 TOS = ipv4hdr->TOS();

        aDscp = (TOS >> 2) & 0xff;

        DEBUG2( "CLanLinkCommon::EtherFrame() - DSCP of the IPv4 packet: 0x%02X (%u)",

	        aDscp, aDscp );

        }

    else if (KIP6FrameType == aType)

        {

        TInet6HeaderIP *ipv6hdr = (TInet6HeaderIP *)aPdu.First()->Ptr();

        TUint8 TrafficClass = ipv6hdr->TrafficClass();

        aDscp = (TrafficClass >> 2) & 0xff;     

        DEBUG2( "CLanLinkCommon::EtherFrame() - DSCP of the IPv6 packet: 0x%02X (%u)",

	        aDscp, aDscp );

        }

    //Finally, add the saved packet buffer to the mac header

    aPdu.Prepend(ethHdr);

    return KErrNone;

    }

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

// CLANLinkCommon::FrameSend

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

//

TInt CLANLinkCommon::FrameSend(

    RMBufChain& aPdu,

    TDesC8& aDestAddr,

    TUint16 aType )

	{

	// Call down from the Protocol