X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fsocketengine.h;h=ddc48f94d159a359ae8d8f27bfc5534a515aa314;hb=7770cd985405c7630e9149fc08c314ec824a9c75;hp=6503ea2936b4bf5a4467b86969f19683040e35f5;hpb=689996cb8856af43a033eb5ca1cb9df7475c0854;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/socketengine.h b/include/socketengine.h index 6503ea293..ddc48f94d 100644 --- a/include/socketengine.h +++ b/include/socketengine.h @@ -29,22 +29,13 @@ #include "socket.h" #include "base.h" -/** 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, - /** Write event */ - EVENT_WRITE = 1, - /** Error event */ - EVENT_ERROR = 2 -}; +#ifndef _WIN32 +#include +#endif + +#ifndef IOV_MAX +#define IOV_MAX 1024 +#endif /** * Event mask for SocketEngine events @@ -165,6 +156,9 @@ class CoreExport EventHandler : public classbase private: /** Private state maintained by socket engine */ int event_mask; + + void SetEventMask(int mask) { event_mask = mask; } + protected: /** File descriptor. * All events which can be handled must have a file descriptor. This @@ -196,16 +190,20 @@ class CoreExport EventHandler : public classbase */ virtual ~EventHandler() {} - /** 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. - * @param et either one of EVENT_READ for read events, - * EVENT_WRITE for write events and EVENT_ERROR for - * error events. - * @param errornum The error code which goes with an EVENT_ERROR. + /** Called by the socket engine in case of a read event */ - virtual void HandleEvent(EventType et, int errornum = 0) = 0; + virtual void OnEventHandlerRead() = 0; + + /** Called by the socket engine in case of a write event. + * The default implementation does nothing. + */ + virtual void OnEventHandlerWrite(); + + /** Called by the socket engine in case of an error event. + * The default implementation does nothing. + * @param errornum Error code + */ + virtual void OnEventHandlerError(int errornum); friend class SocketEngine; }; @@ -271,39 +269,44 @@ class CoreExport SocketEngine private: /** Reference table, contains all current handlers **/ - std::vector ref; + static std::vector ref; protected: /** Current number of descriptors in the engine */ - size_t CurrentSetSize; + static size_t CurrentSetSize; /** List of handlers that want a trial read/write */ - std::set trials; + static std::set trials; - int MAX_DESCRIPTORS; + static int MAX_DESCRIPTORS; /** Socket engine statistics: count of various events, bandwidth usage */ - Statistics stats; + static Statistics stats; - virtual void OnSetEvent(EventHandler* eh, int old_mask, int new_mask) = 0; - void SetEventMask(EventHandler* eh, int value); + static void OnSetEvent(EventHandler* eh, int old_mask, int new_mask); /** Add an event handler to the base socket engine. AddFd(EventHandler*, int) should call this. */ - bool AddFdRef(EventHandler* eh); + static bool AddFdRef(EventHandler* eh); - void DelFdRef(EventHandler* eh); + static void DelFdRef(EventHandler* eh); template - void ResizeDouble(std::vector& vect) + static void ResizeDouble(std::vector& vect) { - if (CurrentSetSize > vect.size()) + if (SocketEngine::CurrentSetSize > vect.size()) vect.resize(vect.size() * 2); } public: +#ifndef _WIN32 + typedef iovec IOVector; +#else + typedef WindowsIOVec IOVector; +#endif + /** Constructor. * The constructor transparently initializes * the socket engine which the ircd is using. @@ -311,14 +314,16 @@ public: * failure (for example, you try and enable * epoll on a 2.4 linux kernel) then this * function may bail back to the shell. + * @return void, but it is acceptable for this function to bail back to + * the shell or operating system on fatal error. */ - SocketEngine(); + static void Init(); /** Destructor. * The destructor transparently tidies up * any resources used by the socket engine. */ - virtual ~SocketEngine(); + static void Deinit(); /** 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 @@ -327,7 +332,7 @@ public: * @param eh An event handling object to add * @param event_mask The initial event mask for the object */ - virtual bool AddFd(EventHandler* eh, int event_mask) = 0; + static bool AddFd(EventHandler* eh, int event_mask); /** If you call this function and pass it an * event handler, that event handler will @@ -340,17 +345,19 @@ public: * @param eh The event handler to change * @param event_mask The changes to make to the wait state */ - void ChangeEventMask(EventHandler* eh, int event_mask); + static void ChangeEventMask(EventHandler* eh, int event_mask); - /** Returns the highest file descriptor you may store in the socket engine - * @return The maximum fd value + /** Returns the number of file descriptors reported by the system this program may use + * when it was started. + * @return If positive, the number of file descriptors that the system reported that we + * may use. Otherwise (<= 0) this number could not be determined. */ - inline int GetMaxFds() const { return MAX_DESCRIPTORS; } + static int GetMaxFds() { return MAX_DESCRIPTORS; } /** Returns the number of file descriptors being queried * @return The set size */ - inline size_t GetUsedFds() const { return CurrentSetSize; } + static size_t GetUsedFds() { return CurrentSetSize; } /** Delete an event handler from the engine. * This function call deletes an EventHandler @@ -360,21 +367,21 @@ public: * required you must do this yourself. * @param eh The event handler object to remove */ - virtual void DelFd(EventHandler* eh) = 0; + static void DelFd(EventHandler* eh); /** 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 */ - virtual bool HasFd(int fd); + static 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 */ - virtual EventHandler* GetRef(int fd); + static EventHandler* GetRef(int fd); /** Waits for events and dispatches them to handlers. Please note that * this doesn't wait long, only a couple of milliseconds. It returns the @@ -384,17 +391,17 @@ public: * value. * @return The number of events which have occured. */ - virtual int DispatchEvents() = 0; + static int DispatchEvents(); /** Dispatch trial reads and writes. This causes the actual socket I/O * to happen when writes have been pre-buffered. */ - virtual void DispatchTrialWrites(); + static void DispatchTrialWrites(); /** Returns true if the file descriptors in the given event handler are * within sensible ranges which can be handled by the socket engine. */ - virtual bool BoundsCheckFd(EventHandler* eh); + static bool BoundsCheckFd(EventHandler* eh); /** Abstraction for BSD sockets accept(2). * This function should emulate its namesake system call exactly. @@ -405,12 +412,11 @@ public: */ static int Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen); - /** Abstraction for BSD sockets close(2). - * This function should emulate its namesake system call exactly. - * @param fd This version of the call takes an EventHandler instead of a bare file descriptor. - * @return This method should return exactly the same values as the system call it emulates. + /** Close the underlying fd of an event handler, remove it from the socket engine and set the fd to -1. + * @param eh The EventHandler to close. + * @return 0 on success, a negative value on error */ - static int Close(EventHandler* fd); + static int Close(EventHandler* eh); /** Abstraction for BSD sockets close(2). * This function should emulate its namesake system call exactly. @@ -427,7 +433,28 @@ public: * @param flags A flag value that controls the sending of the data. * @return This method should return exactly the same values as the system call it emulates. */ - int Send(EventHandler* fd, const void *buf, size_t len, int flags); + static int Send(EventHandler* fd, const void *buf, size_t len, int flags); + + /** Abstraction for vector write function writev(). + * This function should emulate its namesake system call exactly. + * @param fd EventHandler to send data with + * @param iov Array of IOVectors containing the buffers to send and their lengths in the platform's + * native format. + * @param count Number of elements in iov. + * @return This method should return exactly the same values as the system call it emulates. + */ + static int WriteV(EventHandler* fd, const IOVector* iov, int count); + +#ifdef _WIN32 + /** Abstraction for vector write function writev() that accepts a POSIX format iovec. + * This function should emulate its namesake system call exactly. + * @param fd EventHandler to send data with + * @param iov Array of iovecs containing the buffers to send and their lengths in POSIX format. + * @param count Number of elements in iov. + * @return This method should return exactly the same values as the system call it emulates. + */ + static int WriteV(EventHandler* fd, const iovec* iov, int count); +#endif /** Abstraction for BSD sockets recv(2). * This function should emulate its namesake system call exactly. @@ -437,7 +464,7 @@ public: * @param flags A flag value that controls the reception of the data. * @return This method should return exactly the same values as the system call it emulates. */ - int Recv(EventHandler* fd, void *buf, size_t len, int flags); + static int Recv(EventHandler* fd, void *buf, size_t len, int flags); /** Abstraction for BSD sockets recvfrom(2). * This function should emulate its namesake system call exactly. @@ -449,7 +476,7 @@ public: * @param fromlen The size of the from parameter. * @return This method should return exactly the same values as the system call it emulates. */ - int RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen); + static int RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen); /** Abstraction for BSD sockets sendto(2). * This function should emulate its namesake system call exactly. @@ -461,7 +488,7 @@ public: * @param tolen The size of the to parameter. * @return This method should return exactly the same values as the system call it emulates. */ - int SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen); + static int SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen); /** Abstraction for BSD sockets connect(2). * This function should emulate its namesake system call exactly. @@ -523,11 +550,11 @@ public: * @return void, but it is acceptable for this function to bail back to * the shell or operating system on fatal error. */ - virtual void RecoverFromFork(); + static void RecoverFromFork(); /** Get data transfer and event statistics */ - const Statistics& GetStats() const { return stats; } + static const Statistics& GetStats() { return stats; } /** Should we ignore the error in errno? * Checks EAGAIN and WSAEWOULDBLOCK @@ -555,5 +582,3 @@ inline bool SocketEngine::IgnoreError() return false; } - -SocketEngine* CreateSocketEngine();