Needs testbuilding in windows. I will probably do this in a minute.

[user/henk/code/inspircd.git] / include / socketengine.h

diff --git a/include/socketengine.h b/include/socketengine.h
index 55f8516f9f6057ac521a9af0beac201b61eda658..1124966568387bde492e1a5eb3cf7b5070283dc9 100644 (file)
--- a/include/socketengine.h
+++ b/include/socketengine.h
@@ -29,8 +29,11 @@
  */
 enum EventType
 {
+       /** Read event */
        EVENT_READ      =       0,
+       /** Write event */
        EVENT_WRITE     =       1,
+       /** Error event */
        EVENT_ERROR     =       2
 };
 
@@ -54,7 +57,7 @@ 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.
@@ -94,7 +97,7 @@ class EventHandler : public Extensible
         * 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
@@ -111,7 +114,7 @@ class EventHandler : public Extensible
         * If this function is unimplemented, the base class
         * will return false.
         *
-         * NOTE: You cannot set both Readable() and
+        * 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
@@ -129,6 +132,25 @@ class EventHandler : public Extensible
         * 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.
@@ -149,7 +171,7 @@ class EventHandler : public Extensible
  * have to be aware of which SocketEngine derived
  * class they are using.
  */
-class SocketEngine : public Extensible
+class CoreExport SocketEngine : public Extensible
 {
 protected:
        /** Owner/Creator
@@ -224,24 +246,32 @@ public:
         * 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 events and dispatches them to handlers.
         * Please note that this doesnt wait long, only
@@ -260,6 +290,13 @@ public:
         * @return The socket engine name
         */
        virtual std::string GetName();
+
+       /** Returns true if the file descriptors in the
+        * given event handler are within sensible ranges
+        * which can be handled by the socket engine.
+        */
+       bool BoundsCheckFd(EventHandler* eh);
 };
 
 #endif
+