X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fsocketengine.h;h=ce701beff4a14ac3f510737ecc42bc19c2467987;hb=455d6fac2e047a9d544e455e0cced8fe94a9d95b;hp=caccd9b3f2d7825ec84b3c817b0511f797fe9691;hpb=277fc183721767efbce4b4cb1fc716c5f67d4752;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/socketengine.h b/include/socketengine.h index caccd9b3f..ce701beff 100644 --- a/include/socketengine.h +++ b/include/socketengine.h @@ -2,59 +2,158 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * Inspire is copyright (C) 2002-2005 ChatSpike-Dev. - * E-mail: - * - * + * InspIRCd: (C) 2002-2007 InspIRCd Development Team + * See: http://www.inspircd.org/wiki/index.php/Credits * - * Written by Craig Edwards, Craig McLure, and others. * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- -*/ + */ #ifndef __SOCKETENGINE__ #define __SOCKETENGINE__ #include #include +#include #include "inspircd_config.h" -#include "globals.h" -#include "inspircd.h" -#ifdef USE_EPOLL -#include -#define EP_DELAY 5 -#endif -#ifdef USE_KQUEUE -#include -#include -#include -#endif +#include "base.h" -/** - * Each of these values represents a socket - * type in our reference table (the reference - * table itself is only accessible to - * socketengine.cpp) +/** Types of event an EventHandler may receive. + * EVENT_READ is a readable file descriptor, + * and EVENT_WRITE is a writeable file descriptor. + * EVENT_ERROR can always occur, and indicates + * a write error or read error on the socket, + * e.g. EOF condition or broken pipe. */ -const char X_EMPTY_SLOT = 0; -const char X_LISTEN = 1; -const char X_ESTAB_CLIENT = 2; -const char X_ESTAB_MODULE = 3; -const char X_ESTAB_DNS = 4; - -/** - * To indicate that a socket is readable, we - * mask its top bit with this X_READBIT value. - * The socket engine can handle two types of - * socket, readable and writeable (error sockets - * are dealt with when read() and write() return - * negative or zero values). +enum EventType +{ + /** Read event */ + EVENT_READ = 0, + /** Write event */ + EVENT_WRITE = 1, + /** Error event */ + EVENT_ERROR = 2 +}; + +class InspIRCd; + +/** This class is a basic I/O handler class. + * Any object which wishes to receive basic I/O events + * from the socketengine must derive from this class and + * implement the HandleEvent() method. The derived class + * must then be added to SocketEngine using the method + * SocketEngine::AddFd(), after which point the derived + * class will receive events to its HandleEvent() method. + * The derived class should also implement one of Readable() + * and Writeable(). In the current implementation, only + * Readable() is used. If this returns true, the socketengine + * inserts a readable socket. If it is false, the socketengine + * inserts a writeable socket. The derived class should never + * change the value this function returns without first + * deleting the socket from the socket engine. The only + * requirement beyond this for an event handler is that it + * must have a file descriptor. What this file descriptor + * is actually attached to is completely up to you. */ -const char X_READBIT = 0x80; +class CoreExport EventHandler : public Extensible +{ + protected: + /** File descriptor. + * All events which can be handled + * must have a file descriptor. + * This allows you to add events for + * sockets, fifo's, pipes, and various + * other forms of IPC. + */ + int fd; + public: + /** Get the current file descriptor + * @return The file descriptor of this handler + */ + int GetFd(); + + /** Set a new file desciptor + * @param FD The new file descriptor. Do not + * call this method without first deleting the + * object from the SocketEngine if you have + * added it to a SocketEngine instance. + */ + void SetFd(int FD); + + /** Constructor + */ + EventHandler() {} + + /** Destructor + */ + virtual ~EventHandler() {} + + /** Override this function to indicate readability. + * @return This should return true if the function + * wishes to receive EVENT_READ events. Do not change + * what this function returns while the event handler + * is still added to a SocketEngine instance! + * If this function is unimplemented, the base class + * will return true. + * + * NOTE: You cannot set both Readable() and + * Writeable() to true. If you wish to receive + * a write event for your object, you must call + * SocketEngine::WantWrite() instead. This will + * trigger your objects next EVENT_WRITE type event. + */ + virtual bool Readable(); + + /** Override this function to indicate writeability. + * @return This should return true if the function + * wishes to receive EVENT_WRITE events. Do not change + * what this function returns while the event handler + * is still added to a SocketEngine instance! + * If this function is unimplemented, the base class + * will return false. + * + * NOTE: You cannot set both Readable() and + * Writeable() to true. If you wish to receive + * a write event for your object, you must call + * SocketEngine::WantWrite() instead. This will + * trigger your objects next EVENT_WRITE type event. + */ + virtual bool Writeable(); + + /** Process an I/O event. + * You MUST implement this function in your derived + * class, and it will be called whenever read or write + * events are received, depending on what your functions + * Readable() and Writeable() returns and wether you + * previously made a call to SocketEngine::WantWrite(). + * @param et either one of EVENT_READ for read events, + * and EVENT_WRITE for write events. + */ + virtual void HandleEvent(EventType et, int errornum = 0) = 0; + +#ifdef WINDOWS + + /** "Fake" file descriptor. This is windows-specific. + */ + int m_internalFd; + + /** Pointer to read event. We delete this so the buffer can't be used + * after the socket is deleted, and so it doesn't leak memory + */ + void* m_readEvent; + /** Pointer to a write event. + */ + void* m_writeEvent; + /** Pointer to an accept event. + */ + void* m_acceptEvent; + +#endif +}; -/** +/** Provides basic file-descriptor-based I/O support. * The actual socketengine class presents the * same interface on all operating systems, but * its private members and internal behaviour @@ -62,83 +161,136 @@ const char X_READBIT = 0x80; * from system to system and upon the config * settings chosen by the server admin. The current * version supports select, epoll and kqueue. + * The configure script will enable a socket engine + * based upon what OS is detected, and will derive + * a class from SocketEngine based upon what it finds. + * The derived classes file will also implement a + * classfactory, SocketEngineFactory, which will + * create a derived instance of SocketEngine using + * polymorphism so that the core and modules do not + * have to be aware of which SocketEngine derived + * class they are using. */ -class SocketEngine { - - std::vector fds; /* List of file descriptors being monitored */ - int EngineHandle; /* Handle to the socket engine if needed */ -#ifdef USE_SELECT - fd_set wfdset, rfdset; /* Readable and writeable sets for select() */ -#endif -#ifdef USE_KQUEUE - struct kevent ke_list[65535]; /* Up to 64k sockets for kqueue */ - struct timespec ts; /* kqueue delay value */ -#endif -#ifdef USE_EPOLL - struct epoll_event events[65535]; /* Up to 64k sockets for epoll */ -#endif - +class CoreExport SocketEngine : public Extensible +{ +protected: + /** Owner/Creator + */ + InspIRCd* ServerInstance; + /** Handle to socket engine, where needed. + */ + int EngineHandle; + /** Current number of descriptors in the engine + */ + int CurrentSetSize; + /** Reference table, contains all current handlers + */ + EventHandler* ref[MAX_DESCRIPTORS]; public: - /** Constructor + /** Constructor. * The constructor transparently initializes * the socket engine which the ircd is using. * Please note that if there is a catastrophic * failure (for example, you try and enable * epoll on a 2.4 linux kernel) then this * function may bail back to the shell. + * @param Instance The creator/owner of this object */ - SocketEngine(); + SocketEngine(InspIRCd* Instance); - /** Destructor + /** Destructor. * The destructor transparently tidies up * any resources used by the socket engine. */ - ~SocketEngine(); + virtual ~SocketEngine(); - /** Add a file descriptor to the engine + /** Add an EventHandler object to the engine. * Use AddFd to add a file descriptor to the * engine and have the socket engine monitor - * it. You must provide a type (see the consts - * in socketengine.h) and a boolean flag to - * indicate wether to watch this fd for read - * or write events (there is currently no - * need for support of both). - */ - bool AddFd(int fd, bool readable, char type); - - /** Returns the type value for this file descriptor - * This function masks off the X_READBIT value - * so that the type of the socket can be obtained. - * The core uses this to decide where to dispatch - * the event to. Please note that some engines - * such as select() have an upper limit of 1024 - * descriptors which may be active at any one time, - * where others such as kqueue have no practical - * limits at all. - */ - char GetType(int fd); - - /** Delete a file descriptor f rom the engine - * This function call deletes a file descriptor + * it. You must provide an object derived from + * EventHandler which implements HandleEvent() + * and optionally Readable() and Writeable(). + * @param eh An event handling object to add + */ + virtual bool AddFd(EventHandler* eh); + + /** If you call this function and pass it an + * event handler, that event handler will + * receive the next available write event, + * even if the socket is a readable socket only. + * Developers should avoid constantly keeping + * an eventhandler in the writeable state, + * as this will consume large amounts of + * CPU time. + * @param eh An event handler which wants to + * receive the next writeability event. + */ + virtual void WantWrite(EventHandler* eh); + + /** Returns the maximum number of file descriptors + * you may store in the socket engine at any one time. + * @return The maximum fd value + */ + virtual int GetMaxFds(); + + /** Returns the number of file descriptor slots + * which are available for storing fds. + * @return The number of remaining fd's + */ + virtual int GetRemainingFds(); + + /** Delete an event handler from the engine. + * This function call deletes an EventHandler * from the engine, returning true if it succeeded - * and false if it failed. + * and false if it failed. This does not free the + * EventHandler pointer using delete, if this is + * required you must do this yourself. + * Note on forcing deletes. DO NOT DO THIS! This is + * extremely dangerous and will most likely render the + * socketengine dead. This was added only for handling + * very rare cases where broken 3rd party libs destroys + * the OS socket beyond our control. If you can't explain + * in minute details why forcing is absolutely necessary + * then you don't need it. That was a NO! + * @param eh The event handler object to remove + * @param force *DANGEROUS* See method description! + * @return True if the event handler was removed + */ + virtual bool DelFd(EventHandler* eh, bool force = false); + + /** Returns true if a file descriptor exists in + * the socket engine's list. + * @param fd The event handler to look for + * @return True if this fd has an event handler */ - bool DelFd(int fd); + virtual bool HasFd(int fd); - /** Waits for an event. + /** Returns the EventHandler attached to a specific fd. + * If the fd isnt in the socketengine, returns NULL. + * @param fd The event handler to look for + * @return A pointer to the event handler, or NULL + */ + virtual EventHandler* GetRef(int fd); + + /** Waits for events and dispatches them to handlers. * Please note that this doesnt wait long, only - * a couple of milliseconds. It returns a list - * of active file descriptors in the vector - * fdlist which the core may then act upon. + * a couple of milliseconds. It returns the number of + * events which occured during this call. + * This method will dispatch events to their handlers + * by calling their EventHandler::HandleEvent() + * methods with the neccessary EventType value. + * @return The number of events which have occured. */ - bool Wait(std::vector &fdlist); + virtual int DispatchEvents(); - /** Returns the socket engines name + /** Returns the socket engines name. * This returns the name of the engine for use * in /VERSION responses. + * @return The socket engine name */ - std::string GetName(); + virtual std::string GetName(); }; #endif +