Added new API methods:

int Module::OnRawMode(userrec* user, char mode, std::string param, bool adding, int pcnt);
int Module::OnCheckInvite(userrec* user, chanrec* chan);
int Module::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven);
int Module::OnCheckLimit(userrec* user, chanrec* chan);
int Module::OnCheckBan(userrec* user, chanrec* chan);
void Module::OnStats(char symbol);
int Module::OnChangeLocalUserHost(userrec* user, std::string newhost);
int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost);
int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic);


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

6 files changed, 400 insertions, 174 deletions

diff --git a/include/modules.h b/include/modules.h
index b380b6e2f..c9248575f 100644
--- a/include/modules.h
+++ b/include/modules.h
@@ -426,6 +426,62 @@ class Module : public classbase
 	 * Use OnUserConnect for that instead.
 	 */
 	virtual void OnUserRegister(userrec* user);
+
+	/** Called whenever a mode character is processed.
+	 * Return 1 from this function to block the mode character from being processed entirely,
+	 * so that you may perform your own code instead. Note that this method allows you to override
+	 * modes defined by other modes, but this is NOT RECOMMENDED!
+	 */
+	virtual int OnRawMode(userrec* user, char mode, std::string param, bool adding, int pcnt);
+
+	/** Called whenever a user joins a channel, to determine if invite checks should go ahead or not.
+	 * This method will always be called for each join, wether or not the channel is actually +i, and
+	 * determines the outcome of an if statement around the whole section of invite checking code.
+	 * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+	 */
+	virtual int OnCheckInvite(userrec* user, chanrec* chan);
+
+        /** Called whenever a user joins a channel, to determine if key checks should go ahead or not.
+         * This method will always be called for each join, wether or not the channel is actually +k, and
+         * determines the outcome of an if statement around the whole section of key checking code.
+	 * if the user specified no key, the keygiven string will be a valid but empty value.
+         * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+         */
+	virtual int OnCheckKey(userrec* user, chanrec* chan, std::string keygiven);
+
+        /** Called whenever a user joins a channel, to determine if channel limit checks should go ahead or not.
+         * This method will always be called for each join, wether or not the channel is actually +l, and
+         * determines the outcome of an if statement around the whole section of channel limit checking code.
+         * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+         */
+	virtual int OnCheckLimit(userrec* user, chanrec* chan);
+
+        /** Called whenever a user joins a channel, to determine if banlist checks should go ahead or not.
+         * This method will always be called for each join, wether or not the user actually matches a channel ban, and
+         * determines the outcome of an if statement around the whole section of ban checking code.
+         * return 1 to explicitly allow the join to go ahead or 0 to ignore the event.
+         */
+	virtual int OnCheckBan(userrec* user, chanrec* chan);
+
+	/** Called on all /STATS commands
+	 * This method is triggered for all /STATS use, including stats symbols handled by the core.
+	 */
+	virtual void OnStats(char symbol);
+
+	/** Called whenever a change of a local users displayed host is attempted.
+	 * Return 1 to deny the host change, or 0 to allow it.
+	 */
+	virtual int OnChangeLocalUserHost(userrec* user, std::string newhost);
+
+	/** Called whenever a change of a local users GECOS (fullname field) is attempted.
+	 * return 1 to deny the name change, or 0 to allow it.
+	 */
+	virtual int OnChangeLocalUserGECOS(userrec* user, std::string newhost); 
+
+	/** Called whenever a topic is changed by a local user.
+	 * Return 1 to deny the topic change, or 0 to allow it.
+	 */
+	virtual int OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic);
 };
 
 
diff --git a/src/commands.cpp b/src/commands.cpp
index 635000974..3a30a3972 100644
--- a/src/commands.cpp
+++ b/src/commands.cpp
@@ -542,14 +542,22 @@ void handle_topic(char **parameters, int pcnt, userrec *user)
 					WriteServ(user->fd,"482 %s %s :You must be at least a half-operator to change modes on this channel", user->nick, Ptr->name);
 					return;
 				}
-				
+
 				char topic[MAXBUF];
 				strlcpy(topic,parameters[1],MAXBUF);
 				if (strlen(topic)>MAXTOPIC)
 				{
 					topic[MAXTOPIC-1] = '\0';
 				}
