X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fsocketengine.h;h=26d31c168d1c9ff77d9847ddc8f20d7644240e79;hb=635cb9d65f6d7f6758ae8ed874da00c8d94b6e39;hp=b411b394a6cbc1e2f5c3af988c86d5b516e779b4;hpb=eaace5ed7cef3a02f905689a1b44a092ca99a6e1;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/socketengine.h b/include/socketengine.h index b411b394a..26d31c168 100644 --- a/include/socketengine.h +++ b/include/socketengine.h @@ -1,41 +1,43 @@ -/* +------------------------------------+ - * | 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) 2013-2016 Attila Molnar + * Copyright (C) 2013-2014 Adam + * Copyright (C) 2012-2013, 2017-2020 Sadie Powell + * Copyright (C) 2012 Robby + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2009 Uli Schlachter + * Copyright (C) 2007-2008, 2017 Robin Burchell + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2005-2008 Craig Edwards * - * 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__ -#include +#pragma once + #include -#include -#include "inspircd_config.h" +#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 @@ -84,7 +86,7 @@ enum EventMask * 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 + * Before calling OnEventHandler*(), 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 @@ -98,7 +100,7 @@ enum EventMask */ 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. + * return to the FD_WANT_NO_WRITE state before OnEventHandler*() is called. */ FD_WANT_SINGLE_WRITE = 0x100, @@ -106,28 +108,28 @@ enum EventMask 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 + * will call OnEventHandlerRead() 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 + * Reset by SE before running OnEventHandlerRead(). */ 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 + * will call OnEventHandlerWrite() 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 + * Reset by SE before running OnEventHandlerWrite(). */ - FD_WRITE_WILL_BLOCK = 0x8000, + FD_WRITE_WILL_BLOCK = 0x8000, /** Mask for trial read/trial write */ FD_TRIAL_NOTE_MASK = 0x5000 @@ -136,17 +138,14 @@ enum EventMask /** This class is a basic I/O handler class. * Any object which wishes to receive basic I/O events * from the socketengine must derive from this class and - * implement the HandleEvent() method. The derived class + * implement the OnEventHandler*() methods. The derived class * must then be added to SocketEngine using the method * SocketEngine::AddFd(), after which point the derived - * class will receive events to its HandleEvent() method. - * The derived class should also implement one of Readable() - * and Writeable(). In the current implementation, only - * Readable() is used. If this returns true, the socketengine - * inserts a readable socket. If it is false, the socketengine - * inserts a writeable socket. The derived class should never - * change the value this function returns without first - * deleting the socket from the socket engine. The only + * class will receive events to its OnEventHandler*() methods. + * The event mask passed to SocketEngine::AddFd() determines + * what events the EventHandler gets notified about and with + * what semantics. SocketEngine::ChangeEventMask() can be + * called to update the event mask later. The only * requirement beyond this for an event handler is that it * must have a file descriptor. What this file descriptor * is actually attached to is completely up to you. @@ -156,6 +155,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 @@ -164,15 +166,24 @@ class CoreExport EventHandler : public classbase * registered with the SocketEngine */ int fd; + + /** Swaps the internals of this EventHandler with another one. + * @param other A EventHandler to swap internals with. + */ + void SwapInternals(EventHandler& other); + public: /** Get the current file descriptor * @return The file descriptor of this handler */ inline int GetFd() const { return fd; } + /** Checks if this event handler has a fd associated with it. */ + inline bool HasFd() const { return fd >= 0; } + inline int GetEventMask() const { return event_mask; } - /** Set a new file desciptor + /** Set a new file descriptor * @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. @@ -187,14 +198,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, - * and EVENT_WRITE for write events. + /** 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; }; @@ -205,47 +222,102 @@ class CoreExport EventHandler : public classbase * its private members and internal behaviour * should be treated as blackboxed, and vary * from system to system and upon the config - * settings chosen by the server admin. The current - * version supports select, epoll and kqueue. - * The configure script will enable a socket engine - * based upon what OS is detected, and will derive - * a class from SocketEngine based upon what it finds. - * The derived classes file will also implement a - * classfactory, SocketEngineFactory, which will - * create a derived instance of SocketEngine using - * polymorphism so that the core and modules do not - * have to be aware of which SocketEngine derived - * class they are using. + * settings chosen by the server admin. */ class CoreExport SocketEngine { - protected: - /** Current number of descriptors in the engine - */ - int CurrentSetSize; + public: + /** Socket engine statistics: count of various events, bandwidth usage + */ + class Statistics + { + mutable size_t indata; + mutable size_t outdata; + mutable time_t lastempty; + + /** Reset the byte counters and lastempty if there wasn't a reset in this second. + */ + void CheckFlush() const; + + public: + /** Constructor, initializes member vars except indata and outdata because those are set to 0 + * in CheckFlush() the first time Update() or GetBandwidth() is called. + */ + Statistics() : lastempty(0), TotalEvents(0), ReadEvents(0), WriteEvents(0), ErrorEvents(0) { } + + /** Update counters for network data received. + * This should be called after every read-type syscall. + * @param len_in Number of bytes received, or -1 for error, as typically + * returned by a read-style syscall. + */ + void UpdateReadCounters(int len_in); + + /** Update counters for network data sent. + * This should be called after every write-type syscall. + * @param len_out Number of bytes sent, or -1 for error, as typically + * returned by a read-style syscall. + */ + void UpdateWriteCounters(int len_out); + + /** Get data transfer statistics. + * @param kbitpersec_in Filled with incoming traffic in this second in kbit/s. + * @param kbitpersec_out Filled with outgoing traffic in this second in kbit/s. + * @param kbitpersec_total Filled with total traffic in this second in kbit/s. + */ + void CoreExport GetBandwidth(float& kbitpersec_in, float& kbitpersec_out, float& kbitpersec_total) const; + + unsigned long TotalEvents; + unsigned long ReadEvents; + unsigned long WriteEvents; + unsigned long ErrorEvents; + }; + + private: /** Reference table, contains all current handlers - */ - EventHandler** ref; + **/ + static std::vector ref; + + /** Current number of descriptors in the engine. */ + static size_t CurrentSetSize; + + /** The maximum number of descriptors in the engine. */ + static size_t MaxSetSize; + /** List of handlers that want a trial read/write */ - std::set trials; + static std::set trials; - int MAX_DESCRIPTORS; + /** Socket engine statistics: count of various events, bandwidth usage + */ + static Statistics stats; - size_t indata; - size_t outdata; - time_t lastempty; + /** Look up the fd limit using rlimit. */ + static void LookupMaxFds(); - void UpdateStats(size_t len_in, size_t len_out); + /** Terminates the program when the socket engine fails to initialize. */ + static void InitError(); - virtual void OnSetEvent(EventHandler* eh, int old_mask, int new_mask) = 0; - void SetEventMask(EventHandler* eh, int value); -public: + static void OnSetEvent(EventHandler* eh, int old_mask, int new_mask); - double TotalEvents; - double ReadEvents; - double WriteEvents; - double ErrorEvents; + /** Add an event handler to the base socket engine. AddFd(EventHandler*, int) should call this. + */ + static bool AddFdRef(EventHandler* eh); + + static void DelFdRef(EventHandler* eh); + + template + static void ResizeDouble(std::vector& vect) + { + if (SocketEngine::CurrentSetSize > vect.size()) + vect.resize(SocketEngine::CurrentSetSize * 2); + } + +public: +#ifndef _WIN32 + typedef iovec IOVector; +#else + typedef WindowsIOVec IOVector; +#endif /** Constructor. * The constructor transparently initializes @@ -254,23 +326,25 @@ 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 * must provide an object derived from EventHandler which implements - * HandleEvent(). + * the required OnEventHandler*() methods. * @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 @@ -283,17 +357,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 non-zero the number of file descriptors that the system reported that we + * may use. */ - inline int GetMaxFds() const { return MAX_DESCRIPTORS; } + static size_t GetMaxFds() { return MaxSetSize; } /** Returns the number of file descriptors being queried * @return The set size */ - inline int GetUsedFds() const { return CurrentSetSize; } + static size_t GetUsedFds() { return CurrentSetSize; } /** Delete an event handler from the engine. * This function call deletes an EventHandler @@ -301,155 +377,178 @@ 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; + 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. + * If the fd isn't 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 * 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. + * EventHandler::OnEventHandler*() methods. + * @return The number of events which have occurred. */ - 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(); - - /** 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; + 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. * @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. */ - int Accept(EventHandler* fd, sockaddr *addr, socklen_t *addrlen); + 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 */ - int Close(EventHandler* fd); + static int Close(EventHandler* eh); /** 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. */ - int Close(int fd); + static 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. + */ + 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. */ - int Send(EventHandler* fd, const void *buf, size_t len, int flags); + 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. * @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. */ - 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. * @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. */ - 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. * @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 address The remote IP address and port. * @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 irc::sockets::sockaddrs& address); /** 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 address The server IP address and port. * @return This method should return exactly the same values as the system call it emulates. */ - int Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen); + static int Connect(EventHandler* fd, const irc::sockets::sockaddrs& address); /** 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. */ - int Blocking(int fd); + static 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. */ - int NonBlocking(int fd); + static 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. */ - int Shutdown(EventHandler* fd, int how); + static 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. */ - int Shutdown(int fd, int how); + static 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. */ - int Bind(int fd, const sockaddr *my_addr, socklen_t addrlen); + static 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. */ - int Listen(int sockfd, int backlog); + static int Listen(int sockfd, int backlog); /** Set SO_REUSEADDR and SO_LINGER on this file descriptor */ - void SetReuse(int sockfd); + static void SetReuse(int sockfd); /** This function is called immediately after fork(). * Some socket engines (notably kqueue) cannot have their @@ -460,14 +559,35 @@ 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 statistics, kilobits per second in and out and total. + /** Get data transfer and event statistics */ - void GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total); + static const Statistics& GetStats() { return stats; } + + /** 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); }; -SocketEngine* CreateSocketEngine(); +inline bool SocketEngine::IgnoreError() +{ + if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) + return true; +#ifdef _WIN32 + if (WSAGetLastError() == WSAEWOULDBLOCK) + return true; #endif + return false; +}