X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=include%2Fsocketengine.h;h=3a15e98c1475cfefd252596c85913754ef4d0812;hb=8f31b0cf2a753cd7b6af8fd1dc730d0693ebeb90;hp=e23c74de48f1265913c6c7fe5aedc0a01b1d2da2;hpb=f5d5cee19ae1153adae20ee8143d18d61b407b2c;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/include/socketengine.h b/include/socketengine.h index e23c74de4..3a15e98c1 100644 --- a/include/socketengine.h +++ b/include/socketengine.h @@ -1,23 +1,31 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2010 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__ + +#pragma once #include #include #include -#include "inspircd_config.h" +#include "config.h" #include "socket.h" #include "base.h" @@ -119,7 +127,7 @@ enum EventMask /** 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. @@ -128,7 +136,7 @@ enum EventMask /** 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, + FD_WRITE_WILL_BLOCK = 0x8000, /** Mask for trial read/trial write */ FD_TRIAL_NOTE_MASK = 0x5000 @@ -157,6 +165,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 @@ -193,7 +204,9 @@ class CoreExport EventHandler : public classbase * 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; @@ -220,34 +233,79 @@ class CoreExport EventHandler : public classbase */ class CoreExport SocketEngine { + 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) { } + + /** Increase the counters for bytes sent/received in this second. + * @param len_in Bytes received, 0 if updating number of bytes written. + * @param len_out Bytes sent, 0 if updating number of bytes read. + */ + void Update(size_t len_in, size_t len_out); + + /** Get data transfer statistics. + * @param kbitspersec_in Filled with incoming traffic in this second in kbit/s. + * @param kbitspersec_out Filled with outgoing traffic in this second in kbit/s. + * @param kbitspersec_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 + **/ + static std::vector ref; + protected: /** Current number of descriptors in the engine */ - int CurrentSetSize; - /** Reference table, contains all current handlers - */ - EventHandler** ref; + 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; - size_t indata; - size_t outdata; - time_t lastempty; + /** Socket engine statistics: count of various events, bandwidth usage + */ + static Statistics stats; - void UpdateStats(size_t len_in, size_t len_out); + static void OnSetEvent(EventHandler* eh, int old_mask, int new_mask); - virtual void OnSetEvent(EventHandler* eh, int old_mask, int new_mask) = 0; - void SetEventMask(EventHandler* eh, int value); -public: + /** 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); - unsigned long TotalEvents; - unsigned long ReadEvents; - unsigned long WriteEvents; - unsigned long ErrorEvents; + template + static void ResizeDouble(std::vector& vect) + { + if (SocketEngine::CurrentSetSize > vect.size()) + vect.resize(vect.size() * 2); + } +public: /** Constructor. * The constructor transparently initializes * the socket engine which the ircd is using. @@ -255,14 +313,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 @@ -271,7 +331,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 @@ -284,17 +344,17 @@ 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 */ - 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 int GetUsedFds() const { return CurrentSetSize; } + static size_t GetUsedFds() { return CurrentSetSize; } /** Delete an event handler from the engine. * This function call deletes an EventHandler @@ -302,32 +362,23 @@ 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. * @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 @@ -337,120 +388,134 @@ 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(); - - /** 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. */ - 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 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 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. */ - 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. * @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. */ - int Connect(EventHandler* fd, const sockaddr *serv_addr, socklen_t addrlen); + static 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. */ - 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 irc::sockets::sockaddrs& addr); + 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 @@ -461,14 +526,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 and event statistics + */ + 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(); - /** Get data transfer statistics, kilobits per second in and out and total. + /** Returns the error for the given error num, strerror(errnum) on *nix */ - void GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total); + 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; +}