/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* 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:

*

*

*/

#define TRACE_PREFIX "WSOCK: ServProvider: "

#include <es_mbuf.h>

#include "wsock.h"

#include "WinsockProtocol.h"

#include "WinsockProtocolFamily.h"

#include "WinsockServProvider.h"

#include "WinsockUtils.h"

#define KMaxInetAddrBufSize 64

// CWinsockServProvider::CWriteData

class CWinsockServProvider::CWriteData : public CBase

{

public:

    TDblQueLink iLink;

    TSockAddr* iAddr;

    HBufC8* iData;

public:

    static CWriteData* New(const TDesC8& aData, TSockAddr* aAddr);

    ~CWriteData();

};

// CWinsockServProvider::CWriteRequest

class CWinsockServProvider::CWriteRequest : public CActive

{

private:

    CWinsockServProvider* iProvider;

    RTimer iTimer;

    TBool iTimerCreated;

    TBool iTimerActive;

public:

    CWriteRequest(CWinsockServProvider* aProvider);

    ~CWriteRequest();

    void Submit(TInt aDelay = 0);

    // CActive

    virtual void DoCancel();

    virtual void RunL();

};

// CWinsockServProvider::CSelectRequest

class CWinsockServProvider::CSelectRequest : public CActive,

                                             public MSelectRequest

{

private:

    CWinsockServProvider* iProvider;

    RThread iServerThread;

    TInt iSelectMask;

public:

    static CSelectRequest* NewLC(CWinsockServProvider* aProvider);

    virtual ~CSelectRequest();

    void SubmitL();

    // CActive

    virtual void DoCancel();

    virtual void RunL();

    // MSelectRequest

    virtual TUint Socket();

    virtual TInt SelectMask();

    virtual void SelectComplete(TInt aSelectMask);

private:

    CSelectRequest(CWinsockServProvider* aProvider);

    void ConstructL();

};

// CWinsockServProvider::CNewDataNotifier

class CWinsockServProvider::CNewDataNotifier : public CActive

{

private:

    CWinsockServProvider* iProvider;

public:

    CNewDataNotifier(CWinsockServProvider* aProvider);

    void Submit();

    // CActive

    virtual void DoCancel();

    virtual void RunL();

};

// CWinsockServProvider

#define SUPER CServProviderBase

CWinsockServProvider* CWinsockServProvider::NewL(CWinsockProtocol* aProtocol)

{

    return new(ELeave)CWinsockServProvider(aProtocol);

}

CWinsockServProvider* CWinsockServProvider::FromSocket(CWinsockProtocol* aPro,

                                                       TInt aSocket,

                                                       TInt aFamily)

{

    ASSERT(aFamily != 0);

    ASSERT(aSocket != INVALID_SOCKET);

    CWinsockServProvider* self = new CWinsockServProvider(aPro);

    if (self) {

        self->iWinSocket = aSocket;

        self->iFamily = aFamily;

        self->iFlags |= (EFlagConnect | EFlagNeedSelect);

        // Select will be called from SetNotify. Otherwise, under some rare

        // circumstances select may complete and NewDataCheck is invoked

        // before SetNotify has been invoked and therefore iSocket is still

        // NULL.

    }

    return self;

}

CWinsockServProvider::CWinsockServProvider(CWinsockProtocol* aProtocol) :

iProtocol(aProtocol),

iWinSocket(INVALID_SOCKET),

iWriteQ(_FOFF(CWriteData,iLink)),

iTcpSendWinSize(8192),

iTcpRecvWinSize(8192),

iTcpMaxSegSize(1460),

iUdpRecvBuf(8192)

{

    WTRACE("created");

}

CWinsockServProvider::~CWinsockServProvider()

{

    iProtocol->SetReadPending(this, EFalse);

    if (iWrite)

    {

        iWrite->Cancel();

        delete iWrite;

    }

    if (iNewData)

    {

        iNewData->Cancel();

        delete iNewData;

    }

    if (iSelect)

    {

        CWinsockSelectThread::Static()->Cancel(iSelect);

        iSelect->Cancel();

    }

    if (iAdapterInfo)

    {

        User::Free(iAdapterInfo);

    }

    if (iWinSocket != INVALID_SOCKET)

    {

        closesocket(iWinSocket);

    }

#ifdef V1_5_PRT_INTERFACE

    if (iDataBuf)

    {

        delete iDataBuf;

    }

#endif

    WTRACE("destroyed");

}

