X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmode.cpp;h=db120cfe587a59be26b676815fbc44f4002b8f90;hb=d7ac76bed17ac6c9f0884f5e37d01f075243a3b8;hp=c7d66cd463ec81f9fb1177c717725678755990a2;hpb=5e3d719f94d8166219802691d50ab06e260a6d09;p=user%2Fhenk%2Fcode%2Finspircd.git

diff --git a/src/mode.cpp b/src/mode.cpp
index c7d66cd46..db120cfe5 100644
--- a/src/mode.cpp
+++ b/src/mode.cpp
@@ -2,31 +2,19 @@
  *       | Inspire Internet Relay Chat Daemon |
  *       +------------------------------------+
  *
- *  InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev.
- *		      	 E-mail:
- *		<brain@chatspike.net>
- *	   	  <Craig@chatspike.net>
- *     
- * Written by Craig Edwards, Craig McLure, and others.
+ *  InspIRCd: (C) 2002-2007 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.
+ *            the file COPYING for details.
  *
  * ---------------------------------------------------
  */
 
-using namespace std;
-
-#include "inspircd_config.h"
 #include "inspircd.h"
-#include "configreader.h"
-#include <unistd.h>
-#include "hash_map.h"
-#include "connection.h"
 #include "users.h"
 #include "modules.h"
 #include "inspstring.h"
-
-#include "commands.h"
 #include "mode.h"
 
 /* +s (secret) */
@@ -53,7 +41,6 @@ using namespace std;
 #include "modes/cmode_h.h"
 /* +v (channel voice) */
 #include "modes/cmode_v.h"
-
 /* +s (server notices) */
 #include "modes/umode_s.h"
 /* +w (see wallops) */
@@ -66,7 +53,7 @@ using namespace std;
 #include "modes/umode_n.h"
 
 ModeHandler::ModeHandler(InspIRCd* Instance, char modeletter, int parameters_on, int parameters_off, bool listmode, ModeType type, bool operonly, char mprefix)
-	: ServerInstance(Instance), mode(modeletter), n_params_on(parameters_on), n_params_off(parameters_off), list(listmode), m_type(type), oper(operonly), prefix(mprefix)
+	: ServerInstance(Instance), mode(modeletter), n_params_on(parameters_on), n_params_off(parameters_off), list(listmode), m_type(type), oper(operonly), prefix(mprefix), count(0)
 {
 }
 
@@ -84,6 +71,16 @@ unsigned int ModeHandler::GetPrefixRank()
 	return 0;
 }
 
+unsigned int ModeHandler::GetCount()
+{
+	return 0;
+}
+
+void ModeHandler::ChangeCount(int modifier)
+{
+	count += modifier;
+}
+
 ModeType ModeHandler::GetModeType()
 {
 	return m_type;
@@ -183,31 +180,27 @@ const char* ModeParser::Grant(userrec *d,chanrec *chan,int MASK)
 	if (!chan)
 		return "";
 
-	for (std::vector<ucrec*>::const_iterator i = d->chans.begin(); i != d->chans.end(); i++)
+	UCListIter n = d->chans.find(chan);
+	if (n != d->chans.end())
 	{
-		ucrec* n = (ucrec*)(*i);
-		if (n->channel == chan)
+		if (n->second & MASK)
 		{
-			if (n->uc_modes & MASK)
-			{
-				return "";
-			}
-			n->uc_modes = n->uc_modes | MASK;
-			switch (MASK)
-			{
-				case UCMODE_OP:
-					n->channel->AddOppedUser(d);
-				break;
-				case UCMODE_HOP:
-					n->channel->AddHalfoppedUser(d);
-				break;
-				case UCMODE_VOICE:
-					n->channel->AddVoicedUser(d);
-				break;
-			}
-			ServerInstance->Log(DEBUG,"grant: %s %s",n->channel->name,d->nick);
-			return d->nick;
+			return "";
+		}
+		n->second = n->second | MASK;
+		switch (MASK)
+		{
+			case UCMODE_OP:
+				n->first->AddOppedUser(d);
+			break;
+			case UCMODE_HOP:
+				n->first->AddHalfoppedUser(d);
+			break;
+			case UCMODE_VOICE:
+				n->first->AddVoicedUser(d);
+			break;
 		}
+		return d->nick;
 	}
 	return "";
 }
