ircd.anope_valid_chan is added to all protocol modules to allow for things like unreal who add extra restircitons...

git-svn-id: svn://svn.anope.org/anope/trunk@995 31f1291d-b8d6-0310-a050-a5561fc1590b


git-svn-id: http://anope.svn.sourceforge.net/svnroot/anope/trunk@720 5417fbe8-f217-4b02-8779-1006273d7864

Changes

@@ -2,6 +2,7 @@ Anope Version  S V N
 --------------------
 Provided by Anope Dev. <dev@anope.org> - 2006
 02/04 A Events for channel kicks and NickServ logout.                     [ #00]
+03/01 F Added ircd module support for valid_chan.                         [ #00]
 03/01 F Minor issues in ns_saset.                                         [#455]
 02/13 F Yet anotehr 64bit issue.                                          [ #00]
 01/14 F SGLines will now be removed correctly.                            [ #00]

include/extern.h

@@ -659,6 +659,7 @@ E void pmodule_cmd_eob(void (*func) ());
 E void pmodule_cmd_jupe(void (*func) (char *jserver, char *who, char *reason));
 E void pmodule_set_umode(void (*func) (User * user, int ac, char **av));
 E void pmodule_valid_nick(int (*func) (char *nick));
+E void pmodule_valid_chan(int (*func) (char *chan));
 E void pmodule_flood_mode_check(int (*func) (char *value));
 E void pmodule_ircd_var(IRCDVar * ircdvar);
 E void pmodule_ircd_cap(IRCDCAPAB * cap);
@@ -1327,6 +1328,7 @@ E void anope_cmd_global_legacy(char *source, char *fmt);
 E void wallops(char *source, const char *fmt, ...);
 
 E int anope_valid_nick(char *nick);
+E int anope_valid_chan(char *chan);
 
 E char *common_get_vident(User *u);
 E char *common_get_vhost(User *u);

include/services.h

@@ -1177,6 +1177,7 @@ typedef struct ircd_proto_ {
     void (*ircd_cmd_jupe)(char *jserver, char *who, char *reason);
     void (*ircd_set_umode)(User *user, int ac, char **av);
     int (*ircd_valid_nick)(char *nick);
+    int (*ircd_valid_chan)(char *chan);
     int (*ircd_flood_mode_check)(char *value);
 } IRCDProto;
 

src/core/cs_forbid.c

@@ -84,7 +84,7 @@ int do_forbid(User * u)
     if (*chan != '#') {
         notice_lang(s_ChanServ, u, CHAN_SYMBOL_REQUIRED);
         return MOD_CONT;
-    } else if (strchr(chan, ':')) {
+    } else if (anope_valid_chan(chan)) {
         notice_lang(s_ChanServ, u, CHAN_X_INVALID, chan);
         return MOD_CONT;
     }

src/core/cs_register.c

@@ -95,7 +95,7 @@ int do_register(User * u)
         notice_lang(s_ChanServ, u, CHAN_REGISTER_NOT_LOCAL);
     } else if (*chan != '#') {
         notice_lang(s_ChanServ, u, CHAN_SYMBOL_REQUIRED);
-    } else if (strchr(chan, ':')) {
+    } else if (anope_valid_chan(chan)) {
         notice_lang(s_ChanServ, u, CHAN_X_INVALID, chan);
     } else if (!u->na || !(nc = u->na->nc)) {
         notice_lang(s_ChanServ, u, CHAN_MUST_REGISTER_NICK, s_NickServ);

src/ircd.c

@@ -94,6 +94,7 @@ void initIrcdProto()
     ircdproto.ircd_flood_mode_check = NULL;
     ircdproto.ircd_cmd_jupe = NULL;
     ircdproto.ircd_valid_nick = NULL;
+    ircdproto.ircd_valid_chan = NULL;
     ircdproto.ircd_cmd_ctcp = NULL;
 }
 
@@ -596,6 +597,12 @@ int anope_valid_nick(char *nick)
     return ircdproto.ircd_valid_nick(nick);
 }
 
+int anope_valid_chan(char *chan)
+{
+    return ircdproto.ircd_valid_chan(chan);
+}
+
+
 void anope_cmd_ctcp(char *source, char *dest, const char *fmt, ...)
 {
     va_list args;
@@ -988,6 +995,11 @@ void pmodule_valid_nick(int (*func) (char *nick))
     ircdproto.ircd_valid_nick = func;
 }
 
+void pmodule_valid_chan(int (*func) (char *chan))
+{
+    ircdproto.ircd_valid_chan = func;
+}
+
 void pmodule_flood_mode_check(int (*func) (char *value))
 {
     ircdproto.ircd_flood_mode_check = func;

src/protocol/bahamut.c

@@ -1521,6 +1521,16 @@ int bahamut_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = nick is in chan
+*/
+int bahamut_valid_chan(char *chan)
+{
+    /* no silly invalid chans */
+    return 1;
+}
+
 void bahamut_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1617,6 +1627,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(bahamut_flood_mode_check);
     pmodule_cmd_jupe(bahamut_cmd_jupe);
     pmodule_valid_nick(bahamut_valid_nick);
+    pmodule_valid_chan(bahamut_valid_chan);
     pmodule_cmd_ctcp(bahamut_cmd_ctcp);
     pmodule_set_umode(bahamut_set_umode);
 }

src/protocol/charybdis.c

@@ -1765,6 +1765,17 @@ int charybdis_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is invalid
+*/
+int charybdis_valid_chan(char *chan)
+{
+    /* no hard coded invalid chan */
+    return 1;
+}
+
+
 void charybdis_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1872,6 +1883,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(charybdis_flood_mode_check);
     pmodule_cmd_jupe(charybdis_cmd_jupe);
     pmodule_valid_nick(charybdis_valid_nick);
+    pmodule_valid_chan(charybdis_valid_chan);
     pmodule_cmd_ctcp(charybdis_cmd_ctcp);
     pmodule_set_umode(charybdis_set_umode);
 }

src/protocol/dreamforge.c

@@ -1232,6 +1232,17 @@ int dreamforge_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int dreamforge_valid_chan(char *chan)
+{
+    /* no hard coded invalid chan */
+    return 1;
+}
+
+
 void dreamforge_cmd_ctcp(char *source, char *dest, char *buf)
 {
 
@@ -1321,6 +1332,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(dreamforge_flood_mode_check);
     pmodule_cmd_jupe(dreamforge_cmd_jupe);
     pmodule_valid_nick(dreamforge_valid_nick);
+    pmodule_valid_chan(dreamforge_valid_chan);
     pmodule_cmd_ctcp(dreamforge_cmd_ctcp);
     pmodule_set_umode(dreamforge_set_umode);
 }

src/protocol/hybrid.c

@@ -1400,6 +1400,17 @@ int hybrid_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int hybrid_valid_chan(char *chan)
+{
+    /* no hard coded invalid chans */
+    return 1;
+}
+
+
 void hybrid_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1489,6 +1500,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(hybrid_flood_mode_check);
     pmodule_cmd_jupe(hybrid_cmd_jupe);
     pmodule_valid_nick(hybrid_valid_nick);
+    pmodule_valid_chan(hybrid_valid_chan);
     pmodule_cmd_ctcp(hybrid_cmd_ctcp);
     pmodule_set_umode(hybrid_set_umode);
 }

src/protocol/inspircd.c

@@ -1553,6 +1553,12 @@ int inspircd_valid_nick(char *nick)
     return 1;
 }
 
