Create StreamSocket for IO hooking implementation

Fixes the SSL SendQ bug
Removes duplicate code between User and BufferedSocket
Simplify SSL module API
Simplify EventHandler API (Readable/Writeable moved to SE)
Add hook for culled objects to invoke callbacks prior to destructor
 Replace SocketCull with GlobalCull now that sockets can close themselves
Shorten common case of user read/parse/write path:
 User::Write is now zero-copy up to syscall/SSL invocation
 User::Read has only two copy/scan passes from read() to ProcessCommand

git-svn-id: http://svn.inspircd.org/repository/trunk/inspircd@11752 e03df62e-2008-0410-955e-edbf42e46eb7

1 files changed, 99 insertions, 228 deletions

diff --git a/include/inspsocket.h b/include/inspsocket.h
index 32f2dab1a..73aa748a0 100644
--- a/include/inspsocket.h
+++ b/include/inspsocket.h
@@ -36,6 +36,10 @@ enum BufferedSocketState
  */
 enum BufferedSocketError
 {
+	/** No error */
+	I_ERR_NONE,
+	/** Socket was closed by peer */
+	I_ERR_DISCONNECT,
 	/** Socket connect timed out */
 	I_ERR_TIMEOUT,
 	/** Socket could not be created */
@@ -44,17 +48,16 @@ enum BufferedSocketError
 	I_ERR_CONNECT,
 	/** Socket could not bind to local port/ip */
 	I_ERR_BIND,
-	/** Socket could not reslve host (depreciated) */
-	I_ERR_RESOLVE,
 	/** Socket could not write data */
 	I_ERR_WRITE,
 	/** No more file descriptors left to create socket! */
-	I_ERR_NOMOREFDS
+	I_ERR_NOMOREFDS,
+	/** Some other error */
+	I_ERR_OTHER
 };
 
 /* Required forward declarations */
 class BufferedSocket;
-class InspIRCd;
 
 /** Used to time out socket connections
  */
@@ -65,10 +68,6 @@ class CoreExport SocketTimeout : public Timer
 	 */
 	BufferedSocket* sock;
 
-	/** Server instance creating the timeout class
-	 */
-	InspIRCd* ServerInstance;
-
 	/** File descriptor of class this is attached to
 	 */
 	int sfd;
@@ -81,7 +80,7 @@ class CoreExport SocketTimeout : public Timer
 	 * @param secs_from_now Seconds from now to time out
 	 * @param now The current time
 	 */
-	SocketTimeout(int fd, InspIRCd* Instance, BufferedSocket* thesock, long secs_from_now, time_t now) : Timer(secs_from_now, now), sock(thesock), ServerInstance(Instance), sfd(fd) { };
+	SocketTimeout(int fd, BufferedSocket* thesock, long secs_from_now, time_t now) : Timer(secs_from_now, now), sock(thesock), sfd(fd) { }
 
 	/** Handle tick event
 	 */
@@ -89,6 +88,67 @@ class CoreExport SocketTimeout : public Timer
 };
 
 /**
+ * StreamSocket is a class that wraps a TCP socket and handles send
+ * and receive queues, including passing them to IO hooks
+ */
+class CoreExport StreamSocket : public EventHandler
+{
+	/** Module that handles raw I/O for this socket, or NULL */
+	Module *IOHook;
+	/** Private send queue. Note that individual strings may be shared
+	 */
+	std::deque<std::string> sendq;
+	/** Length, in bytes, of the sendq */
+	size_t sendq_len;
+	/** Error - if nonempty, the socket is dead, and this is the reason. */
+	std::string error;
+ protected:
+	std::string recvq;
+ public:
+	StreamSocket() : IOHook(NULL), sendq_len(0) {}
+	inline Module* GetIOHook() { return IOHook; }
+	inline void AddIOHook(Module* m) { IOHook = m; }
+	inline void DelIOHook() { IOHook = NULL; }
+	/** Handle event from socket engine.
+	 * This will call OnDataReady if there is *new* data in recvq
+	 */
+	virtual void HandleEvent(EventType et, int errornum = 0);
+	/** Dispatched from HandleEvent */
+	virtual void DoRead();
+	/** Dispatched from HandleEvent */
+	virtual void DoWrite();
+
+	/** Sets the error message for this socket. Once set, the socket is dead. */
+	void SetError(const std::string& err) { if (error.empty()) error = err; }
+
+	/** Gets the error message for this socket. */
+	const std::string& getError() const { return error; }
+
+	/** Called when new data is present in recvq */
+	virtual void OnDataReady() = 0;
+	/** Called when the socket gets an error from socket engine or IO hook */
+	virtual void OnError(BufferedSocketError e) = 0;
+
+	/** Send the given data out the socket, either now or when writes unblock
+	 */
+	void WriteData(const std::string& data);
+	/** Convenience function: read a line from the socket
+	 * @param line The line read
+	 * @param delim The line delimiter
+	 * @return true if a line was read
+	 */
+	bool GetNextLine(std::string& line, char delim = '\n');
+	/** Useful for implementing sendq exceeded */
+	inline const size_t getSendQSize() const { return sendq_len; }
+
+	/**
+	 * Close the socket, remove from socket engine, etc
+	 */
+	virtual void Close();
+	/** This ensures that close is called prior to destructor */
+	virtual void cull();
+};
+/**
  * BufferedSocket is an extendable socket class which modules
  * can use for TCP socket support. It is fully integrated
  * into InspIRCds socket loop and attaches its sockets to
@@ -97,34 +157,13 @@ class CoreExport SocketTimeout : public Timer
  *
  * To use BufferedSocket, you must inherit a class from it.
  */
