Example #1
0
int DenoraInit(int argc, char **argv)
{
    if (denora->protocoldebug) {
        protocol_debug(NULL, argc, argv);
    }
    /* Only 1 protocol module may be loaded */
    if (protocolModuleLoaded()) {
        alog(LOG_NORMAL, langstr(ALOG_MOD_BE_ONLY_ONE));
        return MOD_STOP;
    }
    /* Actual module code stuff */
    moduleAddAuthor("Denora");
    moduleAddVersion("$Id: asuka.c 388 2011-01-04 21:12:18Z hal9000 $");
    moduleSetType(PROTOCOL);
    /* protocol version and name that we support */
    pmodule_ircd_version("Asuka 1.2.1");
    /* set the flag of what ircd */
    pmodule_irc_var(IRC_ASUKA);

    pmodule_ircd_cap(myIrcdcap);
    pmodule_ircd_var(myIrcd);
    pmodule_ircd_useTSMode(0);

    IRCDModeInit();
    pmodule_oper_umode(UMODE_o);

    moduleAddIRCDCmds();
    moduleAddIRCDMsgs();

    return MOD_CONT;
}
Example #2
0
/**
 * Create the hook, and tell Denora about it.
 **/
int DenoraInit(int argc, char **argv)
{
    EvtHook *hook;
    Command *c;

    if (denora->debug)
        protocol_debug(NULL, argc, argv);

    moduleAddAuthor(AUTHOR);
    moduleAddVersion(VERSION);
    moduleSetType(THIRD);

    if ((VERSION_MAJOR != 1) && (VERSION_MINOR < 4)) {
        alog(LOG_ERROR,
             "[seen] Your Denora version is incompatible with this module.");
        return MOD_STOP;
    }

    if (!denora->do_sql) {
        alog(LOG_ERROR,
             "[seen] SQL needs to be enabled to load this module.");
        return MOD_STOP;
    }

    hook = createEventHook(EVENT_FANTASY, do_fantasy_seen);
    moduleAddEventHook(hook);

    c = createCommand("SEEN", do_msg_seen, NULL, -1, -1, -1, -1);
    moduleAddCommand(STATSERV, c, MOD_UNIQUE);

    mAddLanguages();

    return MOD_CONT;
}
Example #3
0
int DenoraInit(int argc, char **argv)
{
    if (denora->protocoldebug) {
        protocol_debug(NULL, argc, argv);
    }
    /* Only 1 protocol module may be loaded */
    if (protocolModuleLoaded()) {
        alog(LOG_NORMAL, langstr(ALOG_MOD_BE_ONLY_ONE));
        return MOD_STOP;
    }

    moduleAddAuthor("Denora");
    moduleAddVersion
        ("$Id$");
    moduleSetType(PROTOCOL);

    pmodule_ircd_version("InspIRCd 1.1.x");
    pmodule_ircd_cap(myIrcdcap);
    pmodule_ircd_var(myIrcd);
    pmodule_ircd_useTSMode(0);
    pmodule_irc_var(IRC_INSPIRCD11);
    IRCDModeInit();
    pmodule_oper_umode(UMODE_o);

    moduleAddIRCDCmds();
    moduleAddIRCDMsgs();

    return MOD_CONT;
}
Example #4
0
int AnopeInit(int argc, char **argv)
{
    Command *c;
    EvtHook *evt;
    int status;

    moduleAddAuthor(AUTHOR);
    moduleAddVersion(VERSION);
    moduleSetType(SUPPORTED);

    c = createCommand("REGISTER", my_ns_register, NULL, -1, -1, -1, -1,
                      -1);
    if ((status = moduleAddCommand(NICKSERV, c, MOD_HEAD))) {
        alog("[ns_maxemail] Unable to create REGISTER command: %d",
             status);
        return MOD_STOP;
    }

    c = createCommand("SET", my_ns_set, NULL, -1, -1, -1, -1, -1);
    if ((status = moduleAddCommand(NICKSERV, c, MOD_HEAD))) {
        alog("[ns_maxemail] Unable to create SET command: %d", status);
        return MOD_STOP;
    }

    evt = createEventHook(EVENT_RELOAD, my_event_reload);
    if ((status = moduleAddEventHook(evt))) {
        alog("[ns_maxemail] Unable to hook to EVENT_RELOAD: %d", status);
        return MOD_STOP;
    }

    my_load_config();
    my_add_languages();

    return MOD_CONT;
}
Example #5
0
/**
 * Create the command, and tell Denora about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int DenoraInit(int argc, char **argv)
{
    HTMLTag *h;
    int status;

    if (denora->debug >= 2) {
        protocol_debug(NULL, argc, argv);
    }
    moduleAddAuthor("Denora");
    moduleAddVersion
        ("$Id$");
    moduleSetType(CORE);

    h = createHTMLtag("!CLIENTSTATS!", html_ctcp_table);
    status = addHTMLTag(h);
    if (status != MOD_ERR_OK) {
        alog(LOG_NORMAL,
             "Error Occurried setting message for !CLIENTSTATS! [%d][%s]",
             status, ModuleGetErrStr(status));
    }

    h = createHTMLtag("!TOP10CLIENTVERTITLE!", html_top10client_title);
    status = addHTMLTag(h);
    if (status != MOD_ERR_OK) {
        alog(LOG_NORMAL,
             "Error Occurried setting message for !TOP10CLIENTVERTITLE! [%d][%s]",
             status, ModuleGetErrStr(status));
    }


    return MOD_CONT;
}
Example #6
0
/**
 * Create the command, and tell Denora about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int DenoraInit(int argc, char **argv)
{
    Command *c;

    if (denora->debug >= 2) {
        protocol_debug(NULL, argc, argv);
    }
    moduleAddAuthor("Denora");
    moduleAddVersion
        ("$Id: ss_modules.c 398 2011-01-31 22:37:12Z hal9000 $");
    moduleSetType(CORE);

#ifdef USE_MODULES
    c = createCommand("MODLOAD", do_modload, is_stats_admin, -1, -1, -1,
                      STAT_HELP_MODLOAD);
    moduleAddCommand(STATSERV, c, MOD_UNIQUE);

    c = createCommand("MODUNLOAD", do_modunload, is_stats_admin, -1, -1,
                      -1, STAT_HELP_MODUNLOAD);
    moduleAddCommand(STATSERV, c, MOD_UNIQUE);

    c = createCommand("MODLIST", do_modlist, is_stats_admin, -1, -1, -1,
                      STAT_HELP_MODLIST);
    moduleAddCommand(STATSERV, c, MOD_UNIQUE);

    c = createCommand("MODINFO", do_modinfo, is_stats_admin, -1, -1, -1,
                      STAT_HELP_MODINFO);
    moduleAddCommand(STATSERV, c, MOD_UNIQUE);
#endif

    return MOD_CONT;
}
Example #7
0
int AnopeInit(int argc, char **argv)
{
    Command *c;
    int status;

    moduleAddAuthor(AUTHOR);
    moduleAddVersion(VERSION);
    moduleSetType(SUPPORTED);

    c = createCommand("APPENDTOPIC", my_cs_appendtopic, NULL, -1, -1, -1,
                      -1, -1);
    if ((status = moduleAddCommand(CHANSERV, c, MOD_HEAD))) {
        alog("[cs_appendtopic] Unable to create APPENDTOPIC command: %d",
             status);
        return MOD_STOP;
    }
    moduleAddHelp(c, my_cs_help_appendtopic);
    moduleSetChanHelp(my_cs_help);

    my_add_languages();

    alog("[cs_appendtopic] Loaded successfully");

    return MOD_CONT;
}
Example #8
0
int DenoraInit(int argc, char **argv)
{
    if (denora->protocoldebug) {
        protocol_debug(NULL, argc, argv);
    }

    moduleAddAuthor("Denora");
    moduleAddVersion
        ("$Id: dreamforge.c 31 2007-07-18 11:39:31Z Hal9000 $");
    moduleSetType(PROTOCOL);

    pmodule_ircd_version("DreamForge 4.6.7");
    pmodule_ircd_cap(myIrcdcap);
    pmodule_ircd_var(myIrcd);
    pmodule_ircd_useTSMode(0);
    pmodule_irc_var(IRC_DREAMFORGE);

    IRCDModeInit();
    pmodule_oper_umode(UMODE_o);

    moduleAddIRCDCmds();
    moduleAddIRCDMsgs();
    UplinkSynced = 1;
    return MOD_CONT;
}
Example #9
0
/** 
 * Now tell anope how to use us.
 **/