@@ -217,31 +210,27 @@ const char* ModeParser::Revoke(userrec *d,chanrec *chan,int MASK)
 	if (!chan)
 		return "";
 
-	for (std::vector<ucrec*>::const_iterator i = d->chans.begin(); i != d->chans.end(); i++)
+	UCListIter n = d->chans.find(chan);
+	if (n != d->chans.end())
 	{
-		ucrec* n = (ucrec*)(*i);
-		if (n->channel == chan)
+		if ((n->second & MASK) == 0)
 		{
-			if ((n->uc_modes & MASK) == 0)
-			{
-				return "";
-			}
-			n->uc_modes ^= MASK;
-			switch (MASK)
-			{
-				case UCMODE_OP:
-					n->channel->DelOppedUser(d);
-				break;
-				case UCMODE_HOP:
-					n->channel->DelHalfoppedUser(d);
-				break;
-				case UCMODE_VOICE:
-					n->channel->DelVoicedUser(d);
-				break;
-			}
-			ServerInstance->Log(DEBUG,"revoke: %s %s",n->channel->name,d->nick);
-			return d->nick;
+			return "";
 		}
+		n->second ^= MASK;
+		switch (MASK)
+		{
+			case UCMODE_OP:
+				n->first->DelOppedUser(d);
+			break;
+			case UCMODE_HOP:
+				n->first->DelHalfoppedUser(d);
+			break;
+			case UCMODE_VOICE:
+				n->first->DelVoicedUser(d);
+			break;
+		}
+		return d->nick;
 	}
 	return "";
 }
