* | Inspire Internet Relay Chat Daemon |
* +------------------------------------+
*
- * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- * E-mail:
- * <brain@chatspike.net>
- * <Craig@chatspike.net>
+ * InspIRCd: (C) 2002-2008 InspIRCd Development Team
+ * See: http://www.inspircd.org/wiki/index.php/Credits
*
- * Written by Craig Edwards, Craig McLure, and others.
* This program is free but copyrighted software; see
* the file COPYING for details.
*
* ---------------------------------------------------
-*/
+ */
#ifndef __SOCKETENGINE__
#define __SOCKETENGINE__
*/
enum EventType
{
+ /** Read event */
EVENT_READ = 0,
+ /** Write event */
EVENT_WRITE = 1,
+ /** Error event */
EVENT_ERROR = 2
};
* must have a file descriptor. What this file descriptor
* is actually attached to is completely up to you.
*/
-class EventHandler : public Extensible
+class CoreExport EventHandler : public Extensible
{
protected:
/** File descriptor.
*/
int fd;
public:
+
/** Get the current file descriptor
* @return The file descriptor of this handler
*/
* is still added to a SocketEngine instance!
* If this function is unimplemented, the base class
* will return true.
- *
+ *
* NOTE: You cannot set both Readable() and
* Writeable() to true. If you wish to receive
* a write event for your object, you must call
* If this function is unimplemented, the base class
* will return false.
*
- * NOTE: You cannot set both Readable() and
+ * NOTE: You cannot set both Readable() and
* Writeable() to true. If you wish to receive
* a write event for your object, you must call
* SocketEngine::WantWrite() instead. This will
* have to be aware of which SocketEngine derived
* class they are using.
*/
-class SocketEngine : public Extensible
+class CoreExport SocketEngine : public Extensible
{
protected:
/** Owner/Creator
int CurrentSetSize;
/** Reference table, contains all current handlers
*/
- EventHandler* ref[MAX_DESCRIPTORS];
+ EventHandler** ref;
+
+ int MAX_DESCRIPTORS;
+
+ size_t indata;
+ size_t outdata;
+ time_t lastempty;
+
+ void UpdateStats(size_t len_in, size_t len_out);
public:
+ double TotalEvents;
+ double ReadEvents;
+ double WriteEvents;
+ double ErrorEvents;
+
/** Constructor.
* The constructor transparently initializes
* the socket engine which the ircd is using.
* 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);
+ virtual bool DelFd(EventHandler* eh, bool force = false);
/** 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
*/
- bool HasFd(int fd);
+ virtual 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
*/
- EventHandler* GetRef(int fd);
+ virtual EventHandler* GetRef(int fd);
/** Waits for events and dispatches them to handlers.
* Please note that this doesnt wait long, only
* @return The socket engine name
*/
virtual std::string GetName();
+
+ /** 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.
+ * @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);
+
+ /** 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);
+
+ /** 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);
+
+ /** 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.
+ * @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);
+
+ /** 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.
+ * @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);
+
+ /** 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.
+ * @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);
+
+ /** 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.
+ * @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);
+
+ /** 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.
+ * @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);
+
+ /** 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);
+
+ /** 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);
+
+ /** 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.
+ * @return This method should return exactly the same values as the system call it emulates.
+ */
+ virtual 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);
+
+ /** 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);
+
+ /** 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);
+
+ /** 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.
+ */
+ virtual int GetSockName(EventHandler* fd, sockaddr *name, socklen_t* namelen);
+
+ /** This function is called immediately after fork().
+ * Some socket engines (notably kqueue) cannot have their
+ * handles inherited by forked processes. This method
+ * allows for the socket engine to re-create its handle
+ * after the daemon forks as the socket engine is created
+ * long BEFORE the daemon forks.
+ * @return void, but it is acceptable for this function to bail back to
+ * the shell or operating system on fatal error.
+ */
+ virtual void RecoverFromFork();
+
+ /** Get data transfer statistics, kilobits per second in and out and total.
+ */
+ void GetStats(float &kbitpersec_in, float &kbitpersec_out, float &kbitpersec_total);
};
#endif
+