// Returns the socket, or creates one using default address family.

TInt CWinsockServProvider::Socket() const

{

    CWinsockServProvider* This = (CWinsockServProvider*)this;

    return This->Socket(Family());

}

// Returns the socket, creating one if necessary. Note that the requested

// address family may not match the protocol family given to us in the

// constructor. That's because some Symbian code (such as HTTP protocol

// framework) may, for example, create an IPv4 socket and then connect

// it to an IPv6 address. Also note that once we have created the Windows

// socket we can't change its address family.

TInt CWinsockServProvider::Socket(TUint aFamily)

{

    if (iWinSocket == INVALID_SOCKET)

    {

        if (!aFamily) aFamily = Family();

        TInt af = (aFamily == KAfInet6) ? AF_INET6 : AF_INET;

        TInt type = iProtocol->ProtocolDesc()->iWinSockType;

        TInt protocol = iProtocol->ProtocolDesc()->iWinProtocol;

        iWinSocket = socket(af, type, protocol);

        if (iWinSocket == INVALID_SOCKET)

        {

            WTRACE4("socket(%d,%d,%d) failed, err %d",af, type, protocol,

            WSAGetLastError());

        }

        else

        {

            // Remember the actual address family

            iFamily = aFamily;

            WTRACE2("created %s %S socket", (af == AF_INET6) ?

                _S("IPv6") : _S("IPv4"), &iProtocol->ProtocolDesc()->iName);

            // Connection-less sockets immediately start accepting

            // incoming datagrams

            if (iProtocol->IsDatagramProtocol())

            {

                Select();

            }

        }

    }

    else

    {

        // This ASSERT means that we have already created the Windows socket

        // and then we were asked to connect or bind it to the address with

        // a different address family. That's bad.

        ASSERT(!aFamily || aFamily == iFamily);

    }

    return iWinSocket;

}

// Returns address family of this socket in Symbian format,

// i.e. KAfInet or KAfInet6

TUint CWinsockServProvider::Family() const

{

    if (iFamily)

    {

        // The socket has already been created

        return iFamily;

    }

    else if (iRemAddr.Family())

    {

        // Assume the same address family as in remote address. That makes

        // URLs like http://[fe80::a00:20ff:fef9:bf8]/ work in the browser.

        // In that case we get the following sequence of calls:

        //    SetRemName -> AutoBind -> ActiveOpen

        // This allows us to create the socket of the right type in AutoBind.

        return iRemAddr.Family();

    }

    else

    {

        // With no additional information, assume the address family from

        // the protocol object.

        return iProtocol->ProtocolDesc()->iAddrFamily;

    }

}

// CServProviderBase

void CWinsockServProvider::Start()

{

    WTRACE("Start()");

}

void CWinsockServProvider::SetNotify(MSocketNotify* aSocket)

{

    WTRACE1("SetNotify(%08X)",aSocket);

    SUPER::SetNotify(aSocket);

    if (iFlags & EFlagNeedSelect)

    {

        iFlags &= ~EFlagNeedSelect;

        Select();

    }

}

typedef int (WSAAPI *GetSockNameProc)(

    SOCKET s,

    struct sockaddr* name,

    int* namelen

);

static void GetSockName(SOCKET sock, TSockAddr& aAddr,

                        GetSockNameProc aFunction,

                        const TText* DEBUG_ONLY(aFunctionName))

{

    WSockAddr sa;

    int namelen = SOCKADDR_SIZE;

    int err = aFunction(sock, &sa.Address, &namelen);

    if (!err)

    {

        WinsockUtils::ToInetAddr(&aAddr,&sa);

    }

    else

    {

        TRACE2("%s failed, error %d\n",aFunctionName,err);

    }

}

void CWinsockServProvider::LocalName(TSockAddr& aAddr) const

{

    if (Socket() == INVALID_SOCKET)

    {

        WTRACE("LocalName() - no socket");

    }

    else

    {

        GetSockName(iWinSocket,aAddr,getsockname,_S("getsockname"));

    }

}

// Wrapper around WinsockUtils::ToSockAddr which attempts to convert

// the address into the form compatible with the address family of

// this socket.

int CWinsockServProvider::ToSockAddr(union _WSockAddr* aToAddr,

                                     const TSockAddr* aFromAddr)