@@ -252,15 +241,30 @@ void ModeParser::DisplayCurrentModes(userrec *user, userrec* targetuser, chanrec
 	{
 		/* Display channel's current mode string */
 		user->WriteServ("324 %s %s +%s",user->nick, targetchannel->name, targetchannel->ChanModes(targetchannel->HasUser(user)));
-		user->WriteServ("329 %s %s %d", user->nick, targetchannel->name, targetchannel->created);
+		user->WriteServ("329 %s %s %lu", user->nick, targetchannel->name, (unsigned long)targetchannel->age);
 		return;
 	}
 	else if (targetuser)
 	{
-		/* Display user's current mode string */
-		user->WriteServ("221 %s :+%s",targetuser->nick,targetuser->FormatModes());
-		user->WriteServ("008 %s :+%s", targetuser->nick, targetuser->FormatNoticeMasks());
-		return;
+		if (targetuser->Visibility && !targetuser->Visibility->VisibleTo(user))
+		{
+			user->WriteServ("401 %s %s :No such nick/channel",user->nick, text);
+			return;
+		}
+
+		if ((targetuser == user) || (IS_OPER(user)))
+		{
+			/* Display user's current mode string */
+			user->WriteServ("221 %s :+%s",targetuser->nick,targetuser->FormatModes());
+			if (IS_OPER(targetuser))
+				user->WriteServ("008 %s +%s :Server notice mask", targetuser->nick, targetuser->FormatNoticeMasks());
+			return;
+		}
+		else
+		{
+			user->WriteServ("502 %s :Can't change mode for other users", user->nick);
+			return;
+		}
 	}
 
 	/* No such nick/channel */
@@ -276,35 +280,87 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 	chanrec* targetchannel = ServerInstance->FindChan(parameters[0]);
 	userrec* targetuser  = ServerInstance->FindNick(parameters[0]);
 
-	ServerInstance->Log(DEBUG,"ModeParser::Process start");
+	LastParse.clear();
 
 	/* Special case for displaying the list for listmodes,
 	 * e.g. MODE #chan b, or MODE #chan +b without a parameter
 	 */
 	if ((targetchannel) && (pcnt == 2))
 	{
-		ServerInstance->Log(DEBUG,"Spool list");
 		const char* mode = parameters[1];
-		if (*mode == '+')
-			mode++;
-		unsigned char handler_id = ((*mode) - 65) | MASK_CHANNEL;
-		ModeHandler* mh = modehandlers[handler_id];
-		if ((mh) && (mh->IsListMode()))
+		int nonlistmodes_found = 0;
+		bool sent[256];
+
+		mask = MASK_CHANNEL;
+
+		memset(&sent, 0, 256);
+		
+		while (mode && *mode)
 		{
-			mh->DisplayList(user, targetchannel);
-			return;
+			unsigned char mletter = *mode;
+
+			if (*mode == '+')
+			{
+				mode++;
+				continue;
+			}
+
+			/* Ensure the user doesnt request the same mode twice,
+			 * so they cant flood themselves off out of idiocy.
+			 */
+			if (!sent[mletter])
+			{
+				sent[mletter] = true;
+			}
+			else
+			{
+				mode++;
+				continue;
+			}
+
+			ModeHandler *mh = this->FindMode(*mode, MODETYPE_CHANNEL);
+			bool display = true;
+
+			if ((mh) && (mh->IsListMode()))
+			{
+				if (ServerInstance->Config->HideModeLists[mletter] && (targetchannel->GetStatus(user) < STATUS_HOP))
+				{
+					user->WriteServ("482 %s %s :Only half-operators and above may view the +%c list",user->nick, targetchannel->name, *mode++);
+					continue;
+				}
+
+				/** See below for a description of what craq this is :D
+				 */
+				unsigned char handler_id = (*mode - 65) | mask;
+
+				for(ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
+				{
+					std::string dummyparam;
+					
+					if (!((*watchers)->BeforeMode(user, NULL, targetchannel, dummyparam, true, MODETYPE_CHANNEL)))
+						display = false;
+				}
+
+				if (display)
+					mh->DisplayList(user, targetchannel);
+			}
+			else
+				nonlistmodes_found++;
+
+			mode++;
 		}
+
+		/* We didnt have any modes that were non-list, we can return here */
+		if (!nonlistmodes_found)
+			return;
 	}
 
 	if (pcnt == 1)
 	{
-		ServerInstance->Log(DEBUG,"Mode list request");
 		this->DisplayCurrentModes(user, targetuser, targetchannel, parameters[0]);
 	}
 	else if (pcnt > 1)
 	{
-		ServerInstance->Log(DEBUG,"More than one parameter");
-
 		if (targetchannel)
 		{
 			type = MODETYPE_CHANNEL;
@@ -317,17 +373,23 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 			if ((IS_LOCAL(user)) && (targetchannel->GetStatus(user) < STATUS_HOP))
 			{
 				/* We don't have halfop */
-				ServerInstance->Log(DEBUG,"The user is not a halfop or above, checking other reasons for being able to set the modes");
+				int MOD_RESULT = 0;
+				FOREACH_RESULT(I_OnAccessCheck,OnAccessCheck(user, NULL, targetchannel, AC_GENERAL_MODE));
+				if (MOD_RESULT == ACR_DENY)
+					return;
 
-				/* Are we a uline or is it a servermode? */
-				if ((!ServerInstance->ULine(user->server)) && (!servermode))
+				if (MOD_RESULT == ACR_DEFAULT)
 				{
-					/* Not enough permission:
-					 * NOT a uline and NOT a servermode,
-					 * OR, NOT halfop or above.
-					 */
-					user->WriteServ("482 %s %s :You're not a channel (half)operator",user->nick, targetchannel->name);
-					return;
+					/* Are we a uline or is it a servermode? */
+					if ((!ServerInstance->ULine(user->server)) && (!servermode))
+					{
+						/* Not enough permission:
+						 * NOT a uline and NOT a servermode,
+						 * OR, NOT halfop or above.
+						 */
+						user->WriteServ("482 %s %s :You're not a channel (half)operator",user->nick, targetchannel->name);
+						return;
+					}
 				}
 			}
 		}
@@ -335,6 +397,11 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 		{
 			type = MODETYPE_USER;
 			mask = MASK_USER;
+			if ((user != targetuser) && (!ServerInstance->ULine(user->server)))
+			{
+				user->WriteServ("502 %s :Can't change mode for other users", user->nick);
+				return;
+			}
 		}
 		else
 		{
@@ -344,19 +411,23 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 		}
 
 		std::string mode_sequence = parameters[1];
-		std::string parameter = "";
+		std::string parameter;
 		std::ostringstream parameter_list;
-		std::string output_sequence = "";
+		std::string output_sequence;
 		bool adding = true, state_change = false;
 		unsigned char handler_id = 0;
 		int parameter_counter = 2; /* Index of first parameter */
+		int parameter_count = 0;
+		bool last_successful_state_change = false;
+
+		/* A mode sequence that doesnt start with + or -. Assume +. - Thanks for the suggestion spike (bug#132) */
+		if ((*mode_sequence.begin() != '+') && (*mode_sequence.begin() != '-'))
+			mode_sequence.insert(0, "+");
 
 		for (std::string::const_iterator letter = mode_sequence.begin(); letter != mode_sequence.end(); letter++)
 		{
 			unsigned char modechar = *letter;
 
-			ServerInstance->Log(DEBUG,"Process letter %c", modechar);
-
 			switch (modechar)
 			{
 				/* NB:
@@ -373,12 +444,16 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 					if ((!adding) || (!output_sequence.length()))
 						state_change = true;
 					adding = true;
+					if (!output_sequence.length())
+						last_successful_state_change = false;
 					continue;
 				break;
 				case '-':
 					if ((adding) || (!output_sequence.length()))
 						state_change = true;
 					adding = false;
+					if (!output_sequence.length())
+						last_successful_state_change = true;
 					continue;
 				break;
 				default:
@@ -398,12 +473,7 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 					{
 						bool abort = false;
 
-						for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
-						{
-							if ((*watchers)->BeforeMode(user, targetuser, targetchannel, parameter, adding, type) == MODEACTION_DENY)
-								abort = true;
-						}
-						if ((modehandlers[handler_id]->GetModeType() == type) && (!abort))
+						if (modehandlers[handler_id]->GetModeType() == type)
 						{
 							if (modehandlers[handler_id]->GetNumParams(adding))
 							{
@@ -413,26 +483,66 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 									parameter = parameters[parameter_counter++];
 
 									/* Yerk, invalid! */
-									if ((parameter.rfind(':') != std::string::npos) || (parameter.rfind(' ') != std::string::npos))
-										parameter = "";
+									if ((parameter.find(':') == 0) || (parameter.rfind(' ') != std::string::npos))
+										parameter.clear();
 								}
 								else
 								{
 									/* No parameter, continue to the next mode */
 									continue;
 								}
+
+								bool had_parameter = !parameter.empty();
+								
+								for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
+								{
+									if ((*watchers)->BeforeMode(user, targetuser, targetchannel, parameter, adding, type) == false)
+									{
+										abort = true;
+										break;
+									}
+									/* A module whacked the parameter completely, and there was one. abort. */
+									if ((had_parameter) && (parameter.empty()))
+									{
+										abort = true;
+										break;
+									}
+								}
+
+								if (abort)
+									continue;
+							}
+							else
+							{
+								/* Fix by brain: mode watchers not being called for parameterless modes */
+								for (ModeWatchIter watchers = modewatchers[handler_id].begin(); watchers != modewatchers[handler_id].end(); watchers++)
+								{
+									if ((*watchers)->BeforeMode(user, targetuser, targetchannel, parameter, adding, type) == false)
+									{
+										abort = true;
+										break;
+									}
+								}
+
+								if (abort)
+									continue;
 							}
 
 							/* It's an oper only mode, check if theyre an oper. If they arent,
 							 * eat any parameter that  came with the mode, and continue to next
 							 */
-							if ((IS_LOCAL(user)) && (modehandlers[handler_id]->NeedsOper()) && (!*user->oper))
+							if ((IS_LOCAL(user)) && (modehandlers[handler_id]->NeedsOper()) && (!IS_OPER(user)))
+							{
+								user->WriteServ("481 %s :Permission Denied - Only IRC operators may %sset %s mode %c", user->nick,
+										adding ? "" : "un", type == MODETYPE_CHANNEL ? "channel" : "user",
+										modehandlers[handler_id]->GetModeChar());
 								continue;
+							}
 
 							/* Call the handler for the mode */
 							ModeAction ma = modehandlers[handler_id]->OnModeChange(user, targetuser, targetchannel, parameter, adding);
 
-							if ((modehandlers[handler_id]->GetNumParams(adding)) && (parameter == ""))
+							if ((modehandlers[handler_id]->GetNumParams(adding)) && (parameter.empty()))
 							{
 								/* The handler nuked the parameter and they are supposed to have one.
 								 * We CANT continue now, even if they actually returned MODEACTION_ALLOW,
@@ -445,15 +555,20 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 							{
 								/* We're about to output a valid mode letter - was there previously a pending state-change? */
 								if (state_change)
-									output_sequence.append(adding ? "+" : "-");
+								{
+									if (adding != last_successful_state_change)
+										output_sequence.append(adding ? "+" : "-");
+									last_successful_state_change = adding;
+								}
 								
 								/* Add the mode letter */
 								output_sequence.push_back(modechar);
 
 								/* Is there a valid parameter for this mode? If so add it to the parameter list */
-								if ((modehandlers[handler_id]->GetNumParams(adding)) && (parameter != ""))
+								if ((modehandlers[handler_id]->GetNumParams(adding)) && (!parameter.empty()))
 								{
 									parameter_list << " " << parameter;
+									parameter_count++;
 									/* Does this mode have a prefix? */
 									if (modehandlers[handler_id]->GetPrefix() && targetchannel)
 									{
@@ -470,6 +585,14 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 
 								/* Reset the state change flag */
 								state_change = false;
+
+								if ((output_sequence.length() + parameter_list.str().length() > 450) || (output_sequence.length() > 100)
+										|| (parameter_count > MAXMODES))
+								{
+									/* We cant have a mode sequence this long */
+									letter = mode_sequence.end() - 1;
+									continue;
+								}
 							}
 						}
 					}
@@ -481,47 +604,49 @@ void ModeParser::Process(const char** parameters, int pcnt, userrec *user, bool
 				break;
 			}
 		}
+
 		/* Was there at least one valid mode in the sequence? */
-		if (output_sequence != "")
+		if (!output_sequence.empty())
 		{
 			if (servermode)
 			{
 				if (type == MODETYPE_CHANNEL)
 				{
 					targetchannel->WriteChannelWithServ(ServerInstance->Config->ServerName, "MODE %s %s%s", targetchannel->name, output_sequence.c_str(), parameter_list.str().c_str());
+					this->LastParse = targetchannel->name;
 				}
 				else
 				{
-					targetuser->WriteServ("MODE %s %s",targetuser->nick,output_sequence.c_str());
+					targetuser->WriteServ("MODE %s %s%s",targetuser->nick,output_sequence.c_str(), parameter_list.str().c_str());
+					this->LastParse = targetuser->nick;
 				}
 			}
 			else
 			{
 				if (type == MODETYPE_CHANNEL)
 				{
-					ServerInstance->Log(DEBUG,"Write output sequence and parameters to channel: %s %s%s",targetchannel->name,output_sequence.c_str(),parameter_list.str().c_str());
 					targetchannel->WriteChannel(user,"MODE %s %s%s",targetchannel->name,output_sequence.c_str(),parameter_list.str().c_str());
 					FOREACH_MOD(I_OnMode,OnMode(user, targetchannel, TYPE_CHANNEL, output_sequence + parameter_list.str()));
+					this->LastParse = targetchannel->name;
 				}
 				else
 				{
-					user->WriteTo(targetuser,"MODE %s %s",targetuser->nick,output_sequence.c_str());
-					FOREACH_MOD(I_OnMode,OnMode(user, targetuser, TYPE_USER, output_sequence));
+					user->WriteTo(targetuser,"MODE %s %s%s",targetuser->nick,output_sequence.c_str(), parameter_list.str().c_str());
+					FOREACH_MOD(I_OnMode,OnMode(user, targetuser, TYPE_USER, output_sequence + parameter_list.str()));
+					this->LastParse = targetuser->nick;
 				}
 			}
+
+			LastParse.append(" ");
+			LastParse.append(output_sequence);
+			LastParse.append(parameter_list.str());
 		}
 	}
 }
 
