/*

* Copyright (c) 2004-2005 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:

*

*/

#define TRACE_PREFIX "WSOCK: Interface: "

#include "wsock.h"

#include "WinsockInterface.h"

#include "WinsockProtocolFamily.h"

#include <es_enum_partner.h>

const TInt KWinsockSubConnectionId = 1;

const TConnectionType EWinsockConnectionType = EConnectionEthernet;

#define super CNifIfLink 

// CWinsockInterface::CallbackQueueEntry

class CWinsockInterface::CallbackQueueEntry

{

private:

    CWinsockInterface* iInterface;

    CallbackMethod iMethod;

    TInt iParam1;

    TInt iParam2;

public:

    TSglQueLink iLink;

    CallbackQueueEntry(CWinsockInterface* aInterface, CallbackMethod aMethod,

        TInt aParam1, TInt aParam2) : iInterface(aInterface), 

        iMethod(aMethod), iParam1(aParam1), iParam2(aParam2) {}

    void Invoke() { (iInterface->*iMethod)(iParam1, iParam2); }

};

// CWinsockInterface

CWinsockInterface::CWinsockInterface(CNifIfFactory* aFactory, 

                                     MNifIfNotify* aNotify) : 

super(*aFactory),

iSignature(KWinsockInterfaceSignature),

iCallbackQueue(_FOFF(CallbackQueueEntry,iLink)),

iCallback(TCallBack(AsyncCallbackProc,this),CActive::EPriorityStandard)

{

    iNotify = aNotify;

    iTimeStarted.HomeTime();

    TRACE1("created [%08X]",this);

}

CWinsockInterface::~CWinsockInterface()

{

    CancelOutstandingCallbacks();

    TRACE1("destroyed [%08X]",this);

}

TInt CWinsockInterface::Signature() const

{

    return KWinsockInterfaceSignature;

}

TInt CWinsockInterface::AsyncCallbackProc(TAny* aPtr)

{

    CWinsockInterface* self = (CWinsockInterface*)aPtr;

    self->HandleAsyncCallback();

    return KErrNone;

}

void CWinsockInterface::HandleAsyncCallback()

{

    // Invoke the first callback in the queue

    if (!iCallbackQueue.IsEmpty()) {

        CallbackQueueEntry* entry = iCallbackQueue.First();

        iCallbackQueue.Remove(*entry);

        entry->Invoke();

        delete entry;

        // Schedule the next one

        if (!iCallbackQueue.IsEmpty()) {

            iCallback.CallBack();

        }

    }

}

void CWinsockInterface::ScheduleAsyncCallback(CallbackMethod aMethod,

                                              TInt aP1, TInt aP2)

{

    CallbackQueueEntry* entry = new CallbackQueueEntry(this,aMethod,aP1,aP2);

    if (entry) {

        iCallbackQueue.AddLast(*entry);

        iCallback.Cancel();

        iCallback.CallBack();

    }

}

void CWinsockInterface::CancelOutstandingCallbacks()

{

    iCallback.Cancel();

    while (!iCallbackQueue.IsEmpty()) {

        CallbackQueueEntry* entry = iCallbackQueue.First();

        iCallbackQueue.Remove(*entry);

        delete entry;

    }

}

void CWinsockInterface::NotifyLinkLayerUp(TInt, TInt)

{

    ScheduleAsyncCallback(NotifySubConnectionOpened);

    TRACE("firing LinkLayerUp event");

    iNotify->LinkLayerUp();

}

void CWinsockInterface::NotifyLinkLayerOpen(TInt, TInt)

{

    TRACE("firing LinkLayerOpen event");

    iNotify->IfProgress(KLinkLayerOpen, KErrNone);

}

// Sends a subconnection opened event for the entire connection

void CWinsockInterface::NotifySubConnectionOpened(TInt, TInt)

{

    ScheduleAsyncCallback(NotifyLinkLayerOpen);

    TRACE("firing TSubConnectionOpenedEvent");

    TSubConnectionOpenedEvent event;

    event.iSubConnectionUniqueId = KNifEntireConnectionSubConnectionId;

    TPckg<TSubConnectionOpenedEvent> eventPtr(event);

    iNotify->NifEvent(ESubConnectionEvent, ESubConnectionOpened, eventPtr); 

}

// Sends a subconnection Closed event for the entire connection

void CWinsockInterface::NotifySubConnectionClosed(TInt aReason, TInt)

