X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fsocketengine.h;h=37b7d637350b833e46d38f13d932f253008f36d6;hb=4c751dbbe8945e5efc230a59b0ed51c2ba10cf92;hp=4e87f7494db694336422f50a68beeff3c96aa0d6;hpb=e2af2347fc035d702e45f12e772223a8d578410d;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/socketengine.h b/include/socketengine.h index 4e87f7494..37b7d6373 100644 --- a/include/socketengine.h +++ b/include/socketengine.h @@ -1,23 +1,33 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2009 InspIRCd Development Team - * See: http://wiki.inspircd.org/Credits + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2007-2008 Robin Burchell + * Copyright (C) 2005-2007 Craig Edwards + * Copyright (C) 2007 Dennis Friis * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. * - * --------------------------------------------------- + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ -#ifndef __SOCKETENGINE__ -#define __SOCKETENGINE__ + +#ifndef SOCKETENGINE_H +#define SOCKETENGINE_H #include #include #include #include "inspircd_config.h" +#include "socket.h" #include "base.h" /** Types of event an EventHandler may receive. @@ -37,8 +47,101 @@ enum EventType EVENT_ERROR = 2 }; -class InspIRCd; -class Module; +/** + * Event mask for SocketEngine events + */ +enum EventMask +{ + /** Do not test this socket for readability + */ + FD_WANT_NO_READ = 0x1, + /** Give a read event at all times when reads will not block. + */ + FD_WANT_POLL_READ = 0x2, + /** Give a read event when there is new data to read. + * + * An event MUST be sent if there is new data to be read, and the most + * recent read/recv() on this FD returned EAGAIN. An event MAY be sent + * at any time there is data to be read on the socket. + */ + FD_WANT_FAST_READ = 0x4, + /** Give an optional read event when reads begin to unblock + * + * This state is useful if you want to leave data in the OS receive + * queue but not get continuous event notifications about it, because + * it may not require a system call to transition from FD_WANT_FAST_READ + */ + FD_WANT_EDGE_READ = 0x8, + + /** Mask for all read events */ + FD_WANT_READ_MASK = 0x0F, + + /** Do not test this socket for writeability + */ + FD_WANT_NO_WRITE = 0x10, + /** Give a write event at all times when writes will not block. + * + * You probably shouldn't use this state; if it's likely that the write + * will not block, try it first, then use FD_WANT_FAST_WRITE if it + * fails. If it's likely to block (or you are using polling-style reads) + * then use FD_WANT_SINGLE_WRITE. + */ + FD_WANT_POLL_WRITE = 0x20, + /** Give a write event when writes don't block any more + * + * An event MUST be sent if writes will not block, and the most recent + * write/send() on this FD returned EAGAIN, or connect() returned + * EINPROGRESS. An event MAY be sent at any time that writes will not + * block. + * + * Before calling HandleEvent, a socket engine MAY change the state of + * the FD back to FD_WANT_EDGE_WRITE if it is simpler (for example, if a + * one-shot notification was registered). If further writes are needed, + * it is the responsibility of the event handler to change the state to + * one that will generate the required notifications + */ + FD_WANT_FAST_WRITE = 0x40, + /** Give an optional write event on edge-triggered write unblock. + * + * This state is useful to avoid system calls when moving to/from + * FD_WANT_FAST_WRITE when writing data to a mostly-unblocked socket. + */ + FD_WANT_EDGE_WRITE = 0x80, + /** Request a one-shot poll-style write notification. The socket will + * return to the FD_WANT_NO_WRITE state before HandleEvent is called. + */ + FD_WANT_SINGLE_WRITE = 0x100, + + /** Mask for all write events */ + FD_WANT_WRITE_MASK = 0x1F0, + + /** Add a trial read. During the next DispatchEvents invocation, this + * will call HandleEvent with EVENT_READ unless reads are known to be + * blocking. + */ + FD_ADD_TRIAL_READ = 0x1000, + /** Assert that reads are known to block. This cancels FD_ADD_TRIAL_READ. + * Reset by SE before running EVENT_READ + */ + FD_READ_WILL_BLOCK = 0x2000, + + /** Add a trial write. During the next DispatchEvents invocation, this + * will call HandleEvent with EVENT_WRITE unless writes are known to be + * blocking. + * + * This could be used to group several writes together into a single + * send() syscall, or to ensure that writes are blocking when attempting + * to use FD_WANT_FAST_WRITE. + */ + FD_ADD_TRIAL_WRITE = 0x4000, + /** Assert that writes are known to block. This cancels FD_ADD_TRIAL_WRITE. + * Reset by SE before running EVENT_WRITE + */ + FD_WRITE_WILL_BLOCK = 0x8000, + + /** Mask for trial read/trial write */ + FD_TRIAL_NOTE_MASK = 0x5000 +}; /** This class is a basic I/O handler class. * Any object which wishes to receive basic I/O events @@ -58,15 +161,17 @@ class Module; * must have a file descriptor. What this file descriptor * is actually attached to is completely up to you. */ -class CoreExport EventHandler : public Extensible +class CoreExport EventHandler : public classbase { + private: + /** Private state maintained by socket engine */ + int event_mask; 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. + * 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. Do not change this while the object is + * registered with the SocketEngine */ int fd; public: @@ -75,10 +180,11 @@ class CoreExport EventHandler : public Extensible */ inline int GetFd() const { return fd; } + inline int GetEventMask() const { return event_mask; } + /** 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 + * @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); @@ -96,9 +202,13 @@ class CoreExport EventHandler : public Extensible * class, and it will be called whenever read or write * events are received. * @param et either one of EVENT_READ for read events, - * and EVENT_WRITE for write events. + * EVENT_WRITE for write events and EVENT_ERROR for + * error events. + * @param errornum The error code which goes with an EVENT_ERROR. */ virtual void HandleEvent(EventType et, int errornum = 0) = 0; + + friend class SocketEngine; }; /** Provides basic file-descriptor-based I/O support. @@ -121,16 +231,16 @@ class CoreExport EventHandler : public Extensible */ class CoreExport SocketEngine { -protected: - /** Handle to socket engine, where needed. - */ - int EngineHandle; + protected: /** Current number of descriptors in the engine */ int CurrentSetSize; /** Reference table, contains all current handlers */ EventHandler** ref; + /** List of handlers that want a trial read/write + */ + std::set trials; int MAX_DESCRIPTORS; @@ -139,12 +249,15 @@ protected: time_t lastempty; void UpdateStats(size_t len_in, size_t len_out); + + virtual void OnSetEvent(EventHandler* eh, int old_mask, int new_mask) = 0; + void SetEventMask(EventHandler* eh, int value); public: - double TotalEvents; - double ReadEvents; - double WriteEvents; - double ErrorEvents; + unsigned long TotalEvents; + unsigned long ReadEvents; + unsigned long WriteEvents; + unsigned long ErrorEvents; /** Constructor. * The constructor transparently initializes @@ -167,9 +280,9 @@ public: * must provide an object derived from EventHandler which implements * HandleEvent(). * @param eh An event handling object to add - * @param writeFirst Wait for a write event instead of a read + * @param event_mask The initial event mask for the object */ - virtual bool AddFd(EventHandler* eh, bool writeFirst = false) = 0; + virtual bool AddFd(EventHandler* eh, int event_mask) = 0; /** If you call this function and pass it an * event handler, that event handler will @@ -179,22 +292,20 @@ public: * 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. + * @param eh The event handler to change + * @param event_mask The changes to make to the wait state */ - virtual void WantWrite(EventHandler* eh) = 0; + void ChangeEventMask(EventHandler* eh, int event_mask); - /** Returns the maximum number of file descriptors - * you may store in the socket engine at any one time. + /** Returns the highest file descriptor you may store in the socket engine * @return The maximum fd value */ - virtual int GetMaxFds(); + inline int GetMaxFds() const { return MAX_DESCRIPTORS; } - /** Returns the number of file descriptor slots - * which are available for storing fds. - * @return The number of remaining fd's + /** Returns the number of file descriptors being queried + * @return The set size */ - virtual int GetRemainingFds(); + inline int GetUsedFds() const { return CurrentSetSize; } /** Delete an event handler from the engine. * This function call deletes an EventHandler @@ -202,18 +313,9 @@ 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, bool force = false) = 0; + virtual void DelFd(EventHandler* eh) = 0; /** Returns true if a file descriptor exists in * the socket engine's list. @@ -229,129 +331,149 @@ public: */ 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 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. + /** Waits for events and dispatches them to handlers. Please note that + * this doesn't wait long, only a couple of milliseconds. It returns the + * number of events which occurred during this call. This method will + * dispatch events to their handlers by calling their + * EventHandler::HandleEvent() methods with the necessary EventType + * value. * @return The number of events which have occured. */ - virtual int DispatchEvents(); + virtual int DispatchEvents() = 0; - /** Returns the socket engines name. - * This returns the name of the engine for use - * in /VERSION responses. + /** Dispatch trial reads and writes. This causes the actual socket I/O + * to happen when writes have been pre-buffered. + */ + virtual void DispatchTrialWrites(); + + /** Returns the socket engines name. This returns the name of the + * engine for use in /VERSION responses. * @return The socket engine name */ virtual std::string GetName() = 0; - /** Returns true if the file descriptors in the - * given event handler are within sensible ranges - * which can be handled by the socket engine. + /** 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); /** Abstraction for BSD sockets accept(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. + * @param addr The client IP address and port + * @param addrlen The size of the sockaddr parameter. * @return This method should return exactly the same values as the system call it emulates. */ - virtual int Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen); + 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. */ - virtual int Close(EventHandler* fd); + int Close(EventHandler* fd); /** Abstraction for BSD sockets close(2). * This function should emulate its namesake system call exactly. * This function should emulate its namesake system call exactly. * @return This method should return exactly the same values as the system call it emulates. */ - virtual int Close(int fd); + int Close(int fd); /** Abstraction for BSD sockets send(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. + * @param buf The buffer in which the data that is sent is stored. + * @param len The size of the buffer. + * @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. */ - virtual int Send(EventHandler* fd, const void *buf, size_t len, int flags); + int Send(EventHandler* fd, const void *buf, size_t len, int flags); /** Abstraction for BSD sockets recv(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. + * @param buf The buffer in which the data that is read is stored. + * @param len The size of the buffer. + * @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. */ - virtual int Recv(EventHandler* fd, void *buf, size_t len, int flags); + 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. * @param fd This version of the call takes an EventHandler instead of a bare file descriptor. + * @param buf The buffer in which the data that is read is stored. + * @param len The size of the buffer. + * @param flags A flag value that controls the reception of the data. + * @param from The remote IP address and port. + * @param fromlen The size of the from parameter. * @return This method should return exactly the same values as the system call it emulates. */ - virtual int RecvFrom(EventHandler* fd, void *buf, size_t len, int flags, sockaddr *from, socklen_t *fromlen); + 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. * @param fd This version of the call takes an EventHandler instead of a bare file descriptor. + * @param buf The buffer in which the data that is sent is stored. + * @param len The size of the buffer. + * @param flags A flag value that controls the sending of the data. + * @param to The remote IP address and port. + * @param tolen The size of the to parameter. * @return This method should return exactly the same values as the system call it emulates. */ - virtual int SendTo(EventHandler* fd, const void *buf, size_t len, int flags, const sockaddr *to, socklen_t tolen); + 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. * @param fd This version of the call takes an EventHandler instead of a bare file descriptor. + * @param serv_addr The server IP address and port. + * @param addrlen The size of the sockaddr parameter. * @return This method should return exactly the same values as the system call it emulates. */ - virtual int Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen); + int Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen); /** Make a file descriptor blocking. * @param fd a file descriptor to set to blocking mode * @return 0 on success, -1 on failure, errno is set appropriately. */ - virtual int Blocking(int fd); + int Blocking(int fd); /** Make a file descriptor nonblocking. * @param fd A file descriptor to set to nonblocking mode * @return 0 on success, -1 on failure, errno is set appropriately. */ - virtual int NonBlocking(int fd); + int NonBlocking(int fd); /** Abstraction for BSD sockets shutdown(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. + * @param how What part of the socket to shut down * @return This method should return exactly the same values as the system call it emulates. */ - virtual int Shutdown(EventHandler* fd, int how); + int Shutdown(EventHandler* fd, int how); /** Abstraction for BSD sockets shutdown(2). * This function should emulate its namesake system call exactly. * @return This method should return exactly the same values as the system call it emulates. */ - virtual int Shutdown(int fd, int how); + int Shutdown(int fd, int how); /** Abstraction for BSD sockets bind(2). * This function should emulate its namesake system call exactly. * @return This method should return exactly the same values as the system call it emulates. */ - virtual int Bind(int fd, const sockaddr *my_addr, socklen_t addrlen); + int Bind(int fd, const irc::sockets::sockaddrs& addr); /** Abstraction for BSD sockets listen(2). * This function should emulate its namesake system call exactly. * @return This method should return exactly the same values as the system call it emulates. */ - virtual int Listen(int sockfd, int backlog); + int Listen(int sockfd, int backlog); - /** Abstraction for BSD sockets getsockname(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. + /** Set SO_REUSEADDR and SO_LINGER on this file descriptor */ - virtual int GetSockName(EventHandler* fd, sockaddr *name, socklen_t* namelen); + void SetReuse(int sockfd); /** This function is called immediately after fork(). * Some socket engines (notably kqueue) cannot have their @@ -367,7 +489,35 @@ public: /** Get data transfer statistics, kilobits per second in and out and total. */ void GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total); + + /** Should we ignore the error in errno? + * Checks EAGAIN and WSAEWOULDBLOCK + */ + static bool IgnoreError(); + + /** Return the last socket related error. strrerror(errno) on *nix + */ + static std::string LastError(); + + /** Returns the error for the given error num, strerror(errnum) on *nix + */ + static std::string GetError(int errnum); }; +inline bool SocketEngine::IgnoreError() +{ + if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) + return true; + +#ifdef _WIN32 + if (WSAGetLastError() == WSAEWOULDBLOCK) + return true; +#endif + + return false; +} + +SocketEngine* CreateSocketEngine(); + #endif