-
-void cmd_mode::Handle (const char** parameters, int pcnt, userrec *user)
+const std::string& ModeParser::GetLastParse()
 {
-	if (!user)
-		return;
-
-	ServerInstance->Modes->Process(parameters, pcnt, user, false);
-
-	return;
+	return LastParse;
 }
 
 void ModeParser::CleanMask(std::string &mask)
@@ -566,13 +691,14 @@ bool ModeParser::AddMode(ModeHandler* mh, unsigned const char modeletter)
 	 * If they do that, thats their problem, and if i ever EVER see an
 	 * official InspIRCd developer do that, i'll beat them with a paddle!
 	 */
-	if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z'))
+	if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z') || (mh->GetPrefix() > 126))
 		return false;
 
 	/* A mode prefix of ',' is not acceptable, it would fuck up server to server.
 	 * A mode prefix of ':' will fuck up both server to server, and client to server.
+	 * A mode prefix of '#' will mess up /whois and /privmsg
 	 */
-	if ((mh->GetPrefix() == ',') || (mh->GetPrefix() == ':'))
+	if ((mh->GetPrefix() == ',') || (mh->GetPrefix() == ':') || (mh->GetPrefix() == '#'))
 		return false;
 
 	mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
@@ -582,7 +708,41 @@ bool ModeParser::AddMode(ModeHandler* mh, unsigned const char modeletter)
 		return false;
 
 	modehandlers[pos] = mh;