{

    ScheduleAsyncCallback(NotifyLinkLayerClosed, aReason);

    TRACE("firing TSubConnectionClosedEvent");

    TSubConnectionClosedEvent event;

    event.iSubConnectionUniqueId = KNifEntireConnectionSubConnectionId;

    event.iTotalUplinkDataVolume = iBytesReceived;

    event.iTotalDownlinkDataVolume = iBytesSent;

    event.iTimeClosed.UniversalTime();

    TPckg<TSubConnectionClosedEvent> eventPtr(event);

    iNotify->NifEvent(ESubConnectionEvent, ESubConnectionClosed, eventPtr);

}

void CWinsockInterface::NotifyLinkLayerDown(TInt aReason, TInt aAction)

{

    ScheduleAsyncCallback(NotifySubConnectionClosed, aReason);

    TRACE("firing LinkLayerDown event");

    iNotify->LinkLayerDown(aReason, (MNifIfNotify::TAction)aAction);

}

void CWinsockInterface::NotifyLinkLayerClosed(TInt aReason, TInt)

{

    TRACE("firing LinkLayerClosed event");

    iNotify->IfProgress(KLinkLayerClosed, aReason);

}

void CWinsockInterface::DataSent(TUint aBytes)

{

    // Handle rollover?

    iBytesSent += aBytes;

    if (iBytesSentGranularity)

    {

        TUint delta = iBytesSent - iBytesSentMark;

        if (delta >= iBytesSentGranularity)

        {

            int chunks = delta/iBytesSentGranularity;

            iBytesSentMark += chunks*iBytesSentGranularity;

        }

    }

}

void CWinsockInterface::DataReceived(TUint aBytes)

{

    // Handle rollover?

    iBytesReceived += aBytes;

    if (iBytesReceivedGranularity)

    {

        TUint delta = iBytesReceived - iBytesReceivedMark;

        if (delta >= iBytesReceivedGranularity)

        {

            int chunks = delta/iBytesReceivedGranularity;

            iBytesReceivedMark += chunks*iBytesReceivedGranularity;

            iNotify->NotifyDataReceived(KWinsockSubConnectionId,

                delta*iBytesReceivedGranularity);

        }

    }

}

// CNifIfBase

void CWinsockInterface::Info(TNifIfInfo& aInfo) const

{

    aInfo.iName = KWinsockInterface;

    aInfo.iVersion = TVersion(1,0,0);

    aInfo.iFlags = KNifIfIsBase | KNifIfIsLink | KNifIfUsesNotify | KNifIfCreatedByFactory;

    aInfo.iProtocolSupported = 0;

    for (TInt i=0; i<CWinsockProtocolFamily::ProtocolCount(); i++)

    {

        const TServerProtocolDesc* p = CWinsockProtocolFamily::ProtocolDesc(i);

        aInfo.iProtocolSupported |= p->iProtocol;

    }

}

TInt CWinsockInterface::Send(RMBufChain& /*aPdu*/, TAny* /*aSource*/)

{

    TRACE("Send()");

    return KErrNotSupported;

}

TInt CWinsockInterface::Notification(TAgentToNifEventType DEBUG_ONLY(aEvent),

                                     TAny* /*aInfo*/)

{

    TRACE1("Notification(%d)",aEvent);

    return KErrNotSupported;

}

// CNifIfLink

TInt CWinsockInterface::Start()

{

    TRACE("Start()");

    ScheduleAsyncCallback(NotifyLinkLayerUp);

    return KErrNone;

}

void CWinsockInterface::Stop(TInt aReason, MNifIfNotify::TAction aAction)

{

    TRACE2("Stop(%d,%d)",aReason, aAction);

    CancelOutstandingCallbacks();

    ScheduleAsyncCallback(NotifyLinkLayerDown, aReason, aAction);

}

CNifIfBase* CWinsockInterface::GetBinderL(const TDesC& DEBUG_ONLY(aName))

{

    TRACE1("GetBinderL(%S)",&aName);

    return this;

}

TInt CWinsockInterface::Control(TUint aLevel,TUint aName,TDes8& aOption, 

                                TAny* aSource)

{

    TRACE3("Control(%d,%08X), %d bytes",aLevel,aName,aOption.Length());

	switch (aLevel)

    {

  /*  case KCOLInterface:

        switch (aName)

        {

        case KCOGetNifEMIPtr:

        default:

            {

                MNifIfExtendedManagementInterface** that = 

                    (MNifIfExtendedManagementInterface**)aOption.Ptr();

                if (aOption.Length() == sizeof(*that))

                {

                    MNifIfExtendedManagementInterface* This = this;

                    TRACE1("MNifIfExtendedManagementInterface = %08X",This);

                    *that = This;

                    return KErrNone;

                }

                else

                {

                    return KErrArgument;

                }

            }

            break;

        }

        break;

*/

    case KCOLAgent:

        switch (aName)

        {

        case KCOGetAgentEMIPtr:

            {

                MNifAgentExtendedManagementInterface** that = 

                    (MNifAgentExtendedManagementInterface**)aOption.Ptr();

                if (aOption.Length() == sizeof(*that))

                {

                    MNifAgentExtendedManagementInterface* This = this;

                    TRACE1("MNifAgentExtendedManagementInterface = %08X",This);

                    *that = This;

                    return KErrNone;

                }

                else

                {

                    return KErrArgument;

                }

            }

        default:

            break;

        }

        break;

    default:

        break;

    }

    return super::Control(aLevel, aName, aOption, aSource);

}

