socketengine.h

/*
 * InspIRCd -- Internet Relay Chat Daemon
 *
 *   Copyright (C) 2009 Daniel De Graaf <[email protected]>
 *   Copyright (C) 2007-2008 Robin Burchell <[email protected]>
 *   Copyright (C) 2005-2007 Craig Edwards <[email protected]>
 *   Copyright (C) 2007 Dennis Friis <[email protected]>
 *
 * This file is part of InspIRCd.  InspIRCd is free software: you can
 * redistribute it and/or modify it under the terms of the GNU General Public
 * License as published by the Free Software Foundation, version 2.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 
#ifndef SOCKETENGINE_H
#define SOCKETENGINE_H
 
#include <vector>
#include <string>
#include <map>
#include "inspircd_config.h"
#include "socket.h"
#include "base.h"
 
enum EventType
{
        EVENT_READ      =       0,
        EVENT_WRITE     =       1,
        EVENT_ERROR     =       2
};
 
enum EventMask
{
        FD_WANT_NO_READ = 0x1,
        FD_WANT_POLL_READ = 0x2,
        FD_WANT_FAST_READ = 0x4,
        FD_WANT_EDGE_READ = 0x8,
 
        FD_WANT_READ_MASK = 0x0F,
 
        FD_WANT_NO_WRITE = 0x10,
        FD_WANT_POLL_WRITE = 0x20,
        FD_WANT_FAST_WRITE = 0x40,
        FD_WANT_EDGE_WRITE = 0x80,
        FD_WANT_SINGLE_WRITE = 0x100,
 
        FD_WANT_WRITE_MASK = 0x1F0,
 
        FD_ADD_TRIAL_READ  = 0x1000,
        FD_READ_WILL_BLOCK = 0x2000,
 
        FD_ADD_TRIAL_WRITE = 0x4000,
        FD_WRITE_WILL_BLOCK = 0x8000, 
 
        FD_TRIAL_NOTE_MASK = 0x5000
};
 
class CoreExport EventHandler : public classbase
{
 private:
        int event_mask;
 protected:
        int fd;
 public:
        inline int GetFd() const { return fd; }
 
        inline int GetEventMask() const { return event_mask; }
 
        void SetFd(int FD);
 
        EventHandler();
 
        virtual ~EventHandler() {}
 
        virtual void HandleEvent(EventType et, int errornum = 0) = 0;
 
        friend class SocketEngine;
};
 
class CoreExport SocketEngine
{
 protected:
        int CurrentSetSize;
        EventHandler** ref;
        std::set<int> trials;
 
        int MAX_DESCRIPTORS;
 
        size_t indata;
        size_t outdata;
        time_t lastempty;
 
        void UpdateStats(size_t len_in, size_t len_out);
 
        virtual void OnSetEvent(EventHandler* eh, int old_mask, int new_mask) = 0;
        void SetEventMask(EventHandler* eh, int value);
public:
 
        unsigned long TotalEvents;
        unsigned long ReadEvents;
        unsigned long WriteEvents;
        unsigned long ErrorEvents;
 
        SocketEngine();
 
        virtual ~SocketEngine();
 
        virtual bool AddFd(EventHandler* eh, int event_mask) = 0;
 
        void ChangeEventMask(EventHandler* eh, int event_mask);
 
        inline int GetMaxFds() const { return MAX_DESCRIPTORS; }
 
        inline int GetUsedFds() const { return CurrentSetSize; }
 
        virtual void DelFd(EventHandler* eh) = 0;
 
        virtual bool HasFd(int fd);
 
        virtual EventHandler* GetRef(int fd);
 
        virtual int DispatchEvents() = 0;
 
        virtual void DispatchTrialWrites();
 
        virtual std::string GetName() = 0;
 
        virtual bool BoundsCheckFd(EventHandler* eh);
 
        int Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen);
 
        int Close(EventHandler* fd);
 
        int Close(int fd);
 
        int Send(EventHandler* fd, const void *buf, size_t len, int flags);
 
        int Recv(EventHandler* fd, void *buf, size_t len, int flags);
 
        int RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen);
 
        int SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen);
 
        int Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen);
 
        int Blocking(int fd);
 
        int NonBlocking(int fd);
 
        int Shutdown(EventHandler* fd, int how);
 
        int Shutdown(int fd, int how);
 
        int Bind(int fd, const irc::sockets::sockaddrs& addr);
 
        int Listen(int sockfd, int backlog);
 
        void SetReuse(int sockfd);
 
        virtual void RecoverFromFork();
 
        void GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total);
 
        static bool IgnoreError();
 
        static std::string LastError();
 
        static std::string GetError(int errnum);
};
 
inline bool SocketEngine::IgnoreError()
{
        if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
                return true;
 
#ifdef _WIN32
        if (WSAGetLastError() == WSAEWOULDBLOCK)
                return true;
#endif
 
        return false;
}
 
SocketEngine* CreateSocketEngine();
 
#endif