diff options
Diffstat (limited to 'src/protocol/obsolete/plexus3.c')
| -rw-r--r-- | src/protocol/obsolete/plexus3.c | 1853 |
1 files changed, 1853 insertions, 0 deletions
diff --git a/src/protocol/obsolete/plexus3.c b/src/protocol/obsolete/plexus3.c new file mode 100644 index 000000000..a376e11c7 --- /dev/null +++ b/src/protocol/obsolete/plexus3.c @@ -0,0 +1,1853 @@ +/* PlexusIRCD IRCD functions + * + * (C) 2003-2008 Anope Team + * Contact us at info@anope.org + * + * Please read COPYING and README for furhter details. + * + * Based on the original code of Epona by Lara. + * Based on the original code of Services by Andy Church. + */ + +#include "services.h" +#include "pseudo.h" +#include "plexus3.h" + +IRCDVar myIrcd[] = { + {"hybrid-7.2.1+plexus-3.0.0+",/* ircd name */ + "+i", /* nickserv mode */ + "+i", /* chanserv mode */ + "+i", /* memoserv mode */ + "+i", /* hostserv mode */ + "+oai", /* operserv mode */ + "+i", /* botserv mode */ + "+i", /* helpserv mode */ + "+i", /* Dev/Null mode */ + "+i", /* Global mode */ + "+i", /* nickserv alias mode */ + "+i", /* chanserv alias mode */ + "+i", /* memoserv alias mode */ + "+i", /* hostserv alias mode */ + "+oai", /* operserv alias mode */ + "+i", /* botserv alias mode */ + "+i", /* helpserv alias mode */ + "+i", /* Dev/Null alias mode */ + "+i", /* Global alias mode */ + "+i", /* Used by BotServ Bots */ + 5, /* Chan Max Symbols */ + "-cilmnpstBMNORS", /* Modes to Remove */ + "+ao", /* Channel Umode used by Botserv bots */ + 1, /* SVSNICK */ + 1, /* Vhost */ + 1, /* Has Owner */ + "+q", /* Mode to set for an owner */ + "-q", /* Mode to unset for an owner */ + "+a", /* Mode to set for chan admin */ + "-a", /* Mode to unset for chan admin */ + "+rd", /* Mode On Reg */ + "N", /* Mode on ID for Roots */ + NULL, /* Mode on ID for Admins */ + NULL, /* Mode on ID for Opers */ + "-r+d", /* Mode on UnReg */ + "+d", /* Mode on Nick Change */ + 1, /* Supports SGlines */ + 1, /* Supports SQlines */ + 0, /* Supports SZlines */ + 1, /* Supports Halfop +h */ + 3, /* Number of server args */ + 0, /* Join 2 Set */ + 0, /* Join 2 Message */ + 1, /* Has exceptions +e */ + 0, /* TS Topic Forward */ + 0, /* TS Topci Backward */ + UMODE_N, /* Protected Umode */ + 0, /* Has Admin */ + 1, /* Chan SQlines */ + 0, /* Quit on Kill */ + 0, /* SVSMODE unban */ + 1, /* Has Protect */ + 0, /* Reverse */ + 0, /* Chan Reg */ + 0, /* Channel Mode */ + 0, /* vidents */ + 1, /* svshold */ + 1, /* time stamp on mode */ + 0, /* NICKIP */ + 0, /* O:LINE */ + 1, /* UMODE */ + 1, /* VHOST ON NICK */ + 0, /* Change RealName */ + CMODE_p, /* No Knock */ + 0, /* Admin Only */ + DEFAULT_MLOCK, /* Default MLOCK */ + UMODE_x, /* Vhost Mode */ + 0, /* +f */ + 0, /* +L */ + 0, /* +f Mode */ + 0, /* +L Mode */ + 1, /* On nick change check if they could be identified */ + 0, /* No Knock requires +i */ + NULL, /* CAPAB Chan Modes */ + 0, /* We support TOKENS */ + 1, /* TOKENS are CASE inSensitive */ + 0, /* TIME STAMPS are BASE64 */ + 1, /* +I support */ + 0, /* SJOIN ban char */ + 0, /* SJOIN except char */ + 0, /* SJOIN invite char */ + 0, /* Can remove User Channel Modes with SVSMODE */ + 0, /* Sglines are not enforced until user reconnects */ + "x", /* vhost char */ + 0, /* ts6 */ + 0, /* support helper umode */ + 0, /* p10 */ + NULL, /* character set */ + 1, /* reports sync state */ + 0, /* CIDR channelbans */ + } + , + {NULL} +}; + +IRCDCAPAB myIrcdcap[] = { + { + 0, /* NOQUIT */ + 0, /* TSMODE */ + 0, /* UNCONNECT */ + 0, /* NICKIP */ + 0, /* SJOIN */ + CAPAB_ZIP, /* ZIP */ + 0, /* BURST */ + CAPAB_TS5, /* TS5 */ + 0, /* TS3 */ + 0, /* DKEY */ + 0, /* PT4 */ + 0, /* SCS */ + CAPAB_QS, /* QS */ + CAPAB_UID, /* UID */ + CAPAB_KNOCK, /* KNOCK */ + 0, /* CLIENT */ + 0, /* IPV6 */ + 0, /* SSJ5 */ + 0, /* SN2 */ + 0, /* TOKEN */ + 0, /* VHOST */ + 0, /* SSJ3 */ + 0, /* NICK2 */ + 0, /* UMODE2 */ + 0, /* VL */ + 0, /* TLKEXT */ + 0, /* DODKEY */ + 0, /* DOZIP */ + 0, 0, 0} +}; + + + +void +plexus_set_umode (User * user, int ac, const char **av) +{ + int add = 1; /* 1 if adding modes, 0 if deleting */ + const char *modes = av[0]; + + ac--; + + if (debug) + alog ("debug: Changing mode for %s to %s", user->nick, modes); + + while (*modes) + { + + /* This looks better, much better than "add ? (do_add) : (do_remove)". + * At least this is readable without paying much attention :) -GD + */ + if (add) + user->mode |= umodes[(int) *modes]; + else + user->mode &= ~umodes[(int) *modes]; + + switch (*modes++) + { + case '+': + add = 1; + break; + case '-': + add = 0; + break; + case 'd': + if (ac == 0) + { + alog ("user: umode +d with no parameter (?) for user %s", + user->nick); + break; + } + + ac--; + av++; + user->svid = strtoul (*av, NULL, 0); + break; + case 'x': + update_host (user); + break; + case 'o': + if (add) + { + opcnt++; + + if (WallOper) + anope_cmd_global (s_OperServ, + "\2%s\2 is now an IRC operator.", + user->nick); + display_news (user, NEWS_OPER); + + } + else + { + opcnt--; + } + break; + case 'r': + if (add && !nick_identified (user)) + { + common_svsmode (user, "-r", NULL); + user->mode &= ~UMODE_r; + } + break; + } + } +} + +unsigned long umodes[128] = { + 0, 0, 0, /* Unused */ + 0, 0, 0, /* Unused */ + 0, 0, 0, /* Unused, Unused, Horzontal Tab */ + 0, 0, 0, /* Line Feed, Unused, Unused */ + 0, 0, 0, /* Carriage Return, Unused, Unused */ + 0, 0, 0, /* Unused */ + 0, 0, 0, /* Unused */ + 0, 0, 0, /* Unused */ + 0, 0, 0, /* Unused */ + 0, 0, 0, /* Unused */ + 0, 0, 0, /* Unused, Unused, Space */ + 0, 0, 0, /* ! " # */ + 0, 0, 0, /* $ % & */ + 0, 0, 0, /* ! ( ) */ + 0, 0, 0, /* * + , */ + 0, 0, 0, /* - . / */ + 0, 0, /* 0 1 */ + 0, 0, /* 2 3 */ + 0, 0, /* 4 5 */ + 0, 0, /* 6 7 */ + 0, 0, /* 8 9 */ + 0, 0, /* : ; */ + 0, 0, 0, /* < = > */ + 0, 0, /* ? @ */ + 0, 0, 0, /* A B C */ + 0, 0, 0, /* D E F */ + 0, 0, 0, /* G H I */ + 0, 0, 0, /* J K L */ + 0, UMODE_N, 0, /* M N O */ + 0, 0, UMODE_R, /* P Q R */ + UMODE_S, 0, 0, /* S T U */ + 0, 0, 0, /* V W X */ + 0, /* Y */ + 0, /* Z */ + 0, 0, 0, /* [ \ ] */ + 0, 0, 0, /* ^ _ ` */ + UMODE_a, 0, 0, /* a b c */ + 0, 0, 0, /* d e f */ + 0, 0, UMODE_i, /* g h i */ + 0, 0, 0, /* j k l */ + 0, 0, UMODE_o, /* m n o */ + 0, 0, UMODE_r, /* p q r */ + 0, 0, 0, /* s t u */ + 0, UMODE_w, UMODE_x, /* v w x */ + 0, /* y */ + 0, /* z */ + 0, 0, 0, /* { | } */ + 0, 0 /* ~ � */ +}; + + +char myCsmodes[128] = { + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + + 0, + 0, + 0, 0, 0, + 'h', /* (37) % Channel halfops */ + 'a', + 0, 0, 0, 0, + + 'v', 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + + 'o', 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 'q', 0 +}; + +CMMode myCmmodes[128] = { + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, /* BCD */ + {NULL}, {NULL}, {NULL}, /* EFG */ + {NULL}, /* H */ + {add_invite, del_invite}, + {NULL}, /* J */ + {NULL}, {NULL}, {NULL}, /* KLM */ + {NULL}, {NULL}, {NULL}, /* NOP */ + {NULL}, {NULL}, {NULL}, /* QRS */ + {NULL}, {NULL}, {NULL}, /* TUV */ + {NULL}, {NULL}, {NULL}, /* WXY */ + {NULL}, /* Z */ + {NULL}, {NULL}, /* (char 91 - 92) */ + {NULL}, {NULL}, {NULL}, /* (char 93 - 95) */ + {NULL}, /* ` (char 96) */ + {NULL}, /* a (char 97) */ + {add_ban, del_ban}, + {NULL}, + {NULL}, + {add_exception, del_exception}, + {NULL}, + {NULL}, + {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, + {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL}, {NULL} +}; + + +CBMode myCbmodes[128] = { + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, + {0}, /* A */ + {CMODE_B, CBM_NO_USER_MLOCK, NULL, NULL}, /* B */ + {0}, /* C */ + {0}, /* D */ + {0}, /* E */ + {0}, /* F */ + {0}, /* G */ + {0}, /* H */ + {0}, /* I */ + {0}, /* J */ + {0}, /* K */ + {0}, /* L */ + {CMODE_M, 0, NULL, NULL}, /* M */ + {CMODE_N, 0, NULL, NULL}, /* N */ + {CMODE_O, CBM_NO_USER_MLOCK, NULL, NULL}, /* O */ + {0}, /* P */ + {0}, /* Q */ + {CMODE_R, 0, NULL, NULL}, /* R */ + {CMODE_S, 0, NULL, NULL}, /* S */ + {0}, /* T */ + {0}, /* U */ + {0}, /* V */ + {0}, /* W */ + {0}, /* X */ + {0}, /* Y */ + {0}, /* Z */ + {0}, {0}, {0}, {0}, {0}, {0}, + {0}, /* a */ + {0}, /* b */ + {CMODE_c, 0, NULL, NULL}, /* c */ + {0}, /* d */ + {0}, /* e */ + {0}, /* f */ + {0}, /* g */ + {0}, /* h */ + {CMODE_i, 0, NULL, NULL}, + {0}, /* j */ + {CMODE_k, 0, chan_set_key, cs_set_key}, + {CMODE_l, CBM_MINUS_NO_ARG, set_limit, cs_set_limit}, + {CMODE_m, 0, NULL, NULL}, + {CMODE_n, 0, NULL, NULL}, + {0}, /* o */ + {CMODE_p, 0, NULL, NULL}, + {0}, /* q */ + {0}, + {CMODE_s, 0, NULL, NULL}, + {CMODE_t, 0, NULL, NULL}, + {0}, + {0}, /* v */ + {0}, /* w */ + {0}, /* x */ + {0}, /* y */ + {0}, /* z */ + {0}, {0}, {0}, {0} +}; + +CBModeInfo myCbmodeinfos[] = { + {'c', CMODE_c, 0, NULL, NULL}, + {'i', CMODE_i, 0, NULL, NULL}, + {'k', CMODE_k, 0, get_key, cs_get_key}, + {'l', CMODE_l, CBM_MINUS_NO_ARG, get_limit, cs_get_limit}, + {'m', CMODE_m, 0, NULL, NULL}, + {'n', CMODE_n, 0, NULL, NULL}, + {'p', CMODE_p, 0, NULL, NULL}, + {'s', CMODE_s, 0, NULL, NULL}, + {'t', CMODE_t, 0, NULL, NULL}, + {'B', CMODE_B, 0, NULL, NULL}, + {'M', CMODE_M, 0, NULL, NULL}, + {'N', CMODE_N, 0, NULL, NULL}, + {'O', CMODE_O, 0, NULL, NULL}, + {'R', CMODE_R, 0, NULL, NULL}, + {'S', CMODE_S, 0, NULL, NULL}, + {0} +}; + + +CUMode myCumodes[128] = { + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + {0}, {0}, {0}, {0}, {0}, {0}, {0}, {0}, + + {0}, + + {CUS_PROTECT, CUF_PROTECT_BOTSERV, check_valid_op}, + {0}, /* b */ + {0}, /* c */ + {0}, /* d */ + {0}, /* e */ + {0}, /* f */ + {0}, /* g */ + {CUS_HALFOP, 0, check_valid_op}, + {0}, /* i */ + {0}, /* j */ + {0}, /* k */ + {0}, /* l */ + {0}, /* m */ + {0}, /* n */ + {CUS_OP, CUF_PROTECT_BOTSERV, check_valid_op}, + {0}, /* p */ + {CUS_OWNER, 0, check_valid_op}, /* q */ + {0}, /* r */ + {0}, /* s */ + {0}, /* t */ + {0}, /* u */ + {CUS_VOICE, 0, NULL}, + {0}, /* w */ + {0}, /* x */ + {0}, /* y */ + {0}, /* z */ + {0}, {0}, {0}, {0}, {0} +}; + + + +void +plexus_cmd_notice (const char *source, const char *dest, const char *buf) +{ + if (!buf) + { + return; + } + + if (NSDefFlags & NI_MSG) + { + plexus_cmd_privmsg2 (source, dest, buf); + } + else + { + send_cmd (source, "NOTICE %s :%s", dest, buf); + } +} + +void +plexus_cmd_notice2 (const char *source, const char *dest, const char *msg) +{ + send_cmd (source, "NOTICE %s :%s", dest, msg); +} + +void +plexus_cmd_privmsg (const char *source, const char *dest, const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (source, "PRIVMSG %s :%s", dest, buf); +} + +void +plexus_cmd_privmsg2 (const char *source, const char *dest, const char *msg) +{ + send_cmd (source, "PRIVMSG %s :%s", dest, msg); +} + +void +plexus_cmd_serv_notice (const char *source, const char *dest, const char *msg) +{ + send_cmd (source, "NOTICE $$%s :%s", dest, msg); +} + +void +plexus_cmd_serv_privmsg (const char *source, const char *dest, const char *msg) +{ + send_cmd (source, "PRIVMSG $$%s :%s", dest, msg); +} + + +void +plexus_cmd_global (const char *source, const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (source ? source : ServerName, "OPERWALL :%s", buf); +} + +/* GLOBOPS - to handle old WALLOPS */ +void +plexus_cmd_global_legacy (const char *source, const char *fmt) +{ + send_cmd (source ? source : ServerName, "OPERWALL :%s", fmt); +} + +int +anope_event_sjoin (const char *source, int ac, const char **av) +{ + do_sjoin (source, ac, av); + return MOD_CONT; +} + +int +anope_event_nick (const char *source, int ac, const char **av) +{ + if (ac != 2) + { + User *user = do_nick (source, av[0], av[4], av[8], av[6], av[9], + strtoul (av[2], NULL, 10), + strtoul (av[7], NULL, 0), 0, av[5], NULL); + if (user) + anope_set_umode (user, 1, &av[3]); + } + else + { + do_nick (source, av[0], NULL, NULL, NULL, NULL, + strtoul (av[1], NULL, 10), 0, 0, NULL, NULL); + } + return MOD_CONT; +} + +int +anope_event_topic (const char *source, int ac, const char **av) +{ + if (ac == 4) + { + do_topic (source, ac, av); + } + else + { + Channel *c = findchan (av[0]); + time_t topic_time = time (NULL); + + if (!c) + { + if (debug) + { + alog ("debug: TOPIC %s for nonexistent channel %s", + merge_args (ac - 1, av + 1), av[0]); + } + return MOD_CONT; + } + + if (check_topiclock (c, topic_time)) + return MOD_CONT; + + if (c->topic) + { + free (c->topic); + c->topic = NULL; + } + if (ac > 1 && *av[1]) + c->topic = sstrdup (av[1]); + + strscpy (c->topic_setter, source, sizeof (c->topic_setter)); + c->topic_time = topic_time; + + record_topic (av[0]); + + if (ac > 1 && *av[1]) + send_event(EVENT_TOPIC_UPDATED, 2, av[0], av[1]); + else + send_event(EVENT_TOPIC_UPDATED, 2, av[0], ""); + + } + return MOD_CONT; +} + +int +anope_event_tburst (const char *source, int ac, const char **av) +{ + if (ac != 5) + return MOD_CONT; + + av[0] = av[1]; + av[1] = av[3]; + av[3] = av[4]; + do_topic (source, 4, av); + return MOD_CONT; +} + +/* + * ENCAP handler + * av[0] = servermask (not used) + * av[1] = command + * av[2] and beyond are dynamic. + */ +int +anope_event_encap (const char *source, int ac, const char **av) +{ + if (ac < 2) + return MOD_CONT; + + if (!stricmp (av[1], "CHGHOST")) + { + User *u; + + if (ac != 4) + return MOD_CONT; + + u = finduser (av[2]); + if (!u) + { + if (debug) + { + alog ("debug: CHGHOST for nonexistent user %s", av[2]); + } + return MOD_CONT; + } + + u->SetDisplayedHost(av[3]); + return MOD_CONT; + } + return MOD_CONT; +} + +int +anope_event_436 (const char *source, int ac, const char **av) +{ + if (ac < 1) + return MOD_CONT; + + m_nickcoll (av[0]); + return MOD_CONT; +} + + +void +moduleAddIRCDMsgs (void) +{ + Message *m; + + updateProtectDetails("PROTECT","PROTECTME","protect","deprotect","AUTOPROTECT","+a","-a"); + + m = createMessage ("401", anope_event_null); + addCoreMessage (IRCD, m); + m = createMessage ("402", anope_event_null); + addCoreMessage (IRCD, m); + m = createMessage ("436", anope_event_436); + addCoreMessage (IRCD, m); + m = createMessage ("AWAY", anope_event_away); + addCoreMessage (IRCD, m); + m = createMessage ("INVITE", anope_event_invite); + addCoreMessage (IRCD, m); + m = createMessage ("JOIN", anope_event_join); + addCoreMessage (IRCD, m); + m = createMessage ("KICK", anope_event_kick); + addCoreMessage (IRCD, m); + m = createMessage ("KILL", anope_event_kill); + addCoreMessage (IRCD, m); + m = createMessage ("MODE", anope_event_mode); + addCoreMessage (IRCD, m); + m = createMessage ("MOTD", anope_event_motd); + addCoreMessage (IRCD, m); + m = createMessage ("NICK", anope_event_nick); + addCoreMessage (IRCD, m); + m = createMessage ("NOTICE", anope_event_notice); + addCoreMessage (IRCD, m); + m = createMessage ("PART", anope_event_part); + addCoreMessage (IRCD, m); + m = createMessage ("PASS", anope_event_pass); + addCoreMessage (IRCD, m); + m = createMessage ("PING", anope_event_ping); + addCoreMessage (IRCD, m); + m = createMessage ("PRIVMSG", anope_event_privmsg); + addCoreMessage (IRCD, m); + m = createMessage ("QUIT", anope_event_quit); + addCoreMessage (IRCD, m); + m = createMessage ("SERVER", anope_event_server); + addCoreMessage (IRCD, m); + m = createMessage ("SQUIT", anope_event_squit); + addCoreMessage (IRCD, m); + m = createMessage ("TOPIC", anope_event_topic); + addCoreMessage (IRCD, m); + m = createMessage ("TBURST", anope_event_tburst); + addCoreMessage (IRCD, m); + m = createMessage ("USER", anope_event_null); + addCoreMessage (IRCD, m); + m = createMessage ("WALLOPS", anope_event_null); + addCoreMessage (IRCD, m); + m = createMessage ("WHOIS", anope_event_whois); + addCoreMessage (IRCD, m); + m = createMessage ("CAPAB", anope_event_capab); + addCoreMessage (IRCD, m); + m = createMessage ("SJOIN", anope_event_sjoin); + addCoreMessage (IRCD, m); + m = createMessage ("SVINFO", anope_event_svinfo); + addCoreMessage (IRCD, m); + m = createMessage ("EOB", anope_event_eob); + addCoreMessage (IRCD, m); + m = createMessage ("ADMIN", anope_event_admin); + addCoreMessage (IRCD, m); + m = createMessage ("ERROR", anope_event_error); + addCoreMessage (IRCD, m); + m = createMessage ("ENCAP", anope_event_encap); + addCoreMessage (IRCD, m); + m = createMessage ("SVSMODE", anope_event_mode); + addCoreMessage (IRCD, m); +} + +void +plexus_cmd_sqline (const char *mask, const char *reason) +{ + send_cmd (s_OperServ, "RESV * %s :%s", mask, reason); +} + +void +plexus_cmd_unsgline (const char *mask) +{ + send_cmd (s_OperServ, "UNXLINE * %s", mask); +} + +void +plexus_cmd_unszline (const char *mask) +{ + /* Does not support */ +} + +void +plexus_cmd_szline (const char *mask, const char *reason, const char *whom) +{ + /* Does not support */ +} + +void PleXusIRCdProto::cmd_svsnoop(const char *server, int set) +{ + send_cmd(ServerName, "ENCAP %s SVSNOOP %s", server, set ? "+" : "-"); +} + +void +plexus_cmd_svsadmin (const char *server, int set) +{ + ircd_proto.cmd_svsnoop(server, set); +} + +void +plexus_cmd_sgline (const char *mask, const char *reason) +{ + send_cmd (s_OperServ, "XLINE * %s 0 :%s", mask, reason); +} + +void PleXusIRCdProto::cmd_remove_akill(const char *user, const char *host) +{ + send_cmd(s_OperServ, "UNKLINE * %s %s", user, host); +} + +void +plexus_cmd_topic (const char *whosets, const char *chan, const char *whosetit, + const char *topic, time_t when) +{ + send_cmd (whosets, "ENCAP * TOPIC %s %s %lu :%s", chan, whosetit, + (unsigned long int) when, topic); +} + +void +plexus_cmd_vhost_off (User * u) +{ + common_svsmode (u, "-x", NULL); +} + +void +plexus_cmd_vhost_on (const char *nick, const char *vIdent, const char *vhost) +{ + User *u; + + if (!nick) + { + return; + } + + u = finduser (nick); + + if (u) + { + send_cmd (ServerName, "ENCAP * CHGHOST %s %s", u->nick, vhost); + common_svsmode (u, "+x", NULL); + u->mode |= UMODE_x; + } +} + +void +plexus_cmd_unsqline (const char *user) +{ + send_cmd (s_OperServ, "UNRESV * %s", user); +} + +void +plexus_cmd_join (const char *user, const char *channel, time_t chantime) +{ + send_cmd (ServerName, "SJOIN %ld %s + :%s", (long int) chantime, channel, + user); +} + +/* +oper: the nick of the oper performing the kline +target.server: the server(s) this kline is destined for +duration: the duration if a tkline, 0 if permanent. +user: the 'user' portion of the kline +host: the 'host' portion of the kline +reason: the reason for the kline. +*/ + +void +plexus_cmd_akill (const char *user, const char *host, const char *who, time_t when, + time_t expires, const char *reason) +{ + send_cmd (s_OperServ, "KLINE * %ld %s %s :%s", + (long int) (expires - (long) time (NULL)), user, host, reason); +} + +void +plexus_cmd_svskill (const char *source, const char *user, const char *buf) +{ + if (!buf) + { + return; + } + + if (!source || !user) + { + return; + } + + send_cmd (source, "KILL %s :%s", user, buf); +} + +void +plexus_cmd_svsmode (User * u, int ac, const char **av) +{ + send_cmd (ServerName, "ENCAP * SVSMODE %s %ld %s%s%s", u->nick, + (long int) u->timestamp, av[0], (ac == 2 ? " " : ""), + (ac == 2 ? av[1] : "")); +} + +/* + * SVINFO + * parv[0] = sender prefix + * parv[1] = TS_CURRENT for the server + * parv[2] = TS_MIN for the server + * parv[3] = server is standalone or connected to non-TS only + * parv[4] = server's idea of UTC time + */ +void +plexus_cmd_svinfo () +{ + send_cmd (NULL, "SVINFO 5 5 0 :%ld", (long int) time (NULL)); +} + +/* CAPAB */ +/* + QS - Can handle quit storm removal + EX - Can do channel +e exemptions + CHW - Can do channel wall @# + LL - Can do lazy links + IE - Can do invite exceptions + EOB - Can do EOB message + KLN - Can do KLINE message + GLN - Can do GLINE message + HOPS - can do half ops (+h) + HUB - This server is a HUB + AOPS - Can do anon ops (+a) + UID - Can do UIDs + ZIP - Can do ZIPlinks + ENC - Can do ENCrypted links + KNOCK - supports KNOCK + TBURST - supports TBURST + PARA - supports invite broadcasting for +p + ENCAP - supports encapsulization of protocol messages + SVS - supports services protocol extensions +*/ +void +plexus_cmd_capab () +{ + send_cmd (NULL, + "CAPAB :QS EX CHW IE EOB KLN UNKLN GLN HUB KNOCK TBURST PARA ENCAP SVS"); +} + +/* PASS */ +void +plexus_cmd_pass (const char *pass) +{ + send_cmd (NULL, "PASS %s :TS", pass); +} + +/* SERVER name hop descript */ +void +plexus_cmd_server (const char *servname, int hop, const char *descript) +{ + send_cmd (NULL, "SERVER %s %d :%s", servname, hop, descript); +} + +void +plexus_cmd_connect (int servernum) +{ + me_server = new_server (NULL, ServerName, ServerDesc, SERVER_ISME, NULL); + + if (servernum == 1) + plexus_cmd_pass (RemotePassword); + else if (servernum == 2) + plexus_cmd_pass (RemotePassword2); + else if (servernum == 3) + plexus_cmd_pass (RemotePassword3); + + plexus_cmd_capab (); + plexus_cmd_server (ServerName, 1, ServerDesc); + plexus_cmd_svinfo (); +} + +void +plexus_cmd_svsinfo () +{ + /* not used */ +} + + + +void +plexus_cmd_bot_nick (const char *nick, const char *user, const char *host, const char *real, + const char *modes) +{ + EnforceQlinedNick (nick, NULL); + send_cmd (ServerName, "NICK %s 1 %ld %s %s %s %s 0 %s :%s", nick, + (long int) time (NULL), modes, user, host, ServerName, host, + real); + plexus_cmd_sqline (nick, "Reserved for services"); + +} + +void +plexus_cmd_part (const char *nick, const char *chan, const char *buf) +{ + if (buf) + { + send_cmd (nick, "PART %s :%s", chan, buf); + } + else + { + send_cmd (nick, "PART %s", chan); + } +} + +int +anope_event_ping (const char *source, int ac, const char **av) +{ + if (ac < 1) + return MOD_CONT; + plexus_cmd_pong (ac > 1 ? av[1] : ServerName, av[0]); + return MOD_CONT; +} + +int +anope_event_away (const char *source, int ac, const char **av) +{ + if (!source) + { + return MOD_CONT; + } + m_away (source, (ac ? av[0] : NULL)); + return MOD_CONT; +} + +int +anope_event_kill (const char *source, int ac, const char **av) +{ + if (ac != 2) + return MOD_CONT; + + m_kill (av[0], av[1]); + return MOD_CONT; +} + +int +anope_event_kick (const char *source, int ac, const char **av) +{ + if (ac != 3) + return MOD_CONT; + do_kick (source, ac, av); + return MOD_CONT; +} + +int +anope_event_eob (const char *source, int ac, const char **av) +{ + Server *s; + s = findserver (servlist, source); + /* If we found a server with the given source, that one just + * finished bursting. If there was no source, then our uplink + * server finished bursting. -GD + */ + if (!s && serv_uplink) + s = serv_uplink; + finish_sync (s, 1); + + return MOD_CONT; +} + +void +plexus_cmd_eob () +{ + send_cmd (ServerName, "EOB"); +} + + +int +anope_event_join (const char *source, int ac, const char **av) +{ + if (ac != 1) + return MOD_CONT; + do_join (source, ac, av); + return MOD_CONT; +} + +int +anope_event_motd (const char *source, int ac, const char **av) +{ + if (!source) + { + return MOD_CONT; + } + + m_motd (source); + return MOD_CONT; +} + +int +anope_event_privmsg (const char *source, int ac, const char **av) +{ + if (ac != 2) + return MOD_CONT; + m_privmsg (source, av[0], av[1]); + return MOD_CONT; +} + +int +anope_event_part (const char *source, int ac, const char **av) +{ + if (ac < 1 || ac > 2) + return MOD_CONT; + do_part (source, ac, av); + return MOD_CONT; +} + +int +anope_event_whois (const char *source, int ac, const char **av) +{ + if (source && ac >= 1) + { + m_whois (source, av[0]); + } + return MOD_CONT; +} + +/* EVENT: SERVER */ +int +anope_event_server (const char *source, int ac, const char **av) +{ + if (!stricmp (av[1], "1")) + { + uplink = sstrdup (av[0]); + } + do_server (source, av[0], av[1], av[2], NULL); + return MOD_CONT; +} + +int +anope_event_squit (const char *source, int ac, const char **av) +{ + if (ac != 2) + return MOD_CONT; + do_squit (source, ac, av); + return MOD_CONT; +} + +int +anope_event_quit (const char *source, int ac, const char **av) +{ + if (ac != 1) + return MOD_CONT; + do_quit (source, ac, av); + return MOD_CONT; +} + +void +plexus_cmd_372 (const char *source, const char *msg) +{ + send_cmd (ServerName, "372 %s :- %s", source, msg); +} + +void +plexus_cmd_372_error (const char *source) +{ + send_cmd (ServerName, "422 %s :- MOTD file not found! Please " + "contact your IRC administrator.", source); +} + +void +plexus_cmd_375 (const char *source) +{ + send_cmd (ServerName, "375 %s :- %s Message of the Day", + source, ServerName); +} + +void +plexus_cmd_376 (const char *source) +{ + send_cmd (ServerName, "376 %s :End of /MOTD command.", source); +} + +/* 391 */ +void +plexus_cmd_391 (const char *source, const char *timestr) +{ + if (!timestr) + { + return; + } + send_cmd (ServerName, "391 :%s %s :%s", source, ServerName, timestr); +} + +/* 250 */ +void +plexus_cmd_250 (const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "250 %s", buf); +} + +/* 307 */ +void +plexus_cmd_307 (const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "307 %s", buf); +} + +/* 311 */ +void +plexus_cmd_311 (const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "311 %s", buf); +} + +/* 312 */ +void +plexus_cmd_312 (const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "312 %s", buf); +} + +/* 317 */ +void +plexus_cmd_317 (const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "317 %s", buf); +} + +/* 219 */ +void +plexus_cmd_219 (const char *source, const char *letter) +{ + if (!source) + { + return; + } + + if (letter) + { + send_cmd (ServerName, "219 %s %c :End of /STATS report.", source, + *letter); + } + else + { + send_cmd (ServerName, "219 %s l :End of /STATS report.", source); + } +} + +/* 401 */ +void +plexus_cmd_401 (const char *source, const char *who) +{ + if (!source || !who) + { + return; + } + send_cmd (ServerName, "401 %s %s :No such service.", source, who); +} + +/* 318 */ +void +plexus_cmd_318 (const char *source, const char *who) +{ + if (!source || !who) + { + return; + } + + send_cmd (ServerName, "318 %s %s :End of /WHOIS list.", source, who); +} + +/* 242 */ +void +plexus_cmd_242 (const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "242 %s", buf); +} + +/* 243 */ +void +plexus_cmd_243 (const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "243 %s", buf); +} + +/* 211 */ +void +plexus_cmd_211 (const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "211 %s", buf); +} + +void +plexus_cmd_mode (const char *source, const char *dest, const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (source, "MODE %s %s", dest, buf); +} + +void +plexus_cmd_nick (const char *nick, const char *name, const char *mode) +{ + EnforceQlinedNick (nick, NULL); + send_cmd (ServerName, "NICK %s 1 %ld %s %s %s %s 0 %s :%s", nick, + (long int) time (NULL), mode, ServiceUser, ServiceHost, + ServerName, ServiceHost, (name)); + send_cmd (nick, "RESV * %s :%s", nick, "Reserved for services"); +} + +void +plexus_cmd_kick (const char *source, const char *chan, const char *user, const char *buf) +{ + if (buf) + { + send_cmd (source, "KICK %s %s :%s", chan, user, buf); + } + else + { + send_cmd (source, "KICK %s %s", chan, user); + } +} + +void +plexus_cmd_notice_ops (const char *source, const char *dest, const char *buf) +{ + if (!buf) + { + return; + } + + send_cmd (ServerName, "NOTICE @%s :%s", dest, buf); +} + +void +plexus_cmd_bot_chan_mode (const char *nick, const char *chan) +{ + anope_cmd_mode (nick, chan, "%s %s %s", myIrcd->botchanumode, nick, nick); +} + +/* QUIT */ +void +plexus_cmd_quit (const char *source, const char *buf) +{ + if (buf) + { + send_cmd (source, "QUIT :%s", buf); + } + else + { + send_cmd (source, "QUIT"); + } +} + +/* PONG */ +void +plexus_cmd_pong (const char *servname, const char *who) +{ + send_cmd (servname, "PONG %s", who); +} + +/* INVITE */ +void +plexus_cmd_invite (const char *source, const char *chan, const char *nick) +{ + if (!source || !chan || !nick) + { + return; + } + + send_cmd (source, "INVITE %s %s", nick, chan); +} + +/* SQUIT */ +void +plexus_cmd_squit (const char *servname, const char *message) +{ + if (!servname || !message) + { + return; + } + + send_cmd (ServerName, "SQUIT %s :%s", servname, message); +} + +int +anope_event_mode (const char *source, int ac, const char **av) +{ + if (ac < 2) + return MOD_CONT; + + if (*av[0] == '#' || *av[0] == '&') + { + do_cmode (source, ac, av); + } + else + { + Server *s; + s = findserver (servlist, source); + + if (s && *av[0]) + { + do_umode (av[0], ac, av); + } + else + { + do_umode (source, ac, av); + } + } + return MOD_CONT; +} + +void +plexus_cmd_351 (const char *source) +{ + send_cmd (ServerName, "351 %s Anope-%s %s :%s - %s (%s) -- %s", + source, version_number, ServerName, ircd->name, version_flags, + EncModule, version_build); +} + +/* Event: PROTOCTL */ +int +anope_event_capab (const char *source, int ac, const char **av) +{ + int argvsize = 8; + int argc; + const char **argv; + char *str; + + if (ac < 1) + return MOD_CONT; + + /* We get the params as one arg, we should split it for capab_parse */ + argv = (const char **)scalloc (argvsize, sizeof (const char *)); + argc = 0; + while ((str = myStrGetToken (av[0], ' ', argc))) + { + if (argc == argvsize) + { + argvsize += 8; + argv = (const char **)srealloc (argv, argvsize * sizeof (const char *)); + } + argv[argc] = str; + argc++; + } + + capab_parse (argc, argv); + + /* Free our built ac/av */ + for (argvsize = 0; argvsize < argc; argvsize++) + { + free ((char *)argv[argvsize]); + } + free ((char **)argv); + + return MOD_CONT; +} + +/* SVSHOLD - set */ +void +plexus_cmd_svshold (const char *nick) +{ + send_cmd (s_OperServ, "ENCAP * RESV %d %s 0 :%s", NSReleaseTimeout, nick, + "This nick is being held for a registered user. " + "For help with regaining nicknames please see /nickserv help release"); +} + +/* SVSHOLD - release */ +void +plexus_cmd_release_svshold (const char *nick) +{ + send_cmd (s_OperServ, "UNRESV * %s", nick); +} + +/* SVSNICK */ +void +plexus_cmd_svsnick (const char *nick, const char *newnick, time_t when) +{ + User *u; + + if (!nick || !newnick) + return; + + if( (u = finduser (nick))) { + send_cmd (ServerName, "ENCAP * SVSNICK %s %ld %s %ld", + u->nick, (long int) u->timestamp, newnick, (long int) when); + } +} + +void +plexus_cmd_guest_nick (const char *nick, const char *user, const char *host, const char *real, + const char *modes) +{ + send_cmd (ServerName, "NICK %s 1 %ld %s %s %s %s 0 %s :%s", nick, + (long int) time (NULL), modes, user, host, ServerName, host, + real); +} + +void +plexus_cmd_svso (const char *source, const char *nick, const char *flag) +{ + /* Not Supported by this IRCD */ +} + +void +plexus_cmd_unban (const char *name, const char *nick) +{ + /* Not Supported by this IRCD */ +} + +/* SVSMODE channel modes */ + +void +plexus_cmd_svsmode_chan (const char *name, const char *mode, const char *nick) +{ + /* Not Supported by this IRCD */ +} + +/* SVSMODE +d */ +/* sent if svid is something weird */ +void +plexus_cmd_svid_umode (const char *nick, time_t ts) +{ + send_cmd (ServerName, "ENCAP * SVSMODE %s %lu +d 1", nick, + (unsigned long int) ts); +} + +/* SVSMODE +d */ +/* nc_change was = 1, and there is no na->status */ +void +plexus_cmd_nc_change (User * u) +{ + common_svsmode (u, "+d", "1"); +} + +/* SVSMODE +d */ +void +plexus_cmd_svid_umode2 (User * u, const char *ts) +{ + /* not used */ +} + +void +plexus_cmd_svid_umode3 (User * u, const char *ts) +{ + char modes[512]; + + strlcpy(modes, "+r", sizeof(modes)); + + if(ircd->rootmodeonid && is_services_root(u)) { + strlcat(modes, ircd->rootmodeonid, sizeof(modes)); + } else if(ircd->adminmodeonid && is_services_admin(u)) { + strlcat(modes, ircd->adminmodeonid, sizeof(modes)); + } else if(ircd->opermodeonid && is_services_oper(u)) { + strlcat(modes, ircd->opermodeonid, sizeof(modes)); + } + if (u->svid != u->timestamp) { + strlcat(modes, "d", sizeof(modes)); + common_svsmode (u, modes, ts); + } else { + common_svsmode (u, modes, NULL); + } +} + +/* NICK <newnick> */ +void +plexus_cmd_chg_nick (const char *oldnick, const char *newnick) +{ + if (!oldnick || !newnick) + { + return; + } + + send_cmd (oldnick, "NICK %s", newnick); +} + +/* + * SVINFO + * parv[0] = sender prefix + * parv[1] = TS_CURRENT for the server + * parv[2] = TS_MIN for the server + * parv[3] = server is standalone or connected to non-TS only + * parv[4] = server's idea of UTC time + */ +int +anope_event_svinfo (const char *source, int ac, const char **av) +{ + /* currently not used but removes the message : unknown message from server */ + return MOD_CONT; +} + +int +anope_event_pass (const char *source, int ac, const char **av) +{ + /* currently not used but removes the message : unknown message from server */ + return MOD_CONT; +} + +void +plexus_cmd_svsjoin (const char *source, const char *nick, const char *chan, const char *param) +{ + send_cmd(ServerName, "ENCAP * SVSJOIN %s %s", nick, chan); +} + +void +plexus_cmd_svspart (const char *source, const char *nick, const char *chan) +{ + send_cmd(ServerName, "ENCAP * SVSPART %s %s", nick, chan); +} + +void +plexus_cmd_swhois (const char *source, const char *who, const char *mask) +{ + /* not supported */ +} + +int +anope_event_notice (const char *source, int ac, const char **av) +{ + return MOD_CONT; +} + +int +anope_event_admin (const char *source, int ac, const char **av) +{ + return MOD_CONT; +} + +int +anope_event_invite (const char *source, int ac, const char **av) +{ + return MOD_CONT; +} + +int +plexus_flood_mode_check (const char *value) +{ + return 0; +} + +int +anope_event_error (const char *source, int ac, const char **av) +{ + if (ac >= 1) + { + if (debug) + { + alog ("debug: %s", av[0]); + } + } + return MOD_CONT; +} + +void +plexus_cmd_jupe (const char *jserver, const char *who, const char *reason) +{ + char rbuf[256]; + + snprintf (rbuf, sizeof (rbuf), "(H) Juped by %s%s%s", who, + reason ? ": " : "", reason ? reason : ""); + + if (findserver(servlist, jserver)) + plexus_cmd_squit (jserver, rbuf); + plexus_cmd_server (jserver, 2, rbuf); + new_server (me_server, jserver, rbuf, SERVER_JUPED, NULL); +} + +/* + 1 = valid nick + 0 = nick is in valid +*/ +int +plexus_valid_nick (const char *nick) +{ + /* no hard coded invalid nicks */ + return 1; +} + +/* + 1 = valid chan + 0 = chan is in valid +*/ +int +plexus_valid_chan (const char *chan) +{ + /* no hard coded invalid chan */ + return 1; +} + + +void +plexus_cmd_ctcp (const char *source, const char *dest, const char *buf) +{ + char *s; + + if (!buf) + { + return; + } + else + { + s = normalizeBuffer (buf); + } + + send_cmd (source, "NOTICE %s :\1%s \1", dest, s); + free (s); +} + + +/** + * Tell anope which function we want to perform each task inside of anope. + * These prototypes must match what anope expects. + **/ +void +moduleAddAnopeCmds () +{ + pmodule_cmd_topic (plexus_cmd_topic); + pmodule_cmd_vhost_off (plexus_cmd_vhost_off); + pmodule_cmd_akill (plexus_cmd_akill); + pmodule_cmd_svskill (plexus_cmd_svskill); + pmodule_cmd_svsmode (plexus_cmd_svsmode); + pmodule_cmd_372 (plexus_cmd_372); + pmodule_cmd_372_error (plexus_cmd_372_error); + pmodule_cmd_375 (plexus_cmd_375); + pmodule_cmd_376 (plexus_cmd_376); + pmodule_cmd_nick (plexus_cmd_nick); + pmodule_cmd_guest_nick (plexus_cmd_guest_nick); + pmodule_cmd_mode (plexus_cmd_mode); + pmodule_cmd_bot_nick (plexus_cmd_bot_nick); + pmodule_cmd_kick (plexus_cmd_kick); + pmodule_cmd_notice_ops (plexus_cmd_notice_ops); + pmodule_cmd_notice (plexus_cmd_notice); + pmodule_cmd_notice2 (plexus_cmd_notice2); + pmodule_cmd_privmsg (plexus_cmd_privmsg); + pmodule_cmd_privmsg2 (plexus_cmd_privmsg2); + pmodule_cmd_serv_notice (plexus_cmd_serv_notice); + pmodule_cmd_serv_privmsg (plexus_cmd_serv_privmsg); + pmodule_cmd_bot_chan_mode (plexus_cmd_bot_chan_mode); + pmodule_cmd_351 (plexus_cmd_351); + pmodule_cmd_quit (plexus_cmd_quit); + pmodule_cmd_pong (plexus_cmd_pong); + pmodule_cmd_join (plexus_cmd_join); + pmodule_cmd_unsqline (plexus_cmd_unsqline); + pmodule_cmd_invite (plexus_cmd_invite); + pmodule_cmd_part (plexus_cmd_part); + pmodule_cmd_391 (plexus_cmd_391); + pmodule_cmd_250 (plexus_cmd_250); + pmodule_cmd_307 (plexus_cmd_307); + pmodule_cmd_311 (plexus_cmd_311); + pmodule_cmd_312 (plexus_cmd_312); + pmodule_cmd_317 (plexus_cmd_317); + pmodule_cmd_219 (plexus_cmd_219); + pmodule_cmd_401 (plexus_cmd_401); + pmodule_cmd_318 (plexus_cmd_318); + pmodule_cmd_242 (plexus_cmd_242); + pmodule_cmd_243 (plexus_cmd_243); + pmodule_cmd_211 (plexus_cmd_211); + pmodule_cmd_global (plexus_cmd_global); + pmodule_cmd_global_legacy (plexus_cmd_global_legacy); + pmodule_cmd_sqline (plexus_cmd_sqline); + pmodule_cmd_squit (plexus_cmd_squit); + pmodule_cmd_svso (plexus_cmd_svso); + pmodule_cmd_chg_nick (plexus_cmd_chg_nick); + pmodule_cmd_svsnick (plexus_cmd_svsnick); + pmodule_cmd_vhost_on (plexus_cmd_vhost_on); + pmodule_cmd_connect (plexus_cmd_connect); + pmodule_cmd_svshold (plexus_cmd_svshold); + pmodule_cmd_release_svshold (plexus_cmd_release_svshold); + pmodule_cmd_unsgline (plexus_cmd_unsgline); + pmodule_cmd_unszline (plexus_cmd_unszline); + pmodule_cmd_szline (plexus_cmd_szline); + pmodule_cmd_sgline (plexus_cmd_sgline); + pmodule_cmd_unban (plexus_cmd_unban); + pmodule_cmd_svsmode_chan (plexus_cmd_svsmode_chan); + pmodule_cmd_svid_umode (plexus_cmd_svid_umode); + pmodule_cmd_nc_change (plexus_cmd_nc_change); + pmodule_cmd_svid_umode2 (plexus_cmd_svid_umode2); + pmodule_cmd_svid_umode3 (plexus_cmd_svid_umode3); + pmodule_cmd_svsjoin (plexus_cmd_svsjoin); + pmodule_cmd_svspart (plexus_cmd_svspart); + pmodule_cmd_swhois (plexus_cmd_swhois); + pmodule_cmd_eob (plexus_cmd_eob); + 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); +} + +/** + * Now tell anope how to use us. + **/ +int +AnopeInit (int argc, char **argv) +{ + + moduleAddAuthor ("Anope"); + moduleAddVersion ("$Id: plexus.c 995 2006-03-01 20:19:11Z rob $"); + moduleSetType (PROTOCOL); + + pmodule_ircd_version ("hybrid-7.2.1+plexus-3.0.0+"); + pmodule_ircd_cap (myIrcdcap); + pmodule_ircd_var (myIrcd); + pmodule_ircd_cbmodeinfos (myCbmodeinfos); + pmodule_ircd_cumodes (myCumodes); + pmodule_ircd_flood_mode_char_set (""); + pmodule_ircd_flood_mode_char_remove (""); + pmodule_ircd_cbmodes (myCbmodes); + pmodule_ircd_cmmodes (myCmmodes); + pmodule_ircd_csmodes (myCsmodes); + pmodule_ircd_useTSMode (0); + + /** Deal with modes anope _needs_ to know **/ + pmodule_invis_umode (UMODE_i); + pmodule_oper_umode (UMODE_o); + pmodule_invite_cmode (CMODE_i); + pmodule_secret_cmode (CMODE_s); + pmodule_private_cmode (CMODE_p); + pmodule_key_mode (CMODE_k); + pmodule_limit_mode (CMODE_l); + + moduleAddAnopeCmds (); + pmodule_ircd_proto(&ircd_proto); + moduleAddIRCDMsgs (); + + return MOD_CONT; +} + +/* EOF */ |