-					
+
+                                if (!strcasecmp(user->server,ServerName))
+                                {
+                                        int MOD_RESULT = 0;
+                                        FOREACH_RESULT(OnLocalTopicChange(user,Ptr,topic));
+                                        if (MOD_RESULT)
+                                                return;
+                                }
+
 				strlcpy(Ptr->topic,topic,MAXBUF);
 				strlcpy(Ptr->setby,user->nick,NICKMAX);
 				Ptr->topicset = TIME;
@@ -1301,6 +1309,8 @@ void handle_stats(char **parameters, int pcnt, userrec *user)
 	}
 
 
+	FOREACH_MOD OnStats(*parameters[0]);
+
 	if (!strcasecmp(parameters[0],"c"))
 	{
 		for (int i = 0; i < ConfValueEnum("link",&config_f); i++)
diff --git a/src/inspircd.cpp b/src/inspircd.cpp
index 3e70d27f5..a4fcdf749 100644
--- a/src/inspircd.cpp
+++ b/src/inspircd.cpp
@@ -1527,72 +1527,86 @@ chanrec* add_channel(userrec *user, const char* cn, const char* key, bool overri
 				if (!MOD_RESULT) 
 				{
 					log(DEBUG,"add_channel: checking key, invite, etc");
-					if (strcmp(Ptr->key,""))
+					int MOD_RESULT = 0;
+					FOREACH_RESULT(OnCheckKey(user, Ptr, key ? key : ""));
+					if (MOD_RESULT == 0)
 					{
-						log(DEBUG,"add_channel: %s has key %s",Ptr->name,Ptr->key);
-						if (!key)
+						if (strcmp(Ptr->key,""))
 						{
-							log(DEBUG,"add_channel: no key given in JOIN");
-							WriteServ(user->fd,"475 %s %s :Cannot join channel (Requires key)",user->nick, Ptr->name);
-							return NULL;
-						}
-						else
-						{
-							log(DEBUG,"key at %p is %s",key,key);
-							if (strcasecmp(key,Ptr->key))
+							log(DEBUG,"add_channel: %s has key %s",Ptr->name,Ptr->key);
+							if (!key)
 							{
-								log(DEBUG,"add_channel: bad key given in JOIN");
-								WriteServ(user->fd,"475 %s %s :Cannot join channel (Incorrect key)",user->nick, Ptr->name);
+								log(DEBUG,"add_channel: no key given in JOIN");
+								WriteServ(user->fd,"475 %s %s :Cannot join channel (Requires key)",user->nick, Ptr->name);
 								return NULL;
 							}
+							else
+							{
+								if (strcasecmp(key,Ptr->key))
+								{
+									log(DEBUG,"add_channel: bad key given in JOIN");
+									WriteServ(user->fd,"475 %s %s :Cannot join channel (Incorrect key)",user->nick, Ptr->name);
+									return NULL;
+								}
+							}
 						}
+						log(DEBUG,"add_channel: no key");
 					}
-					log(DEBUG,"add_channel: no key");
-		
-					if (Ptr->inviteonly)
+					MOD_RESULT = 0;
+					FOREACH_RESULT(OnCheckInvite(user, Ptr));
+					if (MOD_RESULT == 0)
 					{
-						log(DEBUG,"add_channel: channel is +i");
-						if (user->IsInvited(Ptr->name))
+						if (Ptr->inviteonly)
 						{
-							/* user was invited to channel */
-							/* there may be an optional channel NOTICE here */
-						}
-						else
-						{
-							WriteServ(user->fd,"473 %s %s :Cannot join channel (Invite only)",user->nick, Ptr->name);
-							return NULL;
+							log(DEBUG,"add_channel: channel is +i");
+							if (user->IsInvited(Ptr->name))
+							{
+								/* user was invited to channel */
+								/* there may be an optional channel NOTICE here */
+							}
+							else
+							{
+								WriteServ(user->fd,"473 %s %s :Cannot join channel (Invite only)",user->nick, Ptr->name);
+								return NULL;
+							}
 						}
+						log(DEBUG,"add_channel: channel is not +i");
 					}
-					log(DEBUG,"add_channel: channel is not +i");
-		
-					if (Ptr->limit)
+					MOD_RESULT = 0;
+					FOREACH_RESULT(OnCheckLimit(user, Ptr));
+					if (MOD_RESULT == 0)
 					{
-						if (usercount(Ptr) >= Ptr->limit)
+						if (Ptr->limit)
 						{
-							WriteServ(user->fd,"471 %s %s :Cannot join channel (Channel is full)",user->nick, Ptr->name);
-							return NULL;
+							if (usercount(Ptr) >= Ptr->limit)
+							{
+								WriteServ(user->fd,"471 %s %s :Cannot join channel (Channel is full)",user->nick, Ptr->name);
+								return NULL;
+							}
 						}
 					}
-					
 					log(DEBUG,"add_channel: about to walk banlist");
-		
-					/* check user against the channel banlist */
-					if (Ptr)
+					MOD_RESULT = 0;
+					FOREACH_RESULT(OnCheckBan(user, Ptr));
+					if (MOD_RESULT == 0)
 					{
-						if (Ptr->bans.size())
+						/* check user against the channel banlist */
+						if (Ptr)
 						{
-							for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
+							if (Ptr->bans.size())
 							{
-								if (match(user->GetFullHost(),i->data))
+								for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
 								{
-									WriteServ(user->fd,"474 %s %s :Cannot join channel (You're banned)",user->nick, Ptr->name);
-									return NULL;
+									if (match(user->GetFullHost(),i->data))
+									{
+										WriteServ(user->fd,"474 %s %s :Cannot join channel (You're banned)",user->nick, Ptr->name);
+										return NULL;
+									}
 								}
 							}
 						}
+						log(DEBUG,"add_channel: bans checked");
 					}
-					
-					log(DEBUG,"add_channel: bans checked");
 				
 				}
 				
diff --git a/src/message.cpp b/src/message.cpp
index c2ac34d88..ba1590f8e 100644
--- a/src/message.cpp
+++ b/src/message.cpp
@@ -57,6 +57,8 @@ extern int MODCOUNT;
 extern std::vector<Module*> modules;
 extern std::vector<ircd_module*> factory;
 
+extern char ServerName[MAXBUF];
+
 extern time_t TIME;
 
 extern FILE *log_file;
@@ -248,6 +250,13 @@ bool hasumode(userrec* user, char mode)
 
 void ChangeName(userrec* user, const char* gecos)
 {
+	if (!strcasecmp(user->server,ServerName))
+	{
+		int MOD_RESULT = 0;
+		FOREACH_RESULT(OnChangeLocalUserGECOS(user,gecos));
+		if (MOD_RESULT)
+			return;
+	}
 	strlcpy(user->fullname,gecos,MAXBUF);
 	char buffer[MAXBUF];
 	snprintf(buffer,MAXBUF,"a %s :%s",user->nick,gecos);
@@ -256,6 +265,13 @@ void ChangeName(userrec* user, const char* gecos)
 
 void ChangeDisplayedHost(userrec* user, const char* host)
 {
+        if (!strcasecmp(user->server,ServerName))
+        {
+                int MOD_RESULT = 0;
+                FOREACH_RESULT(OnChangeLocalUserHost(user,host));
+                if (MOD_RESULT)
+                        return;
+        }
 	strlcpy(user->dhost,host,160);
 	char buffer[MAXBUF];
 	snprintf(buffer,MAXBUF,"b %s %s",user->nick,host);
diff --git a/src/mode.cpp b/src/mode.cpp
index 467b3d09b..2b19be1cc 100644
--- a/src/mode.cpp
+++ b/src/mode.cpp
@@ -556,6 +556,7 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 
 		{
 			log(DEBUG,"process_modes: modechar: %c",modelist[ptr]);
+
 			char modechar = modelist[ptr];
 			switch (modelist[ptr])
 			{
@@ -596,13 +597,25 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 					log(DEBUG,"Enough parameters left");
 					if (mdir == 1)
 					{
-						log(DEBUG,"calling give_ops");
-						r = give_ops(user,parameters[param++],chan,status);
+						MOD_RESULT = 0;
+						FOREACH_RESULT(OnRawMode(user, 'o', parameters[param], true, 1));
+						if (!MOD_RESULT)
+						{
+							log(DEBUG,"calling give_ops");
+							r = give_ops(user,parameters[param++],chan,status);
+						}
+						else param++;
 					}
 					else
 					{
-						log(DEBUG,"calling take_ops");
-						r = take_ops(user,parameters[param++],chan,status);
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'o', parameters[param], false, 1));
+                                                if (!MOD_RESULT)
+                                                {
+							log(DEBUG,"calling take_ops");
+							r = take_ops(user,parameters[param++],chan,status);
+						}
+						else param++;
 					}
 					if (r)
 					{
@@ -615,11 +628,23 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 					if (((param >= pcnt)) || (!AllowHalfop)) break;
 					if (mdir == 1)
 					{
-						r = give_hops(user,parameters[param++],chan,status);
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'h', parameters[param], true, 1));
+                                                if (!MOD_RESULT)
+                                                {
+							r = give_hops(user,parameters[param++],chan,status);
+						}
+						else param++;
 					}
 					else
 					{
-						r = take_hops(user,parameters[param++],chan,status);
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'h', parameters[param], false, 1));
+                                                if (!MOD_RESULT)
+                                                {
+							r = take_hops(user,parameters[param++],chan,status);
+						}
+						else param++;
 					}
 					if (r)
 					{
@@ -633,11 +658,23 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 					if ((param >= pcnt)) break;
 					if (mdir == 1)
 					{
-						r = give_voice(user,parameters[param++],chan,status);
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'v', parameters[param], true, 1));
+                                                if (!MOD_RESULT)
+                                                {
+							r = give_voice(user,parameters[param++],chan,status);
+						}
+						else param++;
 					}
 					else
 					{
-						r = take_voice(user,parameters[param++],chan,status);
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'v', parameters[param], false, 1));
+                                                if (!MOD_RESULT)
+                                                {
+							r = take_voice(user,parameters[param++],chan,status);
+						}
+						else param++;
 					}
 					if (r)
 					{
@@ -650,11 +687,23 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 					if ((param >= pcnt)) break;
 					if (mdir == 1)
 					{
-						r = add_ban(user,parameters[param++],chan,status);
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'b', parameters[param], true, 1));
+                                                if (!MOD_RESULT)
+                                                {
+							r = add_ban(user,parameters[param++],chan,status);
+						}
+						else param++;
 					}
 					else
 					{
-						r = take_ban(user,parameters[param++],chan,status);
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'b', parameters[param], false, 1));
+                                                if (!MOD_RESULT)
+                                                {
+							r = take_ban(user,parameters[param++],chan,status);
+						}
+						else param++;
 					}
 					if (r)
 					{
@@ -675,15 +724,21 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 						
 						if (!strcmp(chan->key,""))
 						{
-							strcat(outlist,"k");
-							char key[MAXBUF];
-							strlcpy(key,parameters[param++],MAXBUF);
-							if (strlen(key)>32) {
-								key[31] = '\0';
+							MOD_RESULT = 0;
+							FOREACH_RESULT(OnRawMode(user, 'k', parameters[param], true, 1));
+							if (!MOD_RESULT)
+							{
+								strcat(outlist,"k");
+								char key[MAXBUF];
+								strlcpy(key,parameters[param++],MAXBUF);
+								if (strlen(key)>32) {
+									key[31] = '\0';
+								}
+								strlcpy(outpars[pc++],key,MAXBUF);
+								strlcpy(chan->key,key,MAXBUF);
+								k_set = true;
 							}
-							strlcpy(outpars[pc++],key,MAXBUF);
-							strlcpy(chan->key,key,MAXBUF);
-							k_set = true;
+							else param++;
 						}
 					}
 					else
@@ -691,27 +746,39 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 						/* checks on -k are case sensitive and only accurate to the
   						   first 32 characters */
 						char key[MAXBUF];
-						strlcpy(key,parameters[param++],MAXBUF);
-						if (strlen(key)>32) {
-							key[31] = '\0';
-						}
-						/* only allow -k if correct key given */
-						if (!strcmp(chan->key,key))
+						MOD_RESULT = 0;
+						FOREACH_RESULT(OnRawMode(user, 'k', parameters[param], false, 1));
+						if (!MOD_RESULT)
 						{
-							strlcat(outlist,"k",MAXBUF);
-							strlcpy(chan->key,"",MAXBUF);
-							strlcpy(outpars[pc++],key,MAXBUF);
+							strlcpy(key,parameters[param++],MAXBUF);
+							if (strlen(key)>32)
+							{
+								key[31] = '\0';
+							}
+							/* only allow -k if correct key given */
+							if (!strcmp(chan->key,key))
+							{
+								strlcat(outlist,"k",MAXBUF);
+								strlcpy(chan->key,"",MAXBUF);
+								strlcpy(outpars[pc++],key,MAXBUF);
+							}
 						}
+						else param++;
 					}
 				break;
 				
 				case 'l':
 					if (mdir == 0)
 					{
-						if (chan->limit)
-						{
-							strcat(outlist,"l");
-							chan->limit = 0;
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'l', "", false, 0));
+                                                if (!MOD_RESULT)
+                                                {
+							if (chan->limit)
+							{
+								strcat(outlist,"l");
+								chan->limit = 0;
+							}
 						}
 					}
 					
