/*

* Copyright (c) 2004-2005 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: SelectThread: "

#include "wsock.h"

#include "WinsockSelectThread.h"

#include <winsock2.h>

#ifdef EKA2

// In Series60 version 3.0 they (Symbian) changed the emulator 

// threading model from preemptive to cooperative. That is, only

// one emulated Symbian thread is running at any point of time.

// The threads are never interrupted (with exception of interrupt

// simulation) and must explicitely yield control by making a 

// kernel call (typically, WaitForAnyRequest or something like

// that). It means that if thread blocks on a Win32 event or

// socket, it prevents other threads from running and the emulator

// gets stuck. The Emulator::Escape() call tells the scheduler to

// temporarily remove current thread from the list of scheduled

// threads, which allows other threads to run while we are blocked

// on select. Emulator::Reenter() waits for the currently active

// Symbian thread to yeild control and makes the current thread

// a normal Symbian thread again.

#  define BEGIN_WIN32() Emulator::Escape()

#  define END_WIN32() Emulator::Reenter()

#  include <emulator.h>

#else

#  define BEGIN_WIN32() ((void)0)

#  define END_WIN32() ((void)0)

#endif // EKA2

// Symbian does not support writeable static data, but we don't care because

// this code only runs in the emulator.

static CWinsockSelectThread* instance = NULL;

const TInt ETimeoutInMicroSeconds = 5000000;

CWinsockSelectThread* CWinsockSelectThread::Static()

{

    CWinsockSelectThread* self = NULL;

    TRAPD(err,self = &StaticL());

    return self;

}

CWinsockSelectThread& CWinsockSelectThread::StaticL()

{

    if (!instance)

    {

        instance = NewL();

    }

    return *instance;

}

CWinsockSelectThread* CWinsockSelectThread::NewL()

{

    CWinsockSelectThread* self = new(ELeave)CWinsockSelectThread;

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

}

CWinsockSelectThread::CWinsockSelectThread() : 

iUnblockSocket(INVALID_SOCKET)

{

}

CWinsockSelectThread::~CWinsockSelectThread()

{

    // Normally, this object never gets destroyed

    // Only if ConstructL() leaves

    ASSERT(!iRequests.Count());

    if (iCriticalSectionCreated) iCriticalSection.Close();

    iRequests.Reset();

    if (iUnblockSocket != INVALID_SOCKET) 

    {

        BEGIN_WIN32();

        closesocket(iUnblockSocket);

        END_WIN32();

    }

    delete iAddr.iSockAddrIn;

    delete iTimeout;

}

void CWinsockSelectThread::ConstructL()

{

    iTimeout = new(ELeave)(struct timeval);

    iTimeout->tv_sec = (ETimeoutInMicroSeconds/1000000);

    iTimeout->tv_usec = (ETimeoutInMicroSeconds%1000000);

    iAddr.iSockAddrIn = new(ELeave)(struct sockaddr_in);

    TInt addrSize = sizeof(struct sockaddr_in);

    Mem::FillZ(iAddr.iSockAddrIn, addrSize);

    LEAVE_IF_ERROR(iCriticalSection.CreateLocal());

    // Create a UDP socket for unblocking the select

    BEGIN_WIN32();

    iUnblockSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

    END_WIN32();

    if (iUnblockSocket == INVALID_SOCKET)

    {

        TRACE1("failed to create socket, err %d", WSAGetLastError());

        LEAVE(KErrGeneral);

    }

    iAddr.iSockAddrIn->sin_family = AF_INET;

    iAddr.iSockAddrIn->sin_addr.s_addr = inet_addr("127.0.0.1");

    BEGIN_WIN32();

    int err = bind(iUnblockSocket, iAddr.iSockAddr, addrSize);

    END_WIN32();

    if (err)

    {

        TRACE1("failed to bind, err %d", WSAGetLastError());

        User::Leave(KErrGeneral);

    }

    BEGIN_WIN32();

    err = getsockname(iUnblockSocket, iAddr.iSockAddr, &addrSize);

    END_WIN32();

    if (err)

    {

        TRACE1("failed to getsockname, err %d", WSAGetLastError());

        LEAVE(KErrGeneral);

    }

    TRACE1("notification socket bound to UDP port %d",

        (int)ntohs(iAddr.iSockAddrIn->sin_port));

    // Finally, create and start the thread

    _LIT(threadName,"WinsockSelectThread");

    LEAVE_IF_ERROR(iThread.Create(threadName, Run, KDefaultStackSize,

        NULL, this, EOwnerProcess));

    iThread.Resume();

}

// Wakes up the select thread

TBool CWinsockSelectThread::Wakeup()

{

    char msg[1] = {0};

    BEGIN_WIN32();

    int bytesSent = sendto(iUnblockSocket,msg,sizeof(msg),0,

        iAddr.iSockAddr, sizeof(struct sockaddr_in));

    END_WIN32();

    if (bytesSent == SOCKET_ERROR)

    {

        TRACE1("failed to unblock select, err %d", WSAGetLastError());

        return EFalse;

    }

    return ETrue;

}

TInt CWinsockSelectThread::Submit(MSelectRequest* aRequest)

{

    TInt err = KErrNone;

    iCriticalSection.Wait();

    TInt index = iRequests.FindInAddressOrder(aRequest);

    if (index < 0) err = iRequests.InsertInAddressOrder(aRequest);

    if (err == KErrNone) Wakeup();

    iCriticalSection.Signal();

    return err;

}

TBool CWinsockSelectThread::Cancel(MSelectRequest* aRequest)

{

    TBool found = EFalse;

    iCriticalSection.Wait();

    TInt index = iRequests.FindInAddressOrder(aRequest);

    if (index >= 0)

    {

        iRequests.Remove(index);

        Wakeup();

        found = ETrue;

    }

    iCriticalSection.Signal();

    return found;

}

TInt CWinsockSelectThread::Run(TAny *aPtr)

{

    int err;

    CWinsockSelectThread* thread = (CWinsockSelectThread*)aPtr;

    CTrapCleanup* cleanup = CTrapCleanup::New();

    if (cleanup) {

        TRAP(err, thread->RunL());

        delete cleanup;

    } else {

        err = KErrNoMemory;

    }

    return err;

}

void CWinsockSelectThread::RunL()

{

    TRACE("started");

    RPointerArray<MSelectRequest> completedRequests;

    struct timeval zeroTimeout;

    Mem::FillZ(&zeroTimeout, sizeof(zeroTimeout));

    // Open handle to our protocol DLL to prevent it from being unloaded

    // while this thread is running

    RLibrary self;

    TBuf<12> libName; 

    libName.Copy(KWinsockProtocol);

    libName.Append(_L(".prt"));

    VERIFY_SUCCESS(self.Load(libName));

    for (;;)

    {

        TInt i,n,nfd;

        TUint maxSock;

        fd_set read_fd_set;

        fd_set write_fd_set;

        fd_set except_fd_set;

        fd_set * readfs = NULL;

        fd_set * writefs = NULL;

        fd_set * errfs = NULL;

#pragma warning(push)            // FD_SET macro in winsock.h produces warning

#pragma warning(disable : 4127)  // C4127: conditional expression is constant

        // Always listen for notification socket

        readfs = &read_fd_set;

        FD_ZERO(readfs);

        FD_SET(iUnblockSocket,readfs);

        maxSock = iUnblockSocket;

        // Construct the fdsets

        iCriticalSection.Wait();

        n = iRequests.Count();

        for (i=0; i<n; i++)

        {

            MSelectRequest* req = iRequests[i];

            TUint sock = req->Socket();

            TInt requestMask = req->SelectMask();

            if (maxSock < sock) maxSock = sock;

            if (requestMask & ESelectRead)

            {

                FD_SET(sock,readfs);

            }

            if (requestMask & ESelectWrite)

            {

                if (!writefs)

                {

                    writefs = &write_fd_set;

                    FD_ZERO(writefs);

                }

                FD_SET(sock,writefs);

            }

            if (requestMask & ESelectError)

            {

                if (!errfs)

                {

                    errfs = &except_fd_set;

                    FD_ZERO(errfs);

                }

                FD_SET(sock,errfs);

            }

        }

#pragma warning(pop) 

        iCriticalSection.Signal();

        BEGIN_WIN32();

        nfd = select(maxSock+1, readfs, writefs, errfs, iTimeout);

        END_WIN32();

        if (nfd == SOCKET_ERROR)

        {

            TRACE1("select err %d",WSAGetLastError());

            break;

        }

        TBool dataInNotificationSocket = EFalse;

        if (FD_ISSET(iUnblockSocket, readfs))

        {

            // Don't count the notification socket

            nfd--;

            // Read one message from the notification socket

            char msg[1];

            DEBUG_ONLY(int nbytes = )recv(iUnblockSocket,msg,sizeof(msg),0);

            ASSERT(nbytes != SOCKET_ERROR);

            dataInNotificationSocket = ETrue;

        }

        if (nfd == 0)

        {

            // Timeout or request to rebuild fdsets

            continue;

        }

        iCriticalSection.Wait();

        // Read all remaining messages from the notification socket

        // The fact that we are in a critical section guarantees that

        // we won't get stuck here forever

        if (dataInNotificationSocket)

        {

            char msg[1];

            fd_set tmp;

            FD_ZERO(&tmp);

#pragma warning(push)            // Ignore warning generated by FD_SET macro

#pragma warning(disable : 4127)  // C4127: conditional expression is constant

            FD_SET(iUnblockSocket,&tmp);

            BEGIN_WIN32();

            while (select(iUnblockSocket+1,&tmp,NULL,NULL,&zeroTimeout) == 1)

            {

                if (recv(iUnblockSocket, msg, sizeof(msg), 0) == SOCKET_ERROR)

                {

                    TRACE1("internal recv socket err %d",WSAGetLastError());

                    break;

                }

                FD_ZERO(&tmp);

                FD_SET(iUnblockSocket,&tmp);

            }

            END_WIN32();

#pragma warning(pop) 

        }

        // Move completed requests to completedRequests queue

        n = iRequests.Count();

        for (i=n-1; i>=0 && nfd > 0; i--)

        {

            MSelectRequest* req = iRequests[i];

            TUint sock = req->Socket();

            TInt requestMask = req->SelectMask();

            TInt selectMask = 0;

            if (requestMask & ESelectRead && FD_ISSET(sock, readfs))

            {

                selectMask |= ESelectRead;

            }

            if (requestMask & ESelectWrite && FD_ISSET(sock, writefs))

            {

                selectMask |= ESelectRead;

            }

            if (requestMask & ESelectError && FD_ISSET(sock, errfs))

            {

                selectMask |= ESelectError;

            }

            if (selectMask)

            {

                nfd--;

                if (completedRequests.Append(req) == KErrNone)

                {

                    iRequests.Remove(i);

                }

            }

        }

        iCriticalSection.Signal();

        // Fire completion notifications outside of the critical section

        n = completedRequests.Count();

        for (i=n-1; i>=0; i--)

        {

            MSelectRequest* req = completedRequests[i];

            TUint sock = req->Socket();

            TInt requestMask = req->SelectMask();

            TInt selectMask = 0;

            if (requestMask & ESelectRead && FD_ISSET(sock, readfs))

            {

                selectMask |= ESelectRead;

            }

            if (requestMask & ESelectWrite && FD_ISSET(sock, writefs))

            {

                selectMask |= ESelectRead;

            }

            if (requestMask & ESelectError && FD_ISSET(sock, errfs))

            {

                selectMask |= ESelectError;

            }

            ASSERT(selectMask);

            req->SelectComplete(selectMask);

            completedRequests.Remove(i);

        }

    }

    completedRequests.Reset();

}