* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- * E-mail:
- * <brain@chatspike.net>
- * <Craig@chatspike.net>
+ * 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__
/** 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.
*/
enum EventType
{
+ /** Read event */
EVENT_READ = 0,
- EVENT_WRITE = 1
+ /** Write event */
+ EVENT_WRITE = 1,
+ /** Error event */
+ EVENT_ERROR = 2
};
class InspIRCd;
* must have a file descriptor. What this file descriptor
* is actually attached to is completely up to you.
*/
-class EventHandler : public Extensible
+class CoreExport EventHandler : public Extensible
{
protected:
/** File descriptor.
* 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();
* 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();
* 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.
+ * 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) = 0;
+ 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.
* have to be aware of which SocketEngine derived
* class they are using.
*/
-class SocketEngine : public Extensible
+class CoreExport SocketEngine : public Extensible
{
protected:
/** Owner/Creator
*/
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
* 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);
+ 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 HasFd(int fd);
+ virtual bool HasFd(int fd);
/** 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
*/
- EventHandler* GetRef(int fd);
+ virtual EventHandler* GetRef(int fd);
- /** Waits for an event.
+ /** 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 EventHandlers in the array fdlist
- * which the core will then dispatch events to
+ * 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.
- * @param fdlist A pointer to a set of EventHandler
- * classes. You should ensure that the array you pass
- * is at least MAX_DESCRIPTORS in size, to accomodate
- * for the maximum number of events which can occur.
* @return The number of events which have occured.
*/
- virtual int Wait(EventHandler** fdlist);
+ virtual int DispatchEvents();
/** Returns the socket engines name.
* This returns the name of the engine for use
};
#endif
+
projects / user / henk / code / inspircd.git / blobdiff