// MNifIfExtendedManagementInterface

TInt CWinsockInterface::Stop(TSubConnectionUniqueId aId, 

                             TInt DEBUG_ONLY(aReason))

{

    TRACE2("Stop(%d,%d)", aId, aReason);

    switch (aId)

    {

    case KNifEntireConnectionSubConnectionId:

    case KWinsockSubConnectionId:

        return KErrNone;

    default:

        return KErrNotFound;

    }

}

TInt CWinsockInterface::GetDataTransferred(TSubConnectionUniqueId aId, 

                                           TUint& aSentBytes, 

                                           TUint& aReceivedBytes)

{

    TRACE1("GetDataTransferred(%d)", aId);

    switch (aId)

    {

    case KNifEntireConnectionSubConnectionId:

    case KWinsockSubConnectionId:

        aSentBytes = iBytesSent;

        aReceivedBytes = iBytesReceived;

        return KErrNone;

    default:

        return KErrNotFound;

    }

}

TInt CWinsockInterface::SetDataSentNotificationGranularity(TSubConnectionUniqueId aId, 

                                                           TUint aGranularity)

{

    TRACE2("SetDataSentNotificationGranularity(%d,%d)", aId, aGranularity);

    switch (aId)

    {

    case KNifEntireConnectionSubConnectionId:

    case KWinsockSubConnectionId:

        iBytesSentGranularity = aGranularity;

        return KErrNone;

    default:

        return KErrNotFound;

    }

}

TInt CWinsockInterface::CancelDataSentNotification(TSubConnectionUniqueId aId)

{

    TRACE1("CancelDataSentNotification(%d)", aId);

    switch (aId)

    {

    case KNifEntireConnectionSubConnectionId:

    case KWinsockSubConnectionId:

        iBytesSentGranularity = 0;

        return KErrNone;

    default:

        return KErrNotFound;

    }

}

TInt CWinsockInterface::SetDataReceivedNotificationGranularity(TSubConnectionUniqueId aId, 

                                                               TUint aGranularity)

{

    TRACE2("SetDataReceivedNotificationGranularity(%d,%d)", aId, aGranularity);

    switch (aId)

    {

    case KNifEntireConnectionSubConnectionId:

    case KWinsockSubConnectionId:

        iBytesReceivedGranularity = aGranularity;

        return KErrNone;

    default:

        return KErrNotFound;

    }

}

TInt CWinsockInterface::CancelDataReceivedNotification(TSubConnectionUniqueId aId)

{

    TRACE1("CancelDataReceivedNotification(%d)", aId);

    switch (aId)

    {

    case KNifEntireConnectionSubConnectionId:

    case KWinsockSubConnectionId:

        iBytesReceivedGranularity = 0;

        return KErrNone;

    default:

        return KErrNotFound;

    }

}

// MNifAgentExtendedManagementInterface

TInt CWinsockInterface::GetInterfaceType(TConnectionType& aConnectionType)

{

    aConnectionType = EWinsockConnectionType;

    return KErrNone;

}

TInt CWinsockInterface::EnumerateSubConnections(TUint& aCount)

{

    aCount = 1;

    return KErrNone;

}

TInt CWinsockInterface::GetSubConnectionInfo(TUint aIndex, 

                                             TDes8& aInfo)

{

    if (aInfo.Length() != sizeof(TSubConnectionInfo))

    {

        return KErrArgument;

    }

    TSubConnectionInfo* info = (TSubConnectionInfo*)aInfo.Ptr();

    switch (aIndex)

    {

    case KNifEntireConnectionSubConnectionId:

    case KWinsockSubConnectionId:

        info->iConnectionType = EWinsockConnectionType;

        info->iSubConnectionUniqueId = aIndex;

        info->iTimeStarted = iTimeStarted;

        return KErrNone;

    default:

        return KErrNotFound;

    }

}

TInt CWinsockInterface::GetSubConnectionInfo(TDes8& aInfo)

{

    if (aInfo.Length() != sizeof(TSubConnectionInfo))

    {

        return KErrArgument;

    }

    TSubConnectionInfo* info = (TSubConnectionInfo*)aInfo.Ptr();

    return GetSubConnectionInfo(info->iSubConnectionUniqueId, aInfo);

}