int AnopeInit(int argc, char **argv)
{

    moduleAddAuthor("Anope");
    moduleAddVersion("$Id: viagra.c 1291 2007-08-30 20:59:14Z drstein $");
    moduleSetType(PROTOCOL);

    pmodule_ircd_version("ViagraIRCd 1.3.x");
    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();
    moduleAddIRCDMsgs();

    return MOD_CONT;
}
Example #10
0
/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;
    EvtHook *hook;

    moduleAddAuthor("Anope");
    moduleAddVersion(VERSION_STRING);
    moduleSetType(CORE);

    /** 
     * For some unknown reason, do_opernews is actaully defined in news.c
     * we can look at moving it here later
     **/
    c = createCommand("OPERNEWS", do_opernews, is_services_admin,
                      NEWS_HELP_OPER, -1, -1, -1, -1);
    c->help_param1 = (char *) (long) NewsCount;
    moduleAddCommand(OPERSERV, c, MOD_UNIQUE);

    moduleSetOperHelp(myOperServHelp);

    hook = createEventHook(EVENT_RELOAD, reload_config);
    if (moduleAddEventHook(hook) != MOD_ERR_OK) {
        alog("[\002os_opernews\002] Can't hook to EVENT_RELOAD event");
        return MOD_STOP;
    }

    return MOD_CONT;
}
Example #11
0
int DenoraInit(int argc, char **argv)
{
    if (denora->protocoldebug) {
        protocol_debug(NULL, argc, argv);
    }
    /* Only 1 protocol module may be loaded */
    if (protocolModuleLoaded()) {
        alog(LOG_NORMAL, langstr(ALOG_MOD_BE_ONLY_ONE));
        return MOD_STOP;
    }

    moduleAddAuthor("Denora");
    moduleAddVersion("$Id: bahamut.c 388 2011-01-04 21:12:18Z hal9000 $");
    moduleSetType(PROTOCOL);

    pmodule_ircd_version("BahamutIRCd 1.4.*/1.8.*");
    pmodule_ircd_cap(myIrcdcap);
    pmodule_ircd_var(myIrcd);
    pmodule_ircd_useTSMode(0);

    IRCDModeInit();
    pmodule_oper_umode(UMODE_o);
    pmodule_irc_var(IRC_BAHAMUT);
    moduleAddIRCDCmds();
    moduleAddIRCDMsgs();
    return MOD_CONT;
}
Example #12
0
/** 
 * Now tell anope how to use us.
 **/
