Forward port r9946: make SVSHOLD silent to avoid useless irritation to opers

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

2 files changed, 136 insertions, 13 deletions

diff --git a/include/linebuffer.h b/include/linebuffer.h
new file mode 100644
index 000000000..8b579c452
--- /dev/null
+++ b/include/linebuffer.h
@@ -0,0 +1,110 @@
+/*       +------------------------------------+

+ *       | Inspire Internet Relay Chat Daemon |

+ *       +------------------------------------+

+ *

+ *  InspIRCd: (C) 2002-2008 InspIRCd Development Team

+ * See: http://www.inspircd.org/wiki/index.php/Credits

+ *

+ * This program is free but copyrighted software; see

+ *            the file COPYING for details.

+ *

+ * ---------------------------------------------------

+ */

+

+/** Right, Line Buffers. Time for an explanation as to how sendqs work. By the way, ircd people,

+ * before you jump up and down screaming, this is not anything like Adrian Chadd's linebuffer

+ * stuff done for hybrid(and never really completed.) Rather, this is (I think) where linebuffer

+ * was heading, and should have been.

+ *

+ * Enough introduction, actual explanation starts here.

+ * In IRCd, we have a sendq. Traditionally, a sendq has been a big string. Stuff is tacked onto

+ * the end, and when we can, we send the user some data off the start of it. A circular buffer.

+ *

+ * This model works okay, and is quite simplistic to code, but has a drawback in that most IRC

+ * messages are multicast: topic changes, joins, parts, channel messages, and so on.

+ * This means that for each of these messages, we must do O(n^n) amount of work: bytes ^ recipients

+ * of writes will be made to sendqs, and this is a slow and expensive operation.

+ *

+ * The solution comes with the use of this linebuffer class below, which is managed entirely by

+ * the user class (though it *may* be possible to add a server to server implementation of this later,

+ * but that's nowhere near so needed, and nowhere near so trivial, thanks to the inherited nature

+ * of buffered socket, but I digress).

+ *

+ * What this class does, in a nutshell:

+ * When we need to send a message to a user, we create a LineBuffer object. It has a reference count, and

+ * we copy the string we need to send into the LineBuffer object also.

+ * We then tack a pointer to this LineBuffer into an std::list stored in the User class.

+ * When the user writes data, a ptr is advanced depending how much of that line they wrote. If they wrote all

+ * of the line,  the pointer is popped off the std::list, the ptr is reset, and the buffer's refcount is

+ * decremented - and if it reaches 0, the linebuffer is destroyed as it has fulfilled it's purpose.

+ *

+ * Effectively, this means that multicast writes become O(n) + time taken to copy message once, or just about.

+ *

+ * We gain efficiency, and much, much better RAM usage.

+ */

+static unsigned int totalbuffers = 0;

+

+class LineBuffer

+{

+ private:

+	std::string msg;

+	unsigned long refcount;

+

+	// Don't let it be copied.

+	LineBuffer(const LineBuffer &) { }

+

+ public:

+	~LineBuffer()

+	{

+		totalbuffers--;

+		printf("Destroying LineBuffer with %u bytes, total buffers is %u\n", msg.length(), totalbuffers);

+		msg.resize(0);

+	}

+

+	LineBuffer(std::string &m)

+	{

+		if (m.length() > MAXBUF - 2) /* MAXBUF has a value of 514, to account for line terminators */

+		{

+			// Trim the message to fit, 510 characters max.

+			m = m.substr(0, MAXBUF - 4); // MAXBUF is 514, we need 510.

+		}

+

+		// Add line terminator

+		m.append("\r\n");

+		

+		// And copy

+		msg = m;

+		refcount = 0;

+		totalbuffers++;

+		printf("Creating LineBuffer with %u bytes, total buffers is %u\n", msg.length(), totalbuffers);

+	}

+

+	std::string &GetMessage()

+	{

+		return msg;

+	}

+

+	unsigned long GetMessageLength()

+	{

+		return msg.length();

+	}

+

+	// To be used after creation, when we know how many recipients we actually have.

+	void SetRefcount(unsigned long r)

+	{

+		refcount = r;

+	}

+

+	unsigned long DecrementCount()

+	{

+		if (refcount == 0)

+		{

+			throw "decrementing a refcount when nobody is using it is weird and wrong";

+		}

+

+		refcount--;

+		return refcount;

+	}

+

+	// There is no increment method as it isn't really needed.

+};