+int inspircd_valid_chan(char *chan)
+{
+    return 1;
+}
+
+
 void inspircd_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1642,6 +1648,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(inspircd_flood_mode_check);
     pmodule_cmd_jupe(inspircd_cmd_jupe);
     pmodule_valid_nick(inspircd_valid_nick);
+    pmodule_valid_chan(inspircd_valid_chan);
     pmodule_cmd_ctcp(inspircd_cmd_ctcp);
     pmodule_set_umode(inspircd_set_umode);
 }

src/protocol/plexus.c

@@ -1714,6 +1714,18 @@ plexus_valid_nick (char *nick)
   return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int
+plexus_valid_chan (char *chan)
+{
+  /* no hard coded invalid chan */
+  return 1;
+}
+
+
 void
 plexus_cmd_ctcp (char *source, char *dest, char *buf)
 {
@@ -1808,6 +1820,7 @@ moduleAddAnopeCmds ()
   pmodule_flood_mode_check (plexus_flood_mode_check);
   pmodule_cmd_jupe (plexus_cmd_jupe);
   pmodule_valid_nick (plexus_valid_nick);
+  pmodule_valid_chan (plexus_valid_chan);
   pmodule_cmd_ctcp (plexus_cmd_ctcp);
   pmodule_set_umode (plexus_set_umode);
 }