{

    if (Family() == KAfInet6 && aFromAddr->Family() == KAfInet)

    {

        // Convert IPv4 address to IPv4-mapped IPv6 address.

        TInetAddr ipv6(*aFromAddr);

        ipv6.ConvertToV4Mapped();

        ASSERT(ipv6.Family() == KAfInet6);

        return WinsockUtils::ToSockAddr(aToAddr, &ipv6);

    }

    if (Family() == KAfInet && aFromAddr->Family() == KAfInet6)

    {

        TInetAddr& ipv6 = TInetAddr::Cast(aFromAddr);

        if (ipv6.IsV4Mapped() || ipv6.IsV4Compat())

        {

            // Convert IPv4 compatible IPv6 address to IPv4

            TInetAddr ipv4(ipv6);

            ipv4.ConvertToV4();

            return WinsockUtils::ToSockAddr(aToAddr, &ipv4);

        }

    }

    // Do the default conversion

    return WinsockUtils::ToSockAddr(aToAddr, aFromAddr);

}

TInt CWinsockServProvider::SetLocalName(TSockAddr& aAddr)

{

#ifdef _REALLY_DEBUG

    TBuf<KMaxInetAddrBufSize> buf;

    TInetAddr::Cast(aAddr).OutputWithScope(buf);

    if (buf.Length() == 0) buf.Append('*');

    WTRACE2("SetLocalName(%S,%d)",&buf,aAddr.Port());

#endif // _REALLY_DEBUG

    if (Socket(aAddr.Family()) == INVALID_SOCKET)

    {

        WTRACE("SetLocalName - no socket");

        iFlags |= EFlagError;

        return KErrNotSupported;

    }

    // Bind new socket to the specified address

    WSockAddr sa;

    int len = ToSockAddr(&sa, &aAddr);

    int err = bind(iWinSocket, &sa.Address, len);

    if (err)

    {

        WTRACE1("bind failed, err %d",WSAGetLastError());

        return KErrArgument;

    }

    else

    {

#ifdef _REALLY_DEBUG

        TInetAddr localAddr;

        GetSockName(iWinSocket,localAddr,getsockname,_S("getsockname"));

        localAddr.OutputWithScope(buf);

        WTRACE2("bound to %S port %d",&buf,localAddr.Port());

#endif // _REALLY_DEBUG

        return KErrNone;

    }

}

void CWinsockServProvider::RemName(TSockAddr& aAddr) const

{

    if (iFlags & EFlagConnect)

    {

        GetSockName(iWinSocket,aAddr,getpeername,_S("getpeername"));

    }

    else

    {

        aAddr = iRemAddr;

    }

}

TInt CWinsockServProvider::SetRemName(TSockAddr& aAddr)

{

    iRemAddr = TInetAddr::Cast(aAddr);

#ifdef _REALLY_DEBUG

    TBuf<KMaxInetAddrBufSize> buf;

    iRemAddr.OutputWithScope(buf);

    WTRACE2("SetRemName(%S,%d)",&buf,iRemAddr.Port());

#endif // _REALLY_DEBUG

    if (iProtocol->IsDatagramProtocol())

    {

        // application called connect() on datagram-socket. Propagate call to

        // Winsock. (In case of stream-socket, connect() appears to happen

        // ActiveOpen()-call, but that is not called in case of udp-socket.)

        Connect();

    }

    return KErrNone;

}

void CWinsockServProvider::Ioctl(TUint DEBUG_ONLY(aLevel),

                                 TUint DEBUG_ONLY(aName),

                                 TDes8* /*anOption*/)

{

    WTRACE2("Ioctl(%d,%08X)",aLevel,aName);

}

void CWinsockServProvider::CancelIoctl(TUint DEBUG_ONLY(aLevel),

                                       TUint DEBUG_ONLY(aName))

{

    WTRACE2("CancelIoctl(%d,%08X)",aLevel,aName);

}

TInt CWinsockServProvider::SetOption(TUint aLevel, TUint aName,

                                     const TDesC8& aOption)