-	ServerInstance->Log(DEBUG,"ModeParser::AddMode: added mode %c",mh->GetModeChar());
+	return true;
+}
+
+bool ModeParser::DelMode(ModeHandler* mh)
+{
+	unsigned char mask = 0;
+	unsigned char pos = 0;
+
+	if ((mh->GetModeChar() < 'A') || (mh->GetModeChar() > 'z'))
+		return false;
+
+	mh->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
+	pos = (mh->GetModeChar()-65) | mask;
+
+	if (!modehandlers[pos])
+		return false;
+
+	switch (mh->GetModeType())
+	{
+		case MODETYPE_USER:
+			for (user_hash::iterator i = ServerInstance->clientlist->begin(); i != ServerInstance->clientlist->end(); i++)
+			{
+				mh->RemoveMode(i->second);
+			}
+		break;
+		case MODETYPE_CHANNEL:
+			for (chan_hash::iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end(); i++)
+			{
+				mh->RemoveMode(i->second);
+			}
+		break;
+	}
+
+	modehandlers[pos] = NULL;
+
 	return true;
 }
 
@@ -623,6 +783,9 @@ std::string ModeParser::ChannelModeList()
 
 	for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 	{
+		if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h'))
+			continue;
+
 		unsigned char pos = (mode-65) | MASK_CHANNEL;
 
 		if (modehandlers[pos])
@@ -639,6 +802,9 @@ std::string ModeParser::ParaModeList()
 
 	for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 	{
+		if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h'))
+			continue;
+
 		unsigned char pos = (mode-65) | MASK_CHANNEL;
 
 		if ((modehandlers[pos]) && (modehandlers[pos]->GetNumParams(true)))
@@ -662,20 +828,102 @@ ModeHandler* ModeParser::FindPrefix(unsigned const char pfxletter)
 	return NULL;
 }
 
-bool ModeParser::PrefixComparison(const prefixtype one, const prefixtype two)
+std::string ModeParser::ModeString(userrec* user, chanrec* channel)
+{
+	std::string types;
+	std::string pars;
+
+	if (!channel || !user)
+		return "";
+
+	for (unsigned char mode = 'A'; mode <= 'z'; mode++)
+	{
+		unsigned char pos = (mode-65) | MASK_CHANNEL;
+		ModeHandler* mh = modehandlers[pos];
+		if ((mh) && (mh->GetNumParams(true)) && (mh->GetNumParams(false)))
+		{
+			ModePair ret;
+			ret = mh->ModeSet(NULL, user, channel, user->nick);
+			if ((ret.first) && (ret.second == user->nick))
+			{
+				pars.append(" ");
+				pars.append(user->nick);
+				types.push_back(mh->GetModeChar());
+			}
+		}
+	}
+
+	return types+pars;
+}
+
+std::string ModeParser::ChanModes()
+{
+	std::string type1;	/* Listmodes EXCEPT those with a prefix */
+	std::string type2;	/* Modes that take a param when adding or removing */
+	std::string type3;	/* Modes that only take a param when adding */
+	std::string type4;	/* Modes that dont take a param */
+
+	for (unsigned char mode = 'A'; mode <= 'z'; mode++)
+	{
+		if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h'))
+			continue;
+
+		unsigned char pos = (mode-65) | MASK_CHANNEL;
+		 /* One parameter when adding */
+		if (modehandlers[pos])
+		{	
+			if (modehandlers[pos]->GetNumParams(true))
+			{
+				if ((modehandlers[pos]->IsListMode()) && (!modehandlers[pos]->GetPrefix()))
+				{
+					type1 += modehandlers[pos]->GetModeChar();
+				}
+				else
+				{
+					/* ... and one parameter when removing */
+					if (modehandlers[pos]->GetNumParams(false))
+					{
+						/* But not a list mode */
+						if (!modehandlers[pos]->GetPrefix())
+						{
+							type2 += modehandlers[pos]->GetModeChar();
+						}
+					}
+					else
+					{
+						/* No parameters when removing */
+						type3 += modehandlers[pos]->GetModeChar();
+					}
+				}
+			}
+			else
+			{
+				type4 += modehandlers[pos]->GetModeChar();
+			}
+		}
+			 
+	}
+
+	return type1 + "," + type2 + "," + type3 + "," + type4;
+}
+
+bool ModeParser::PrefixComparison(prefixtype one, prefixtype two)
 {       
 	return one.second > two.second;
 }
 
 std::string ModeParser::BuildPrefixes()
 {
-	std::string mletters = "";
-	std::string mprefixes = "";
+	std::string mletters;
+	std::string mprefixes;
 	pfxcontainer pfx;
 	std::map<char,char> prefix_to_mode;
 
 	for (unsigned char mode = 'A'; mode <= 'z'; mode++)
 	{
+		if ((!ServerInstance->Config->AllowHalfop) && (mode == 'h'))
+			continue;
+
 		unsigned char pos = (mode-65) | MASK_CHANNEL;
 
 		if ((modehandlers[pos]) && (modehandlers[pos]->GetPrefix()))
@@ -711,7 +959,6 @@ bool ModeParser::AddModeWatcher(ModeWatcher* mw)
 	pos = (mw->GetModeChar()-65) | mask;
 
 	modewatchers[pos].push_back(mw);
-	ServerInstance->Log(DEBUG,"ModeParser::AddModeWatcher: watching mode %c",mw->GetModeChar());
 
 	return true;
 }
@@ -724,7 +971,7 @@ bool ModeParser::DelModeWatcher(ModeWatcher* mw)
 	if (!mw)
 		return false;
 
-	if ((mw->GetModeType() < 'A') || (mw->GetModeType() > 'z'))
+	if ((mw->GetModeChar() < 'A') || (mw->GetModeChar() > 'z'))
 		return false;
 
 	mw->GetModeType() == MODETYPE_USER ? mask = MASK_USER : mask = MASK_CHANNEL;
@@ -733,69 +980,87 @@ bool ModeParser::DelModeWatcher(ModeWatcher* mw)
 	ModeWatchIter a = find(modewatchers[pos].begin(),modewatchers[pos].end(),mw);
 
 	if (a == modewatchers[pos].end())
+	{
 		return false;
+	}
 
 	modewatchers[pos].erase(a);
-	ServerInstance->Log(DEBUG,"ModeParser::DelModeWatcher: stopped watching mode %c",mw->GetModeChar());
 
 	return true;
 }
 
-ModeParser::ModeParser(InspIRCd* Instance) : ServerInstance(Instance)
+/** This default implementation can remove simple user modes
+ */
+void ModeHandler::RemoveMode(userrec* user)
 {
-	/* Clear mode list */
-	memset(modehandlers, 0, sizeof(modehandlers));
-	memset(modewatchers, 0, sizeof(modewatchers));
+	char moderemove[MAXBUF];
+	const char* parameters[] = { user->nick, moderemove };
 
-	/* Initialise the RFC mode letters */
+	if (user->IsModeSet(this->GetModeChar()))
+	{
+		sprintf(moderemove,"-%c",this->GetModeChar());
+		ServerInstance->Parser->CallHandler("MODE", parameters, 2, user);
+	}
+}
 
-	/* Start with channel simple modes, no params */
-	this->AddMode(new ModeChannelSecret(Instance), 's');
-	this->AddMode(new ModeChannelPrivate(Instance), 'p');
-	this->AddMode(new ModeChannelModerated(Instance), 'm');
-	this->AddMode(new ModeChannelTopicOps(Instance), 't');
-	this->AddMode(new ModeChannelNoExternal(Instance), 'n');
-	this->AddMode(new ModeChannelInviteOnly(Instance), 'i');
+/** This default implementation can remove simple channel modes
+ * (no parameters)
+ */
+void ModeHandler::RemoveMode(chanrec* channel)
+{
+	char moderemove[MAXBUF];
+	const char* parameters[] = { channel->name, moderemove };
+
+	if (channel->IsModeSet(this->GetModeChar()))
+	{
+		userrec* n = new userrec(ServerInstance);
 
-	/* Cannel modes with params */
-	this->AddMode(new ModeChannelKey(Instance), 'k');
-	this->AddMode(new ModeChannelLimit(Instance), 'l');
+		sprintf(moderemove,"-%c",this->GetModeChar());
+		n->SetFd(FD_MAGIC_NUMBER);
 
-	/* Channel listmodes */
-	this->AddMode(new ModeChannelBan(Instance), 'b');
-	this->AddMode(new ModeChannelOp(Instance), 'o');
-	this->AddMode(new ModeChannelHalfOp(Instance), 'h');
-	this->AddMode(new ModeChannelVoice(Instance), 'v');
+		ServerInstance->SendMode(parameters, 2, n);
 
-	/* Now for usermodes */
-	this->AddMode(new ModeUserServerNotice(Instance), 's');
-	this->AddMode(new ModeUserWallops(Instance), 'w');
-	this->AddMode(new ModeUserInvisible(Instance), 'i');
-	this->AddMode(new ModeUserOperator(Instance), 'o');
-	this->AddMode(new ModeUserServerNoticeMask(Instance), 'n');
+		delete n;
+	}
 }
 
-bool ModeParser::InsertMode(std::string &output, const char* mode, unsigned short section)
+ModeParser::ModeParser(InspIRCd* Instance) : ServerInstance(Instance)
 {
-	unsigned short currsection = 1;
-	unsigned int pos = output.find("CHANMODES=", 0) + 10; // +10 for the length of "CHANMODES="
-
-	if(section > 4 || section == 0)
+	struct Initializer
 	{
-		ServerInstance->Log(DEBUG, "InsertMode: CHANMODES doesn't have a section %dh :/", section);
-		return false;
-	}
+		char modechar;
+		ModeHandler* handler;
+	};
+
+	Initializer modes[] = {
+		{ 's', new ModeChannelSecret(Instance) },
+		{ 'p', new ModeChannelPrivate(Instance) },
+		{ 'm', new ModeChannelModerated(Instance) },
+		{ 't', new ModeChannelTopicOps(Instance) },
+		{ 'n', new ModeChannelNoExternal(Instance) },
+		{ 'i', new ModeChannelInviteOnly(Instance) },
+		{ 'k', new ModeChannelKey(Instance) },
+		{ 'l', new ModeChannelLimit(Instance) },
+		{ 'b', new ModeChannelBan(Instance) },
+		{ 'o', new ModeChannelOp(Instance) },
+		{ 'h', new ModeChannelHalfOp(Instance) },
+		{ 'v', new ModeChannelVoice(Instance) },
+		{ 's', new ModeUserServerNotice(Instance) },
+		{ 'w', new ModeUserWallops(Instance) },
+		{ 'i', new ModeUserInvisible(Instance) },
+		{ 'o', new ModeUserOperator(Instance) },
+		{ 'n', new ModeUserServerNoticeMask(Instance) },
+		{ 0, NULL }
+	};
 
-	for(; pos < output.size(); pos++)
-	{
-		if(section == currsection)
-			break;
+	/* Clear mode list */
+	memset(modehandlers, 0, sizeof(modehandlers));
+	memset(modewatchers, 0, sizeof(modewatchers));
 
-		if(output[pos] == ',')
-			currsection++;
-	}
+	/* Last parse string */
+	LastParse.clear();
 
-	output.insert(pos, mode);
-	return true;
+	/* Initialise the RFC mode letters */
+	for (int index = 0; modes[index].modechar; index++)
+		this->AddMode(modes[index].handler, modes[index].modechar);
 }
-