diff --git a/include/users.h b/include/users.h
index f098500e3..883fbadf8 100644
--- a/include/users.h
+++ b/include/users.h
@@ -17,12 +17,17 @@
 #include "socket.h"
 #include "connection.h"
 #include "dns.h"
-
 #include "mode.h"
+#include "linebuffer.h"
+
+#include <list> // XXX XXX XXX this should probably be moved to globals.h, and globals.h should probably be merged in with inspircd.h sometime. -- w00t
+#define _GLIBCXX_FORCE_NEW 1
+
 
 /** Channel status for a user
  */
-enum ChanStatus {
+enum ChanStatus
+{
 	/** Op */
 	STATUS_OP     = 4,
 	/** Halfop */
@@ -35,7 +40,8 @@ enum ChanStatus {
 
 /** connect class types
  */
-enum ClassTypes {
+enum ClassTypes
+{
 	/** connect:allow */
 	CC_ALLOW = 0,
 	/** connect:deny */
@@ -44,7 +50,8 @@ enum ClassTypes {
 
 /** RFC1459 channel modes
  */
-enum UserModes {
+enum UserModes
+{
 	/** +s: Server notices */
 	UM_SERVERNOTICE = 's' - 65,
 	/** +w: WALLOPS */
@@ -60,16 +67,17 @@ enum UserModes {
 /** Registration state of a user, e.g.
  * have they sent USER, NICK, PASS yet?
  */
-enum RegistrationState {
-
-#ifndef WIN32   // Burlex: This is already defined in win32, luckily it is still 0.
+enum RegistrationState
+{
+#ifndef REG_NONE		/* This is already defined in win32, luckily it is still 0. -- Burlex 
+							XXX perhaps we should undef it just in case.. Relying on magic numbers... -- w00t */
 	REG_NONE = 0,		/* Has sent nothing */
 #endif
 
 	REG_USER = 1,		/* Has sent USER */
 	REG_NICK = 2,		/* Has sent NICK */
 	REG_NICKUSER = 3, 	/* Bitwise combination of REG_NICK and REG_USER */
-	REG_ALL = 7	  	/* REG_NICKUSER plus next bit along */
+	REG_ALL = 7		  	/* REG_NICKUSER plus next bit along */
 };
 
 /* Required forward declaration */
@@ -598,10 +606,15 @@ class CoreExport User : public connection
 	 */
 	std::string recvq;
 
-	/** User's send queue.
-	 * Lines waiting to be sent are stored here until their buffer is flushed.
+	/** How many bytes are currently in the user's sendq.
+	 */
+	unsigned long sendqlength;
+	/** List of pointers to buffer objects, this is the actual user's sendq.
+	 */
+	std::list<LineBuffer*, __gnu_cxx::new_allocator<LineBuffer*> > sendq;
+	/** How far into the current sendq line is the user?
 	 */
-	std::string sendq;
+	unsigned long sendqpos;
 
 	/** Message user will quit with. Not to be set externally.
 	 */
@@ -843,13 +856,13 @@ class CoreExport User : public connection
 	 */
 	const char* GetWriteError();
 
-	/** Adds to the user's write buffer.
+	/** Adds a line buffer to the user's sendq.
 	 * You may add any amount of text up to this users sendq value, if you exceed the
 	 * sendq value, SetWriteError() will be called to set the users error string to
 	 * "SendQ exceeded", and further buffer adds will be dropped.
 	 * @param data The data to add to the write buffer
 	 */
-	void AddWriteBuf(const std::string &data);
+	void AddWriteBuf(LineBuffer *l);
 
 	/** Flushes as much of the user's buffer to the file descriptor as possible.
 	 * This function may not always flush the entire buffer, rather instead as much of it