-class CoreExport BufferedSocket : public EventHandler
+class CoreExport BufferedSocket : public StreamSocket
 {
  public:
-
-	/** Bind IP
-	 */
-	std::string cbindip;
-
-	/** Instance we were created by
-	 */
-	InspIRCd* ServerInstance;
-
-	/** Timeout class or NULL
+	/** Timeout object or NULL
 	 */
 	SocketTimeout* Timeout;
 
-	/** Socket output buffer (binary safe)
-	 */
-	std::deque<std::string> outbuffer;
-
-	/** The hostname connected to
-	 */
-	char host[MAXBUF];
-
-	/** The port connected to
-	 */
-	int port;
-
 	/**
 	 * The state for this socket, either
 	 * listening, connecting, connected
@@ -132,220 +171,52 @@ class CoreExport BufferedSocket : public EventHandler
 	 */
 	BufferedSocketState state;
 
-	/**
-	 * The IP address being connected
-	 * to stored in string form for
-	 * easy retrieval by accessors.
-	 */
-	char IP[MAXBUF];
-
-	/**
-	 * Used by accept() to indicate the
-	 * sizes of the sockaddr_in structures
-	 */
-	socklen_t length;
-
-	/** Flushes the write buffer
-	 * @returns true if the writing failed, false if it was successful
-	 */
-	bool FlushWriteBuffer();
-
-	/** Set the queue sizes
-	 * This private method sets the operating system queue
-	 * sizes for this socket to 65535 so that it can queue
-	 * more information without application-level queueing
-	 * which was required in older software.
-	 */
-	void SetQueues();
-
-	/** When the socket has been marked as closing, this flag
-	 * will be set to true, then the next time the socket is
-	 * examined, the socket is deleted and closed.
-	 */
-	bool ClosePending;
-
-	/**
-	 * Bind to an address
-	 * @param ip IP to bind to
-	 * @return True is the binding succeeded
-	 */
-	bool BindAddr(const std::string &ip);
-
-	/** (really) Try bind to a given IP setup. For internal use only.
-	 */
-	bool DoBindMagic(const std::string &current_ip);
-
-	/**
-	 * The default constructor does nothing
-	 * and should not be used.
-	 */
-	BufferedSocket(InspIRCd* SI);
-
+	BufferedSocket();
 	/**
 	 * This constructor is used to associate
 	 * an existing connecting with an BufferedSocket
 	 * class. The given file descriptor must be
 	 * valid, and when initialized, the BufferedSocket
-	 * will be set with the given IP address
-	 * and placed in CONNECTED state.
-	 */
-	BufferedSocket(InspIRCd* SI, int newfd, const char* ip);
-
-	/**
-	 * This constructor is used to create a new outbound connection to another host.
-	 * Note that if you specify a hostname in the 'ipaddr' parameter, this class will not
-	 * connect. You must resolve your hostnames before passing them to BufferedSocket. To do so,
-	 * you should use the nonblocking class 'Resolver'.
-	 * @param ipaddr The IP to connect to, or bind to
-	 * @param port The port number to connect to
-	 * @param maxtime Number of seconds to wait, if connecting, before the connection times out and an OnTimeout() event is generated
-	 * @param connectbindip When creating an outbound connection, the IP to bind the connection to. If not defined, the port is not bound.
-	 * @return On exit, GetState() returns I_ERROR if an error occured, and errno can be used to read the socket error.
-	 */
-	BufferedSocket(InspIRCd* SI, const std::string &ipaddr, int port, unsigned long maxtime, const std::string &connectbindip = "");
-
-	/**
-	 * This method is called when an outbound
-	 * connection on your socket is completed.
-	 * @return false to abort the connection, true to continue
-	 */
-	virtual bool OnConnected();
-
-	/**
-	 * This method is called when an error occurs.
-	 * A closed socket in itself is not an error,
-	 * however errors also generate close events.
-	 * @param e The error type which occured
+	 * will be placed in CONNECTED state.
 	 */
-	virtual void OnError(BufferedSocketError e);
+	BufferedSocket(int newfd);
 
-	/**
-	 * When an established connection is terminated,
-	 * the OnDisconnect method is triggered.
+	/** Begin connection to the given address
+	 * This will create a socket, register with socket engine, and start the asynchronous
+	 * connection process. If an error is detected at this point (such as out of file descriptors),
+	 * OnError will be called; otherwise, the state will become CONNECTING.
+	 * @param dest Address to connect to
+	 * @param bind Address to bind to (if NULL, no bind will be done)
+	 * @param timeout Time to wait for connection
 	 */
-	virtual int OnDisconnect();
+	void DoConnect(const std::string &ipaddr, int aport, unsigned long maxtime, const std::string &connectbindip);
 
-	/**
-	 * When there is data waiting to be read on a
-	 * socket, the OnDataReady() method is called.
-	 * Within this method, you *MUST* call the Read()
-	 * method to read any pending data. At its lowest
-	 * level, this event is signalled by the core via
-	 * the socket engine. If you return false from this
-	 * function, the core removes your socket from its
-	 * list and erases it from the socket engine, then
-	 * calls BufferedSocket::Close() and deletes it.
-	 * @return false to close the socket
+	/** This method is called when an outbound connection on your socket is
+	 * completed.
 	 */
-	virtual bool OnDataReady();
+	virtual void OnConnected();
 
-	/**
-	 * When it is ok to write to the socket, and a
-	 * write event was requested, this method is
-	 * triggered.
-	 *
-	 * Within this method you should call
-	 * write() or send() etc, to send data to the
-	 * other end of the socket.
-	 *
-	 * Further write events will not be triggered
-	 * unless you call SocketEngine::WantWrite().
-	 *
-	 * The default behaviour of this method is to
-	 * flush the write buffer, respecting the IO
-	 * hooking modules.
-	 *
-	 * XXX: this used to be virtual, ask us if you need it to be so.
-	 * @return false to close the socket
+	/** When there is data waiting to be read on a socket, the OnDataReady()
+	 * method is called.
 	 */
-	bool OnWriteReady();
+	virtual void OnDataReady() = 0;
 
 	/**
-	 * When an outbound connection fails, and the
-	 * attempt times out, you will receive this event.
-	 * The method will trigger once maxtime seconds are
-	 * reached (as given in the constructor) just
-	 * before the socket's descriptor is closed.
-	 * A failed DNS lookup may cause this event if
-	 * the DNS server is not responding, as well as
-	 * a failed connect() call, because DNS lookups are
-	 * nonblocking as implemented by this class.
+	 * When an outbound connection fails, and the attempt times out, you
+	 * will receive this event.  The method will trigger once maxtime
+	 * seconds are reached (as given in the constructor) just before the
+	 * socket's descriptor is closed.  A failed DNS lookup may cause this
+	 * event if the DNS server is not responding, as well as a failed
+	 * connect() call, because DNS lookups are nonblocking as implemented by
+	 * this class.
 	 */
 	virtual void OnTimeout();
 
-	/**
-	 * Whenever close() is called, OnClose() will be
-	 * called first. Please note that this means
-	 * OnClose will be called alongside OnError(),
-	 * OnTimeout(), and Close().
-	 */
-	virtual void OnClose();
-
-	/**
-	 * Reads all pending bytes from the socket
-	 * into a char* array which can be up to
-	 * 16 kilobytes in length.
-	 */
-	virtual const char* Read();
-
-	/**
-	 * Returns the IP address associated with
-	 * this connection, or an empty string if
-	 * no IP address exists.
-	 */
-	std::string GetIP();
-
-	/**
-	 * Writes a std::string to the socket. No carriage
-	 * returns or linefeeds are appended to the string.
-	 * @param data The data to send
-	 */
-	virtual void Write(const std::string &data);
-
-	/**
-	 * Changes the socket's state. The core uses this
-	 * to change socket states, and you should not call
-	 * it directly.
-	 */
-	void SetState(BufferedSocketState s);
-
-	/**
-	 * Returns the current socket state.
-	 */
-	BufferedSocketState GetState();
-
-	/** Mark a socket as being connected and call appropriate events.
-	 */
-	bool InternalMarkConnected();
-
-	/**
-	 * This method causes the socket to close, and may
-	 * also be triggered by other methods such as OnTimeout
-	 * and OnError.
-	 */
-	virtual void Close();
-
-	/**
-	 * The destructor may implicitly call OnClose(), and
-	 * will close() and shutdown() the file descriptor
-	 * used for this socket.
-	 */
 	virtual ~BufferedSocket();
-
-	/**
-	 * This method attempts to connect to a hostname.
-	 * This method is asyncronous.
-	 * @param maxtime Number of seconds to wait, if connecting, before the connection times out and an OnTimeout() event is generated
-	 */
-	virtual bool DoConnect(unsigned long maxtime);
-
-	/** Handle event from EventHandler parent class
-	 */
-	void HandleEvent(EventType et, int errornum = 0);
-
-	/** Returns true if this socket is readable
-	 */
-	bool Readable();
+ protected:
+	virtual void DoWrite();
+	BufferedSocketError BeginConnect(const irc::sockets::sockaddrs& dest, const irc::sockets::sockaddrs& bind, unsigned long timeout);
+	BufferedSocketError BeginConnect(const std::string &ipaddr, int aport, unsigned long maxtime, const std::string &connectbindip);
 };
 
 #endif