include/socketengine_iocp.h

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *            the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */\r
  13 \r
  14 #ifndef __SOCKETENGINE_IOCP__\r
  15 #define __SOCKETENGINE_IOCP__\r
  16 \r
  17 #define READ_BUFFER_SIZE 500\r
  18 #define USING_IOCP 1\r
  19 \r
  20 #include "inspircd_config.h"\r
  21 #include "inspircd_win32wrapper.h"\r
  22 #include "globals.h"
  23 #include "inspircd.h"
  24 #include "socketengine.h"\r
  25 \r
  26 enum SocketIOEvent\r
  27 {\r
  28         SOCKET_IO_EVENT_READ_READY                      = 0,\r
  29         SOCKET_IO_EVENT_WRITE_READY                     = 1,\r
  30         SOCKET_IO_EVENT_ACCEPT                          = 2,\r
  31         SOCKET_IO_EVENT_ERROR                           = 3,\r
  32         NUM_SOCKET_IO_EVENTS                            = 4,\r
  33 };\r
  34 \r
  35 class Overlapped\r
  36 {\r
  37 public:\r
  38         OVERLAPPED m_overlap;\r
  39         SocketIOEvent m_event;\r
  40         int m_params;\r
  41         Overlapped(SocketIOEvent ev, int params) : m_event(ev), m_params(params)\r
  42         {\r
  43                 memset(&m_overlap, 0, sizeof(OVERLAPPED));\r
  44         }\r
  45 };\r
  46 \r
  47 struct accept_overlap\r
  48 {\r
  49         int socket;\r
  50         char buf[1024];\r
  51 };\r
  52 \r
  53 class IOCPEngine : public SocketEngine\r
  54 {\r
  55         /** Creates a "fake" file descriptor for use with an IOCP socket.\r
  56          * @return -1 if there are no free slots, and an integer if it finds one.\r
  57          */\r
  58         __inline int GenerateFd()\r
  59         {\r
  60                 register int i = 0;\r
  61                 for(; i < MAX_DESCRIPTORS; ++i)\r
  62                         if(ref[i] == 0)\r
  63                                 return i;\r
  64                 return -1;\r
  65         }\r
  66         \r
  67         /** Global I/O completion port that sockets attach to.\r
  68          */\r
  69         HANDLE m_completionPort;\r
  70 \r
  71         /** This is kinda shitty... :/ for getting an address from a real fd. \r
  72          */\r
  73         map<int, EventHandler*> m_binding;\r
  74 \r
  75 public:\r
  76         /** Creates an IOCP Socket Engine\r
  77          * @param Instance The creator of this object\r
  78          */\r
  79         IOCPEngine(InspIRCd * Instance);\r
  80 \r
  81         /** Deletes an IOCP socket engine and all the attached sockets\r
  82          */\r
  83         ~IOCPEngine();\r
  84 \r
  85         /** Adds an event handler to the completion port, and sets up initial events.\r
  86          * @param eh EventHandler to add\r
  87          * @return True if success, false if no room\r
  88          */\r
  89         bool AddFd(EventHandler* eh);
  90
  91         /** Gets the maximum number of file descriptors that this engine can handle.
  92          * @return The number of file descriptors
  93          */
  94         __inline int GetMaxFds() { return MAX_DESCRIPTORS; }
  95
  96         /** Gets the number of free/remaining file descriptors under this engine.
  97          * @return Remaining count
  98          */
  99         __inline int GetRemainingFds()
 100         {
 101                 register int count = 0;
 102                 register int i = 0;
 103                 for(; i < MAX_DESCRIPTORS; ++i)
 104                         if(ref[i] == 0)
 105                                 ++count;
 106                 return count;
 107         }
 108
 109         /** Removes a file descriptor from the set, preventing it from receiving any more events
 110          * @return True if remove was successful, false otherwise
 111          */
 112         bool DelFd(EventHandler* eh, bool force = false);
 113
 114         /** Called every loop to handle input/output events for all sockets under this engine
 115          * @return The number of "changed" sockets.
 116          */
 117         int DispatchEvents();
 118
 119         /** Gets the name of this socket engine as a string.
 120          * @return string of socket engine name
 121          */
 122         std::string GetName();
 123
 124         /** Queues a Write event on the specified event handler.
 125          * @param eh EventHandler that needs data sent on
 126          */
 127         void WantWrite(EventHandler* eh);\r
 128 \r
 129         /** Posts a completion event on the specified socket.\r
 130          * @param eh EventHandler for message\r
 131          * @param type Event Type\r
 132          * @param param Event Parameter\r
 133          * @return True if added, false if not\r
 134          */\r
 135         bool PostCompletionEvent(EventHandler * eh, SocketIOEvent type, int param);\r
 136 \r
 137         /** Posts a read event on the specified socket\r
 138          * @param eh EventHandler (socket)\r
 139          */\r
 140         void PostReadEvent(EventHandler * eh);\r
 141 \r
 142         /** Posts an accept event on the specified socket\r
 143          * @param eh EventHandler (socket)\r
 144          */\r
 145         void PostAcceptEvent(EventHandler * eh);\r
 146 \r
 147         /** Returns the EventHandler attached to a specific fd.
 148          * If the fd isnt in the socketengine, returns NULL.
 149          * @param fd The event handler to look for
 150          * @return A pointer to the event handler, or NULL
 151          */
 152         EventHandler* GetRef(int fd);\r
 153 \r
 154         /** Returns true if a file descriptor exists in
 155          * the socket engine's list.
 156          * @param fd The event handler to look for
 157          * @return True if this fd has an event handler
 158          */
 159         bool HasFd(int fd);\r
 160 \r
 161         /** Returns the EventHandler attached to a specific fd.
 162          * If the fd isnt in the socketengine, returns NULL.
 163          * @param fd The event handler to look for
 164          * @return A pointer to the event handler, or NULL
 165          */
 166         EventHandler* GetIntRef(int fd);\r
 167 };\r
 168 \r
 169 //typedef void(*OpHandler)(EventHandler)\r
 170 /** Event Handler Array\r
 171  */\r
 172 \r
 173 /** Creates a SocketEngine
 174  */
 175 class SocketEngineFactory
 176 {
 177 public:
 178         /** Create a new instance of SocketEngine based on IOCPEngine
 179          */
 180         SocketEngine* Create(InspIRCd* Instance) { return new IOCPEngine(Instance); }
 181 };\r
 182 \r
 183 #endif\r