int
AnopeInit (int argc, char **argv)
{

  moduleAddAuthor ("Anope");
  moduleAddVersion (VERSION_STRING);
  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);
  pmodule_permchan_mode(CMODE_z);

  moduleAddAnopeCmds ();
  moduleAddIRCDMsgs ();

  return MOD_CONT;
}
Example #13
0
/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion(VERSION_STRING);
    moduleSetType(CORE);

    c = createCommand("SET", do_set, NULL, MEMO_HELP_SET, -1, -1, -1, -1);
    moduleAddCommand(MEMOSERV, c, MOD_UNIQUE);

    c = createCommand("SET NOTIFY", NULL, NULL, MEMO_HELP_SET_NOTIFY, -1,
                      -1, -1, -1);
    moduleAddCommand(MEMOSERV, c, MOD_UNIQUE);

    c = createCommand("SET LIMIT", NULL, NULL, -1, MEMO_HELP_SET_LIMIT,
                      MEMO_SERVADMIN_HELP_SET_LIMIT,
                      MEMO_SERVADMIN_HELP_SET_LIMIT,
                      MEMO_SERVADMIN_HELP_SET_LIMIT);
    c->help_param1 = (char *) (long) MSMaxMemos;
    moduleAddCommand(MEMOSERV, c, MOD_UNIQUE);

    moduleSetMemoHelp(myMemoServHelp);

    return MOD_CONT;
}
Example #14
0
int DenoraInit(int argc, char **argv)
{
    if (denora->protocoldebug) {
        protocol_debug(NULL, argc, argv);
    }
    /* Only 1 protocol module may be loaded */
    if (protocolModuleLoaded()) {
        alog(LOG_NORMAL, langstr(ALOG_MOD_BE_ONLY_ONE));
        return MOD_STOP;
    }

    moduleAddAuthor("Denora");
    moduleAddVersion("$Id: scarynet.c 64 2007-05-08 16:48:13Z outsider $");
    moduleSetType(PROTOCOL);

    pmodule_ircd_version("ScaryNet IRCu 2.10.11");
    pmodule_ircd_cap(myIrcdcap);
    pmodule_ircd_var(myIrcd);
    pmodule_ircd_useTSMode(0);
    pmodule_irc_var(IRC_SCARYNET);
    IRCDModeInit();
    pmodule_oper_umode(UMODE_o);

    moduleAddIRCDCmds();
    moduleAddIRCDMsgs();

    return MOD_CONT;
}
Example #15
0
/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion(VERSION_STRING);
    moduleSetType(CORE);

    c = createCommand("SASET", do_saset, is_services_oper, -1, -1,
                      NICK_HELP_SASET, NICK_HELP_SASET, NICK_HELP_SASET);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET DISPLAY", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_DISPLAY, NICK_HELP_SASET_DISPLAY, NICK_HELP_SASET_DISPLAY);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET PASSWORD", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_PASSWORD, NICK_HELP_SASET_PASSWORD, NICK_HELP_SASET_PASSWORD);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET URL", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_URL, NICK_HELP_SASET_URL, NICK_HELP_SASET_URL);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET EMAIL", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_EMAIL, NICK_HELP_SASET_EMAIL, NICK_HELP_SASET_EMAIL);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET ICQ", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_ICQ, NICK_HELP_SASET_ICQ, NICK_HELP_SASET_ICQ);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET GREET", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_GREET, NICK_HELP_SASET_GREET, NICK_HELP_SASET_GREET);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET KILL", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_KILL, NICK_HELP_SASET_KILL, NICK_HELP_SASET_KILL);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET SECURE", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_SECURE, NICK_HELP_SASET_SECURE, NICK_HELP_SASET_SECURE);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET PRIVATE", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_PRIVATE, NICK_HELP_SASET_PRIVATE, NICK_HELP_SASET_PRIVATE);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET MSG", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_MSG, NICK_HELP_SASET_MSG, NICK_HELP_SASET_MSG);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET HIDE", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_HIDE, NICK_HELP_SASET_HIDE, NICK_HELP_SASET_HIDE);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET NOEXPIRE", NULL, is_services_oper, -1, -1,
                      NICK_HELP_SASET_NOEXPIRE, NICK_HELP_SASET_NOEXPIRE,
                      NICK_HELP_SASET_NOEXPIRE);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET AUTOOP", NULL, is_services_oper, -1, -1,
                      NICK_HELP_SASET_AUTOOP, NICK_HELP_SASET_AUTOOP, NICK_HELP_SASET_AUTOOP);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);
    c = createCommand("SASET LANGUAGE", NULL, is_services_oper,
                      -1, -1, NICK_HELP_SASET_LANGUAGE, NICK_HELP_SASET_LANGUAGE, NICK_HELP_SASET_LANGUAGE);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);

    moduleSetNickHelp(myNickServHelp);

    return MOD_CONT;
}
Example #16
0
int AnopeInit(int argc, char **argv)
{
    Command *c;
    EvtHook *hook;

    c = createCommand("request", hs_do_request, nick_identified, -1, -1,
                      -1, -1, -1);
    moduleAddHelp(c, hs_help_request);
    moduleAddCommand(HOSTSERV, c, MOD_HEAD);

    c = createCommand("activate", hs_do_activate, is_host_setter, -1, -1,
                      -1, -1, -1);
    moduleAddHelp(c, hs_help_activate);
    moduleAddCommand(HOSTSERV, c, MOD_HEAD);

    c = createCommand("reject", hs_do_reject, is_host_setter, -1, -1, -1,
                      -1, -1);
    moduleAddHelp(c, hs_help_reject);
    moduleAddCommand(HOSTSERV, c, MOD_HEAD);

    c = createCommand("waiting", hs_do_waiting, is_host_setter, -1, -1, -1,
                      -1, -1);
    moduleAddHelp(c, hs_help_waiting);
    moduleAddCommand(HOSTSERV, c, MOD_HEAD);

    c = createCommand("list", hs_do_list_out, is_services_oper, -1, -1, -1,
                      -1, -1);
    moduleAddCommand(HOSTSERV, c, MOD_HEAD);

    hook = createEventHook(EVENT_NICK_DROPPED, hsreqevt_nick_dropped);
    moduleAddEventHook(hook);

    hook = createEventHook(EVENT_NICK_EXPIRE, hsreqevt_nick_dropped);
    moduleAddEventHook(hook);

    hook = createEventHook(EVENT_DB_SAVING, hsreqevt_db_saving);
    moduleAddEventHook(hook);

    hook = createEventHook(EVENT_DB_BACKUP, hsreqevt_db_backup);
    moduleAddEventHook(hook);

    moduleSetHostHelp(hs_help);
    moduleAddAuthor(AUTHOR);
    moduleAddVersion(VERSION);
    moduleSetType(SUPPORTED);

    my_load_config();
    my_add_languages();
    hs_request_head = NULL;

    if (debug)
        alog("[hs_request] Loading database...");
    hsreq_load_db();
    alog("hs_request loaded");
    return MOD_CONT;
}
Example #17
0
/**
 * Create the hook, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    EvtHook *hook;

    moduleAddAuthor("Anope");
    moduleAddVersion(VERSION_STRING);
    moduleSetType(CORE);
    hook = createEventHook(EVENT_BOT_FANTASY, do_fantasy);
    moduleAddEventHook(hook);

    return MOD_CONT;
}
Example #18
0
/**
 * Create the help command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion("$Id: ms_help.c 953 2006-01-14 11:36:29Z certus $");
    moduleSetType(CORE);
    c = createCommand("HELP", do_help, NULL, -1, -1, -1, -1, -1);
    moduleAddCommand(MEMOSERV, c, MOD_UNIQUE);

    return MOD_CONT;
}
Example #19
0
int AnopeInit(int argc, char **argv) {

    moduleAddAuthor("Anope");
    moduleAddVersion(VERSION_STRING);
    moduleSetType(ENCRYPTION);
 
    encmodule_encrypt(plain_encrypt);
    encmodule_encrypt_check_len(plain_encrypt_check_len);
    encmodule_decrypt(plain_decrypt);
    encmodule_check_password(plain_check_password);

    return MOD_CONT;
}
Example #20
0
/**
 * Create the help command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion(VERSION_STRING);
    moduleSetType(CORE);
    c = createCommand("HELP", do_help, NULL, -1, -1, -1, -1, -1);
    moduleAddCommand(BOTSERV, c, MOD_UNIQUE);


    return MOD_CONT;
}
Example #21
0
/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion("$Id: ns_help.c 1265 2007-08-26 15:33:06Z geniusdex $");
    moduleSetType(CORE);

    c = createCommand("HELP", do_help, NULL, -1, -1, -1, -1, -1);
    moduleAddCommand(NICKSERV, c, MOD_UNIQUE);

    return MOD_CONT;
}
Example #22
0
/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion(VERSION_STRING);
    moduleSetType(CORE);
    c = createCommand("LIST", do_list, NULL, MEMO_HELP_LIST, -1, -1, -1,
                      -1);
    moduleAddCommand(MEMOSERV, c, MOD_UNIQUE);
    moduleSetMemoHelp(myMemoServHelp);

    return MOD_CONT;
}
Example #23
0
/**
 * Create the hook, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    EvtHook *hook;

    moduleAddAuthor("Anope");
    moduleAddVersion
        ("$Id: bs_fantasy_unban.c 953 2006-01-14 11:36:29Z certus $");
    moduleSetType(CORE);

    hook = createEventHook(EVENT_BOT_FANTASY, do_fantasy);
    moduleAddEventHook(hook);

    return MOD_CONT;
}
Example #24
0
/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion("$Id: ms_read.c 953 2006-01-14 11:36:29Z certus $");
    moduleSetType(CORE);
    c = createCommand("READ", do_read, NULL, MEMO_HELP_READ, -1, -1, -1,
                      -1);
    moduleAddCommand(MEMOSERV, c, MOD_UNIQUE);
    moduleSetMemoHelp(myMemoServHelp);

    return MOD_CONT;
}
Example #25
0
/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion(VERSION_STRING);
    moduleSetType(CORE);
    c = createCommand("INFO", do_info, NULL, -1, MEMO_HELP_INFO, -1,
                      MEMO_SERVADMIN_HELP_INFO, MEMO_SERVADMIN_HELP_INFO);
    moduleAddCommand(MEMOSERV, c, MOD_UNIQUE);
    moduleSetMemoHelp(myMemoServHelp);

    return MOD_CONT;
}
/**
 * Create the hook, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    EvtHook *hook;

    moduleAddAuthor("Anope");
    moduleAddVersion
        ("$Id: bs_fantasy_kick.c 1265 2007-08-26 15:33:06Z geniusdex $");
    moduleSetType(CORE);

    hook = createEventHook(EVENT_BOT_FANTASY, do_fantasy);
    moduleAddEventHook(hook);

    return MOD_CONT;
}
Example #27
0
/**
 * Create the hook, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    EvtHook *hook;

    moduleAddAuthor("Anope");
    moduleAddVersion
        ("$Id: bs_fantasy_kickban.c 1029 2006-04-29 09:29:34Z certus $");
    moduleSetType(CORE);

    hook = createEventHook(EVENT_BOT_FANTASY, do_fantasy);
    moduleAddEventHook(hook);

    return MOD_CONT;
}
Example #28
0
/**
 * Create the command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion("$Id: bs_say.c 1265 2007-08-26 15:33:06Z geniusdex $");
    moduleSetType(CORE);
    c = createCommand("SAY", do_say, NULL, BOT_HELP_SAY, -1, -1, -1, -1);
    moduleAddCommand(BOTSERV, c, MOD_UNIQUE);

    moduleSetBotHelp(myBotServHelp);

    return MOD_CONT;
}
Example #29
0
/**
 * Create the off command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion("$Id: hs_setall.c 1265 2007-08-26 15:33:06Z geniusdex $");
    moduleSetType(CORE);

    c = createCommand("SETALL", do_setall, is_host_setter,
                      HOST_HELP_SETALL, -1, -1, -1, -1);
    moduleAddCommand(HOSTSERV, c, MOD_UNIQUE);
    moduleSetHostHelp(myHostServHelp);

    return MOD_CONT;
}
Example #30
0
/**
 * Create the off command, and tell anope about it.
 * @param argc Argument count
 * @param argv Argument list
 * @return MOD_CONT to allow the module, MOD_STOP to stop it
 **/
int AnopeInit(int argc, char **argv)
{
    Command *c;

    moduleAddAuthor("Anope");
    moduleAddVersion("$Id: hs_off.c 953 2006-01-14 11:36:29Z certus $");
    moduleSetType(CORE);

    c = createCommand("OFF", do_off, NULL, HOST_HELP_OFF, -1, -1, -1, -1);
    moduleAddCommand(HOSTSERV, c, MOD_UNIQUE);

    moduleSetHostHelp(myHostServHelp);

    return MOD_CONT;
}