{

    switch (aLevel)

    {

    case KSOLSocket:

        WTRACE1("SetOption(KSOLSocket,%08X)",aName);

        return KErrNone;

    case KSolInetIfCtrl:

        switch (aName)

        {

        case KSoInetEnumInterfaces:

            WTRACE("SetOption(KSoInetEnumInterfaces)");

            if (iAdapterInfo)

            {

                User::Free(iAdapterInfo);

                iAdapterInfo = NULL;

            }

            iAdapterInfo = iProtocol->GetAdapterInfo();

            iNextAdapter = iAdapterInfo;

            iLastAdapter = NULL;

            return KErrNone;

        default:

            WTRACE1("SetOption(KSolInetIfCtrl,%08X)",aName);

            break;

        }

    case KSOLProvider:

        switch (aName)

        {

        case KSoConnectionInfo:

            iConnectionInfo = *((TSoIfConnectionInfo*)aOption.Ptr());

            WTRACE2("SetOption(KSoConnectionInfo) IAP %d, network %d",

                   iConnectionInfo.iIAPId, iConnectionInfo.iNetworkId);

            return KErrNone;

        default:

            WTRACE1("SetOption(KSOLProvider,%08X) - UNSUPPORTED",aName);

            break;

        }

        break;

    case KSolInetIp:

        switch (aName)

        {

        case KSoIpTTL:

            WTRACE1("SetOption(KSoIpTTL) %d",*((int*)aOption.Ptr()));

            if (!setsockopt(Socket(), IPPROTO_IP, IP_TTL,

                (char*)aOption.Ptr(), aOption.Length()))

            {

                return KErrNone;

            }

            WTRACE1("setsockopt(IP_TTL) error %d",WSAGetLastError());

            break;

        case KSoReuseAddr:

            WTRACE1("SetOption(KSoReuseAddr) %d",*((int*)aOption.Ptr()));

            if (!setsockopt(Socket(), SOL_SOCKET, SO_REUSEADDR,

                (char*)aOption.Ptr(), aOption.Length()))

            {

                return KErrNone;

            }

            WTRACE1("setsockopt(SO_REUSEADDR) error %d",WSAGetLastError());

            break;

        default:

            WTRACE1("SetOption(KSolInetIp,%08X)",aName);

            break;

        }

        break;

    case KSolInetTcp:

        if (iProtocol->ProtocolDesc()->iProtocol == KProtocolInetTcp) {

            switch (aName)

            {

            case KSoTcpSendWinSize:

                WTRACE("SetOption(KSoTcpSendWinSize)");

                if (iFlags & EFlagConnect) return KErrLocked;

                if (aOption.Length() != sizeof(TInt)) return KErrArgument;

                iTcpSendWinSize = *((TInt*)aOption.Ptr());

                return KErrNone;

            case KSoTcpRecvWinSize:

                WTRACE("SetOption(KSoTcpSendWinSize)");

                if (iFlags & EFlagConnect) return KErrLocked;

                if (aOption.Length() != sizeof(TInt)) return KErrArgument;

                iTcpRecvWinSize = *((TInt*)aOption.Ptr());

                return KErrNone;

            case KSoTcpMaxSegSize:

                WTRACE("SetOption(KSoTcpMaxSegSize)");

                if (iFlags & EFlagConnect) return KErrLocked;

                if (aOption.Length() != sizeof(TInt)) return KErrArgument;

                iTcpMaxSegSize = *((TInt*)aOption.Ptr());

                return KErrNone;

            case KSoTcpNoDelay:

                WTRACE1("SetOption(KSoTcpNoDelay) %d",*((TInt*)aOption.Ptr()));

                if (!setsockopt(Socket(), IPPROTO_TCP, TCP_NODELAY,

                    (char*)aOption.Ptr(),aOption.Length())) return KErrNone;

                WTRACE1("setsockopt(TCP_NODELAY) error %d",WSAGetLastError());

                break;

            case KSoTcpKeepAlive:

                WTRACE1("SetOption(KSoTcpKeepAlive) %d",*((TInt*)aOption.Ptr()));

                if (!setsockopt(Socket(), SOL_SOCKET, SO_KEEPALIVE,

                    (char*)aOption.Ptr(),aOption.Length())) return KErrNone;

                WTRACE1("setsockopt(SO_KEEPALIVE) error %d",WSAGetLastError());

                break;

            default:

                WTRACE1("SetOption(KSolInetTcp,%08X) - UNSUPPORTED",aName);

                break;

            }

        } else {

            WTRACE1("SetOption(KSolInetTcp,%08X) - not a TCP socket!",aName);

        }

        break;