src/protocol/ptlink.c

@@ -1590,6 +1590,17 @@ int ptlink_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int ptlink_valid_chan(char *cahn)
+{
+    /* no hard coded invalid chan */
+    return 1;
+}
+
+
 void ptlink_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1679,6 +1690,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(ptlink_flood_mode_check);
     pmodule_cmd_jupe(ptlink_cmd_jupe);
     pmodule_valid_nick(ptlink_valid_nick);
+    pmodule_valid_chan(ptlink_valid_chan);
     pmodule_cmd_ctcp(ptlink_cmd_ctcp);
     pmodule_set_umode(ptlink_set_umode);
 }

src/protocol/rageircd.c

@@ -1525,6 +1525,17 @@ int rageircd_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int rageircd_valid_chan(char *chan)
+{
+    /* no hard coded invalid nicks */
+    return 1;
+}
+
+
 void rageircd_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1614,6 +1625,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(rageircd_flood_mode_check);
     pmodule_cmd_jupe(rageircd_cmd_jupe);
     pmodule_valid_nick(rageircd_valid_nick);
+    pmodule_valid_chan(rageircd_valid_chan);
     pmodule_cmd_ctcp(rageircd_cmd_ctcp);
     pmodule_set_umode(rageircd_set_umode);
 }

src/protocol/ratbox.c

@@ -1731,6 +1731,17 @@ int ratbox_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int ratbox_valid_chan(char *chan)
+{
+    /* no hard coded invalid chans */
+    return 1;
+}
+
+
 void ratbox_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1820,6 +1831,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(ratbox_flood_mode_check);
     pmodule_cmd_jupe(ratbox_cmd_jupe);
     pmodule_valid_nick(ratbox_valid_nick);
+    pmodule_valid_chan(ratbox_valid_chan);
     pmodule_cmd_ctcp(ratbox_cmd_ctcp);
     pmodule_set_umode(ratbox_set_umode);
 }

src/protocol/shadowircd.c

@@ -1679,6 +1679,17 @@ int shadowircd_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int shadowircd_valid_chan(char *chan)
+{
+    /* no hard coded invalid chan */
+    return 1;
+}
+
+
 void shadowircd_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1767,6 +1778,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(shadowircd_flood_mode_check);
     pmodule_cmd_jupe(shadowircd_cmd_jupe);
     pmodule_valid_nick(shadowircd_valid_nick);
+    pmodule_valid_chan(shadowircd_valid_chan);
     pmodule_cmd_ctcp(shadowircd_cmd_ctcp);
     pmodule_set_umode(shadowircd_set_umode);
 }

src/protocol/solidircd.c

@@ -1556,6 +1556,17 @@ int solidircd_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int solidircd_valid_chan(char *chan)
+{
+    /* no hard coded invalid chan*/
+    return 1;
+}
+
+
 void solidircd_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1645,6 +1656,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(solidircd_flood_mode_check);
     pmodule_cmd_jupe(solidircd_cmd_jupe);
     pmodule_valid_nick(solidircd_valid_nick);
