/*

* Copyright (c) 2004-2006 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: 

*

*/

#define TRACE_PREFIX "WSOCK: Protocol: "

#include "wsock.h"

#include "WinsockProtocol.h"

#include "WinsockProtocolFamily.h"

#include "WinsockHostResolver.h"

#include "WinsockServProvider.h"

#include "WinsockUtils.h"

CWinsockProtocol::CWinsockProtocol(const TWinProtocolDesc* aProtocolDesc) :

iProtocolDesc(aProtocolDesc)

{

    TRACE3("[%08X] created %s %S protocol",this,

        (iProtocolDesc->iAddrFamily == KAfInet6) ? _S("IPv6") : _S("IPv4"),

        &iProtocolDesc->iName);

}

CWinsockProtocol::~CWinsockProtocol()

{

    iReadPending.Reset();

    if (iIpHlpApi)

    {

        BEGIN_WIN32();

        FreeLibrary((HMODULE)iIpHlpApi);

        END_WIN32();

    }

    TRACE2("[%08X] deleted %S protocol",this,&iProtocolDesc->iName);

}

TBool CWinsockProtocol::IsStreamProtocol() const

{

    return (iProtocolDesc->iSockType == KSockStream);

}

TBool CWinsockProtocol::IsDatagramProtocol() const

{

    return (iProtocolDesc->iSockType == KSockDatagram);

}

void CWinsockProtocol::DataSent(TUint aBytes)

{

    if (iWinsockInterface)

    {

        iWinsockInterface->DataSent(aBytes);

    }

    else if (iIfNotify)

    {

        iIfNotify->NotifyDataSent(KNifEntireConnectionSubConnectionId,aBytes);

    }

}

void CWinsockProtocol::DataReceived(TUint aBytes)

{

    if (iWinsockInterface)

    {

        iWinsockInterface->DataReceived(aBytes);

    }

    else if (iIfNotify)

    {

        iIfNotify->NotifyDataReceived(KNifEntireConnectionSubConnectionId,aBytes);

    }

}

WinsockIpAdapterInfo* CWinsockProtocol::GetAdapterInfo()

{

    if (!iIpHlpApi && iIpHlpApi != INVALID_HANDLE_VALUE)

    {

        BEGIN_WIN32();

        iIpHlpApi = LoadLibraryA("IPHLPAPI.DLL");

        if (iIpHlpApi)

        {

            iGetAdapterInfo = (GetAdaptersInfoProc)GetProcAddress((HMODULE)

                              iIpHlpApi, "GetAdaptersInfo");

            if (iGetAdapterInfo)

            {

                END_WIN32();

            }

            else

            {

                FreeLibrary((HMODULE)iIpHlpApi);

                END_WIN32();

                iIpHlpApi = INVALID_HANDLE_VALUE;

                TRACE("failed to find GetAdaptersInfo in IPHLPAPI.DLL");

            }

        }

        else

        {

            END_WIN32();

            iIpHlpApi = INVALID_HANDLE_VALUE;

            TRACE1("failed to load IPHLPAPI.DLL, err %d",GetLastError());

        }

    }

    WinsockIpAdapterInfo* info = NULL;

    if (iGetAdapterInfo)

    {

        TUint len = 0;

        BEGIN_WIN32();

        TUint err = iGetAdapterInfo(NULL, &len);

        END_WIN32();

        if (err == ERROR_BUFFER_OVERFLOW && len > 0)

        {

            info = (WinsockIpAdapterInfo*)User::Alloc(len);

            if (info)

            {

                BEGIN_WIN32();

                err = iGetAdapterInfo(info, &len);

                END_WIN32();

                if (err != ERROR_SUCCESS)

                {

                    TRACE1("GetAdapterInfo err %d",err);

                    User::Free(info);

                    info = NULL;

                }

            }

        }

    }

    return info;

}

// Notifies CWinsockProtocol that there are unread data in a particular

// socket.

void CWinsockProtocol::SetReadPending(CWinsockServProvider* aSocket, 

                                      TBool aPending)

{

    TInt index = iReadPending.FindInAddressOrder(aSocket);

    if (aPending)

    {

        if (index < 0)

        {

            iReadPending.InsertInAddressOrder(aSocket);

            TRACE2("[%08X] %d socket(s) have unread data",this,

                iReadPending.Count());

        }

    }

    else

    {

        if (index >= 0)

        {

            iReadPending.Remove(index);

            TRACE2("[%08X] %d socket(s) have unread data",this,

                iReadPending.Count());

        }

    }

}

// Checks if there are any unread data in any socket associated with this

// protocol.

TBool CWinsockProtocol::ReadPending() const

{

    return (iReadPending.Count() > 0);

}

// CProtocolBase

CServProviderBase* CWinsockProtocol::NewSAPL(TUint DEBUG_ONLY(aSockType))

{

    TRACE3("[%08X] NewSAPL(%d) for %S",this,aSockType,&iProtocolDesc->iName);

    return CWinsockServProvider::NewL(this);

}

CHostResolvProvdBase* CWinsockProtocol::NewHostResolverL()

{

    return CWinsockHostResolver::NewL(iProtocolDesc);

}

void CWinsockProtocol::Identify(TServerProtocolDesc* aProtocolDesc) const

{

    *aProtocolDesc = *iProtocolDesc;

}

TInt CWinsockProtocol::GetOption(TUint aLevel, TUint aName, TDes8& aOption, 

                                 CProtocolBase* aSourceProtocol)

{

    if(aLevel == KNifOptLevel)

    {

        if(aName == KNifOptGetNifIfUser)

        {

            TNifIfUser ifuser;

            ifuser() = this;

            aOption.Copy(ifuser);

            return KErrNone;

        }

    }

    return CProtocolBase::GetOption(aLevel, aName, aOption, aSourceProtocol);

}

// MNifIfUser

void CWinsockProtocol::IfUserBindFailure(TInt /*aResult*/, TAny* /*aId*/)

{

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

}

void CWinsockProtocol::IfUserNewInterfaceL(CNifIfBase* aIf, TAny* /*aId*/)

{

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

    ASSERT(aIf && aIf->Notify());

    if (aIf) 

    {

        iWinsockInterface = NULL;

        iIfNotify = aIf->Notify();

        CWinsockInterface* mayBeWinsockInterface = (CWinsockInterface*)aIf;

        if (mayBeWinsockInterface->Signature() == KWinsockInterfaceSignature)

        {

            iWinsockInterface = mayBeWinsockInterface;

        }

    }

}

void CWinsockProtocol::IfUserInterfaceDown(TInt /*aResult*/, 

                                           CNifIfBase* DEBUG_ONLY(aIf))

{

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

    ASSERT(aIf && iIfNotify && (aIf->Notify() == iIfNotify));

    iIfNotify = NULL;

    iWinsockInterface = NULL;

}

void CWinsockProtocol::IfUserOpenNetworkLayer()

{

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

    Open();

}

void CWinsockProtocol::IfUserCloseNetworkLayer()

{

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

    Close();

}

CProtocolBase* CWinsockProtocol::IfUserProtocol()

{

    return this;

}

TBool CWinsockProtocol::IfUserIsNetworkLayerActive()

{

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

    return ETrue;

}

/**

 * Local Variables:

 * c-basic-offset: 4

 * indent-tabs-mode: nil

 * End:

 */