---

socket_select.cpp

Go to the documentation of this file.

#ifdef WIN32
#pragma warning (disable:4786)
#endif

#include "socket_select.h"
#include "socket_generic.h"

#include "API/Core/System/mutex.h"

#include <vector>
#include <algorithm>

// CL_SocketSelect construction:

CL_SocketSelect::CL_SocketSelect()
: listen_thread(NULL), mutex(NULL), stop_thread(false)
{
#ifdef WIN32
        signal_event = WSACreateEvent();
#endif

        mutex = CL_Mutex::create();
        listen_thread = CL_Thread::create(this);

        listen_thread->start();
}

CL_SocketSelect::~CL_SocketSelect()
{
        stop_thread = true;
        signal_listen_thread();
        listen_thread->wait();
        delete listen_thread;
        delete mutex;

#ifdef WIN32
        WSACloseEvent(signal_event);
#endif
}

// CL_SocketSelect attributes:

// CL_SocketSelect operations:

void CL_SocketSelect::listen_read(CL_EventTrigger_Socket *socket)
{
        {
                CL_MutexSection mutex_section(mutex);
                if (std::find(read_sockets.begin(), read_sockets.end(), socket) == read_sockets.end())
                        read_sockets.push_back(socket);
        }
        
        signal_listen_thread();
}

void CL_SocketSelect::listen_write(CL_EventTrigger_Socket *socket)
{
        {
                CL_MutexSection mutex_section(mutex);
                if (std::find(write_sockets.begin(), write_sockets.end(), socket) == write_sockets.end())
                        write_sockets.push_back(socket);
        }
        
        signal_listen_thread();
}

void CL_SocketSelect::listen_exception(CL_EventTrigger_Socket *socket)
{
        {
                CL_MutexSection mutex_section(mutex);
                if (std::find(exception_sockets.begin(), exception_sockets.end(), socket) == exception_sockets.end())
                        exception_sockets.push_back(socket);
        }
        
        signal_listen_thread();
}

void CL_SocketSelect::remove_read(CL_EventTrigger_Socket *socket)
{
        {
                CL_MutexSection mutex_section(mutex);
                read_sockets.remove(socket);
        }
        
        signal_listen_thread();
}

void CL_SocketSelect::remove_write(CL_EventTrigger_Socket *socket)
{
        {
                CL_MutexSection mutex_section(mutex);
                write_sockets.remove(socket);
        }
        
        signal_listen_thread();
}

void CL_SocketSelect::remove_exception(CL_EventTrigger_Socket *socket)
{
        {
                CL_MutexSection mutex_section(mutex);
                exception_sockets.remove(socket);
        }

        signal_listen_thread();
}

// CL_SocketSelect implementation:

void CL_SocketSelect::run()
{
        while (!stop_thread)
        {
#ifdef WIN32
                std::vector<WSAEVENT> events;
                std::vector<CL_EventTrigger_Socket*> triggers;
                std::list<CL_EventTrigger_Socket*>::iterator it;

                {
                        CL_MutexSection mutex_section(mutex);

                        WSAResetEvent(signal_event);
                        events.push_back(signal_event);

                        for (it = read_sockets.begin(); it != read_sockets.end(); it++)
                        {
                                WSAEVENT event = WSACreateEvent();
                                WSAEventSelect((*it)->get_socket()->sock, event, FD_READ|FD_ACCEPT|FD_CLOSE);
                                events.push_back(event);
                                triggers.push_back(*it);
                        }

                        for (it = write_sockets.begin(); it != write_sockets.end(); it++)
                        {
                                WSAEVENT event = WSACreateEvent();
                                WSAEventSelect((*it)->get_socket()->sock, event, FD_WRITE|FD_CONNECT);
                                events.push_back(event);
                                triggers.push_back(*it);
                        }

                        for (it = exception_sockets.begin(); it != exception_sockets.end(); it++)
                        {
                                WSAEVENT event = WSACreateEvent();
                                WSAEventSelect((*it)->get_socket()->sock, event, FD_OOB);
                                events.push_back(event);
                                triggers.push_back(*it);
                        }
                }

                int num_events = events.size();

                DWORD result = WSAWaitForMultipleEvents(
                        num_events, &events[0], FALSE, WSA_INFINITE, FALSE);

                CL_EventTrigger_Socket *trigger = triggers[result - WSA_WAIT_EVENT_0];

                // verify trigger is still valid. if it is, raise its flag.
                {
                        CL_MutexSection mutex_section(mutex);
                        if (
                                std::find(read_sockets.begin(), read_sockets.end(), trigger) != read_sockets.end() ||
                                std::find(write_sockets.begin(), write_sockets.end(), trigger) != write_sockets.end() ||
                                std::find(exception_sockets.begin(), exception_sockets.end(), trigger) != exception_sockets.end())
                        {
                                trigger->set_flag();
                        }
                }

#else

                bool read_empty, write_empty, exception_empty;
                fd_set rfds, wfds, efds;
                std::list<CL_EventTrigger_Socket*>::iterator it;
                int highest_fd = -1;

                // lock mutex and generate listen file descriptor tables.
                {
                        CL_MutexSection mutex_section(mutex);

                        read_empty = read_sockets.empty();
                        write_empty = write_sockets.empty();
                        exception_empty = exception_sockets.empty();

                        if (!read_empty)
                        {
                                FD_ZERO(&rfds);
                                for (it = read_sockets.begin(); it != read_sockets.end(); it++)
                                {
                                        int sock = (*it)->get_socket()->sock;

                                        if (sock > highest_fd) highest_fd = sock;
                                        FD_SET(sock, &rfds);
                                }
                        }

                        if (write_empty)
                        {
                                FD_ZERO(&wfds);
                                for (it = write_sockets.begin(); it != write_sockets.end(); it++)
                                {
                                        int sock = (*it)->get_socket()->sock;

                                        if (sock > highest_fd) highest_fd = sock;
                                        FD_SET(sock, &wfds);
                                }
                        }

                        if (exception_empty)
                        {
                                FD_ZERO(&efds);
                                for (it = exception_sockets.begin(); it != exception_sockets.end(); it++)
                                {
                                        int sock = (*it)->get_socket()->sock;

                                        if (sock > highest_fd) highest_fd = sock;
                                        FD_SET(sock, &efds);
                                }
                        }
                }

                int result = select(
                        highest_fd+1,
                        read_empty ? NULL : &rfds,
                        write_empty ? NULL : &wfds,
                        exception_empty ? NULL : &efds,
                        NULL);

                // lock mutex, check results and notify triggers.
                {
                        CL_MutexSection mutex_section(mutex);

                        if (result > 0)
                        {
                                for (it = read_sockets.begin(); it != read_sockets.end(); it++)
                                {
                                        int sock = (*it)->get_socket()->sock;
                                        if (FD_ISSET(sock, &rfds)) (*it)->set_flag();
                                }

                                for (it = write_sockets.begin(); it != write_sockets.end(); it++)
                                {
                                        int sock = (*it)->get_socket()->sock;
                                        if (FD_ISSET(sock, &wfds)) (*it)->set_flag();
                                }

                                for (it = exception_sockets.begin(); it != exception_sockets.end(); it++)
                                {
                                        int sock = (*it)->get_socket()->sock;
                                        if (FD_ISSET(sock, &efds)) (*it)->set_flag();
                                }
                        }
                }
#endif
        }
}

void CL_SocketSelect::signal_listen_thread()
{
        WSASetEvent(signal_event);
}

---