+    pmodule_valid_chan(solidircd_valid_chan);
     pmodule_cmd_ctcp(solidircd_cmd_ctcp);
     pmodule_set_umode(solidircd_set_umode);
 }

src/protocol/ultimate2.c

@@ -1583,6 +1583,17 @@ int ultiamte2_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int ultiamte2_valid_chan(char *chan)
+{
+    /* no hard coded invalid chans */
+    return 1;
+}
+
+
 void ultimate2_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1672,6 +1683,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(ultiamte2_flood_mode_check);
     pmodule_cmd_jupe(ultimate2_cmd_jupe);
     pmodule_valid_nick(ultiamte2_valid_nick);
+    pmodule_valid_chan(ultiamte2_valid_chan);
     pmodule_cmd_ctcp(ultimate2_cmd_ctcp);
     pmodule_set_umode(ultiamte2_set_umode);
 }

src/protocol/ultimate3.c

@@ -1665,6 +1665,17 @@ int ultiamte3_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int ultiamte3_valid_chan(char *chan)
+{
+    /* no hard coded invalid chans */
+    return 1;
+}
+
+
 void ultimate3_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1754,6 +1765,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(ultiamte3_flood_mode_check);
     pmodule_cmd_jupe(ultimate3_cmd_jupe);
     pmodule_valid_nick(ultiamte3_valid_nick);
+    pmodule_valid_chan(ultiamte3_valid_chan);
     pmodule_cmd_ctcp(ultimate3_cmd_ctcp);
     pmodule_set_umode(ultimate3_set_umode);
 }

src/protocol/unreal31.c

@@ -1440,6 +1440,13 @@ int unreal_valid_nick(char *nick)
     return 1;
 }
 
+int unreal_valid_chan(char *chan) {
+    if (strchr(chan, ':')) {
+      return 0;
+    }
+    return 1;
+}
+
 void unreal_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1529,6 +1536,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(unreal_flood_mode_check);
     pmodule_cmd_jupe(unreal_cmd_jupe);
     pmodule_valid_nick(unreal_valid_nick);
+    pmodule_valid_chan(unreal_valid_chan);
     pmodule_cmd_ctcp(unreal_cmd_ctcp);
     pmodule_set_umode(unreal_set_umode);
 }

src/protocol/unreal32.c

@@ -1814,6 +1814,13 @@ int unreal_valid_nick(char *nick)
     return 1;
 }
 
+int unreal_valid_chan(char *chan) {
+    if (strchr(chan, ':')) {
+      return 0;
+    }
+    return 1;
+}
+
 void unreal_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -2160,6 +2167,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(unreal_flood_mode_check);
     pmodule_cmd_jupe(unreal_cmd_jupe);
     pmodule_valid_nick(unreal_valid_nick);
+    pmodule_valid_chan(unreal_valid_chan);
     pmodule_cmd_ctcp(unreal_cmd_ctcp);
     pmodule_set_umode(unreal_set_umode);
 }

src/protocol/viagra.c

@@ -1565,6 +1565,17 @@ int viagra_valid_nick(char *nick)
     return 1;
 }
 
+/* 
+  1 = valid chan
+  0 = chan is in valid
+*/
+int viagra_valid_chan(char *chan)
+{
+    /* no hard coded invalid chans */
+    return 1;
+}
+
+
 void viagra_cmd_ctcp(char *source, char *dest, char *buf)
 {
     char *s;
@@ -1654,6 +1665,7 @@ void moduleAddAnopeCmds()
     pmodule_flood_mode_check(viagra_flood_mode_check);
     pmodule_cmd_jupe(viagra_cmd_jupe);
     pmodule_valid_nick(viagra_valid_nick);
+    pmodule_valid_chan(viagra_valid_chan);
     pmodule_cmd_ctcp(viagra_cmd_ctcp);
     pmodule_set_umode(viagra_set_umode);
 }