@@ -736,12 +803,18 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 
 						if (invalid)
 							break;
-						
-						chan->limit = atoi(parameters[param]);
-						
-						// reported by mech: large values cause underflow
-						if (chan->limit < 0)
-							chan->limit = 0x7FFFFF;
+
+                                                MOD_RESULT = 0;
+                                                FOREACH_RESULT(OnRawMode(user, 'l', parameters[param], true, 1));
+                                                if (!MOD_RESULT)
+                                                {
+	
+							chan->limit = atoi(parameters[param]);
+							
+							// reported by mech: large values cause underflow
+							if (chan->limit < 0)
+								chan->limit = 0x7FFFFF;
+						}
 							
 						if (chan->limit)
 						{
@@ -753,75 +826,105 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
 				break;
 				
 				case 'i':
-					if (chan->inviteonly != mdir)
-					{
-						strlcat(outlist,"i",MAXBUF);
+                                        MOD_RESULT = 0;
+                                        FOREACH_RESULT(OnRawMode(user, 'i', "", mdir, 0));
+                                        if (!MOD_RESULT)
+                                        {
+						if (chan->inviteonly != mdir)
+						{
+							strlcat(outlist,"i",MAXBUF);
+						}
+						chan->inviteonly = mdir;
 					}
-					chan->inviteonly = mdir;
 				break;
 				
 				case 't':
-					if (chan->topiclock != mdir)
-					{
-						strlcat(outlist,"t",MAXBUF);
+                                        MOD_RESULT = 0;
+                                        FOREACH_RESULT(OnRawMode(user, 't', "", mdir, 0));
+                                        if (!MOD_RESULT)
+                                        {
+						if (chan->topiclock != mdir)
+						{
+							strlcat(outlist,"t",MAXBUF);
+						}
+						chan->topiclock = mdir;
 					}
-					chan->topiclock = mdir;
 				break;
 				
 				case 'n':
-					if (chan->noexternal != mdir)
-					{
-						strlcat(outlist,"n",MAXBUF);
+                                        MOD_RESULT = 0;
+                                        FOREACH_RESULT(OnRawMode(user, 'n', "", mdir, 0));
+                                        if (!MOD_RESULT)
+                                        {
+						if (chan->noexternal != mdir)
+						{
+							strlcat(outlist,"n",MAXBUF);
+						}
+						chan->noexternal = mdir;
 					}
-					chan->noexternal = mdir;
 				break;
 				
 				case 'm':
-					if (chan->moderated != mdir)
-					{
-						strlcat(outlist,"m",MAXBUF);
+                                        MOD_RESULT = 0;
+                                        FOREACH_RESULT(OnRawMode(user, 'm', "", mdir, 0));
+                                        if (!MOD_RESULT)
+                                        {
+						if (chan->moderated != mdir)
+						{
+							strlcat(outlist,"m",MAXBUF);
+						}
+						chan->moderated = mdir;
 					}
-					chan->moderated = mdir;
 				break;
 				
 				case 's':
-					if (chan->secret != mdir)
-					{
-						strcat(outlist,"s");
-						if (chan->c_private)
+                                        MOD_RESULT = 0;
+                                        FOREACH_RESULT(OnRawMode(user, 's', "", mdir, 0));
+                                        if (!MOD_RESULT)
+                                        {
+						if (chan->secret != mdir)
 						{
-							chan->c_private = 0;
-							if (mdir)
-							{
-								strlcat(outlist,"-p+",MAXBUF);
-							}
-							else
+							strcat(outlist,"s");
+							if (chan->c_private)
 							{
-								strlcat(outlist,"+p-",MAXBUF);
+								chan->c_private = 0;
+								if (mdir)
+								{
+									strlcat(outlist,"-p+",MAXBUF);
+								}
+								else
+								{
+									strlcat(outlist,"+p-",MAXBUF);
+								}
 							}
 						}
+						chan->secret = mdir;
 					}
-					chan->secret = mdir;
 				break;
 				
 				case 'p':
-					if (chan->c_private != mdir)
-					{
-						strlcat(outlist,"p",MAXBUF);
-						if (chan->secret)
+                                        MOD_RESULT = 0;
+                                        FOREACH_RESULT(OnRawMode(user, 'p', "", mdir, 0));
+                                        if (!MOD_RESULT)
+                                        {
+						if (chan->c_private != mdir)
 						{
-							chan->secret = 0;
-							if (mdir)
-							{
-								strlcat(outlist,"-s+",MAXBUF);
-							}
-							else
+							strlcat(outlist,"p",MAXBUF);
+							if (chan->secret)
 							{
-								strlcat(outlist,"+s-",MAXBUF);
+								chan->secret = 0;
+								if (mdir)
+								{
+									strlcat(outlist,"-s+",MAXBUF);
+								}
+								else
+								{
+									strlcat(outlist,"+s-",MAXBUF);
+								}
 							}
 						}
+						chan->c_private = mdir;
 					}
-					chan->c_private = mdir;
 				break;
 				
 				default:
@@ -861,56 +964,69 @@ void process_modes(char **parameters,userrec* user,chanrec *chan,int status, int
   								param++;
   							}
   						}
-  						for (int i = 0; i <= MODCOUNT; i++)
-						{
-							if (!handled)
+
+						// BIG ASS IDIOTIC CODER WARNING!
+						// Using OnRawMode on another modules mode's behavour 
+						// will confuse the crap out of admins! just because you CAN
+						// do it, doesnt mean you SHOULD!
+	                                        MOD_RESULT = 0;
+						std::string para = "";
+						if (p.size())
+							para = p[0];
+        	                                FOREACH_RESULT(OnRawMode(user, modechar, para, mdir, pcnt));
+                	                        if (!MOD_RESULT)
+                        	                {
+  							for (int i = 0; i <= MODCOUNT; i++)
 							{
-								int t = modules[i]->OnExtendedMode(user,chan,modechar,MT_CHANNEL,mdir,p);
-								if (t != 0)
+								if (!handled)
 								{
-									log(DEBUG,"OnExtendedMode returned nonzero for a module");
-									char app[] = {modechar, 0};
-									if (ModeIsListMode(modechar,MT_CHANNEL))
+									int t = modules[i]->OnExtendedMode(user,chan,modechar,MT_CHANNEL,mdir,p);
+									if (t != 0)
 									{
-										if (t == -1)
-										{
-											pc++;
-										}
-										else
+										log(DEBUG,"OnExtendedMode returned nonzero for a module");
+										char app[] = {modechar, 0};
+										if (ModeIsListMode(modechar,MT_CHANNEL))
 										{
-											if (ptr>0)
+											if (t == -1)
 											{
-												strlcat(outlist, app,MAXBUF);
+												pc++;
+											}
+											else
+											{
+												if (ptr>0)
+												{
+													strlcat(outlist, app,MAXBUF);
+												}
+												strlcpy(outpars[pc++],parameters[param++],MAXBUF);
 											}
-											strlcpy(outpars[pc++],parameters[param++],MAXBUF);
 										}
-									}
-									else
-									{
-										if (ptr>0)
+										else
 										{
-											if ((modelist[ptr-1] == '+') || (modelist[ptr-1] == '-'))
+											if (ptr>0)
 											{
-												strlcat(outlist, app,MAXBUF);
+												if ((modelist[ptr-1] == '+') || (modelist[ptr-1] == '-'))
+												{
+													strlcat(outlist, app,MAXBUF);
+												}
+												else if (!strchr(outlist,modechar))
+												{
+													strlcat(outlist, app,MAXBUF);
+												}
 											}
-											else if (!strchr(outlist,modechar))
+											chan->SetCustomMode(modechar,mdir);
+											// include parameters in output if mode has them
+											if ((ModeDefinedOn(modechar,MT_CHANNEL)>0) && (mdir))
 											{
-												strlcat(outlist, app,MAXBUF);
+												chan->SetCustomModeParam(modelist[ptr],parameters[param],mdir);
+												strlcpy(outpars[pc++],parameters[param++],MAXBUF);
 											}
 										}
-										chan->SetCustomMode(modechar,mdir);
-										// include parameters in output if mode has them
-										if ((ModeDefinedOn(modechar,MT_CHANNEL)>0) && (mdir))
-										{
-											chan->SetCustomModeParam(modelist[ptr],parameters[param],mdir);
-											strlcpy(outpars[pc++],parameters[param++],MAXBUF);
-										}
-									}
-									// break, because only one module can handle the mode.
-									handled = true;
-        		 					}
-        	 					}
-     						}
+										// break, because only one module can handle the mode.
+										handled = true;
+       	 		 						}
+       	 	 						}
+	     						}
+						}
      					}
 					else
 					{
@@ -1273,25 +1389,30 @@ void handle_mode(char **parameters, int pcnt, userrec *user)
 		else
 		if (pcnt == 2)
 		{
-			if ((!strcmp(parameters[1],"+b")) || (!strcmp(parameters[1],"b")))
-			{
-
-				for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
-				{
-					WriteServ(user->fd,"367 %s %s %s %s %d",user->nick, Ptr->name, i->data, i->set_by, i->set_time);
-				}
-				WriteServ(user->fd,"368 %s %s :End of channel ban list",user->nick, Ptr->name);
-				return;
-			}
 			char* mode = parameters[1];
 			if (*mode == '+')
 				mode++;
-			if ((ModeDefined(*mode,MT_CHANNEL)) && (ModeIsListMode(*mode,MT_CHANNEL)))
-			{
-				// list of items for an extmode
-				log(DEBUG,"Calling OnSendList for all modules, list output for mode %c",*mode);
-				FOREACH_MOD OnSendList(user,Ptr,*mode);
-				return;
+			int MOD_RESULT = 0;
+                        FOREACH_RESULT(OnRawMode(user, *mode, "", false, 0));
+                        if (!MOD_RESULT)
+                        {
+				if (*mode == 'b')
+				{
+
+					for (BanList::iterator i = Ptr->bans.begin(); i != Ptr->bans.end(); i++)
+					{
+						WriteServ(user->fd,"367 %s %s %s %s %d",user->nick, Ptr->name, i->data, i->set_by, i->set_time);
+					}
+					WriteServ(user->fd,"368 %s %s :End of channel ban list",user->nick, Ptr->name);
+					return;
+				}
+				if ((ModeDefined(*mode,MT_CHANNEL)) && (ModeIsListMode(*mode,MT_CHANNEL)))
+				{
+					// list of items for an extmode
+					log(DEBUG,"Calling OnSendList for all modules, list output for mode %c",*mode);
+					FOREACH_MOD OnSendList(user,Ptr,*mode);
+					return;
+				}
 			}
 		}
 
diff --git a/src/modules.cpp b/src/modules.cpp
index 02221f1a6..be5d1d744 100644
--- a/src/modules.cpp
+++ b/src/modules.cpp
@@ -337,6 +337,15 @@ bool Module::OnCheckReady(userrec* user) { return true; };
 void Module::OnUserRegister(userrec* user) { };
 int Module::OnUserPreKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { return 0; };
 void Module::OnUserKick(userrec* source, userrec* user, chanrec* chan, std::string reason) { };
+int Module::OnRawMode(userrec* user, char mode, std::string param, bool adding, int pcnt) { return 0; };
+int Module::OnCheckInvite(userrec* user, chanrec* chan) { return 0; };
+int Module::OnCheckKey(userrec* user, chanrec* chan, std::string keygiven) { return 0; };
+int Module::OnCheckLimit(userrec* user, chanrec* chan) { return 0; };
+int Module::OnCheckBan(userrec* user, chanrec* chan) { return 0; };
+void Module::OnStats(char symbol) { };
+int Module::OnChangeLocalUserHost(userrec* user, std::string newhost) { return 0; };
+int Module::OnChangeLocalUserGECOS(userrec* user, std::string newhost) { return 0; };
+int Module::OnLocalTopicChange(userrec* user, chanrec* chan, std::string topic) { return 0; };
 
 // server is a wrapper class that provides methods to all of the C-style
 // exports in the core