X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_shun.cpp;h=599d665a114eff445b31f0d97a14b63d7f5fe874;hb=6d03943426dcce76ba66567a9b18425a5ebb4c0c;hp=b3b9b2010bbfe19c81d75407195e7793dc0b3880;hpb=480407f4ff12a014efdfa0eaa01172787409850c;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_shun.cpp b/src/modules/m_shun.cpp index b3b9b2010..599d665a1 100644 --- a/src/modules/m_shun.cpp +++ b/src/modules/m_shun.cpp @@ -1,228 +1,300 @@ -#include -#include -#include -#include +/* +------------------------------------+ + * | Inspire Internet Relay Chat Daemon | + * +------------------------------------+ + * + * InspIRCd: (C) 2002-2009 InspIRCd Development Team + * See: http://wiki.inspircd.org/Credits + * + * This program is free but copyrighted software; see + * the file COPYING for details. + * + * --------------------------------------------------- + */ + #include "inspircd.h" -#include "modules.h" -#include "hashcomp.h" -#include "configreader.h" +#include "xline.h" -/* $ModDesc: Gives the /shun command, which stops a user executing all commands except PING and PONG. */ -/* $ModAuthor: Om */ -/* $ModAuthorMail: om@inspircd.org */ +/* $ModDesc: Provides the /shun command, which stops a user executing all commands except PING and PONG. */ -class Shun +class Shun : public XLine { public: - std::string banmask; - std::string set_by; - time_t set_on; - long length; - std::string reason; + std::string matchtext; - Shun() { } + Shun(time_t s_time, long d, std::string src, std::string re, std::string shunmask) + : XLine(s_time, d, src, re, "SHUN") + { + this->matchtext = shunmask; + } - Shun(std::string bm, std::string sb, time_t so, long ln, std::string rs) : banmask(bm), set_by(sb), set_on(so), length(ln), reason(rs) { } - - bool operator<(const Shun &ban2) const + ~Shun() { - return ((this->set_on + this->length) < (ban2.set_on + ban2.length)); } -}; -typedef std::vector shunlist; + bool Matches(User *u) + { + // E: overrides shun + if (u->exempt) + return false; -class ModuleShunBase -{ - public: - /* shuns is declared here, as our type is right above. Don't try move it. */ - shunlist shuns; - - InspIRCd* Srv; - - std::string EncodeShun(const Shun &shun) + if (InspIRCd::Match(u->GetFullHost(), matchtext) || InspIRCd::Match(u->GetFullRealHost(), matchtext) || InspIRCd::Match(u->nick+"!"+u->ident+"@"+u->GetIPString(), matchtext)) + return true; + + return false; + } + + bool Matches(const std::string &s) + { + if (matchtext == s) + return true; + return false; + } + + void Apply(User *u) { - std::ostringstream stream; - stream << shun.banmask << " " << shun.set_by << " " << shun.set_on << " " << shun.length << " " << shun.reason; - return stream.str(); } - Shun DecodeShun(const std::string &data) + + void DisplayExpiry() { - Shun res; - std::istringstream stream(data); - stream >> res.banmask; - stream >> res.set_by; - stream >> res.set_on; - stream >> res.length; - res.reason = stream.str(); - - return res; + ServerInstance->SNO->WriteToSnoMask('x',"Removing expired shun %s (set by %s %ld seconds ago)", + this->matchtext.c_str(), this->source.c_str(), (long int)(ServerInstance->Time() - this->set_time)); } - void ExpireBans() + const char* Displayable() { - while(shuns.size() && shuns.begin()->length && ((shuns.begin()->set_on + shuns.begin()->length) <= Srv->Time())) - { - shunlist::iterator iter = shuns.begin(); - - Srv->SNO->WriteToSnoMask('X', "*** %ld second shun on '%s' (%s) set by %s %ld seconds ago expired", iter->length, iter->banmask.c_str(), iter->reason.c_str(), iter->set_by.c_str(), Srv->Time() - iter->set_on); - shuns.erase(iter); - } + return matchtext.c_str(); } }; -class cmd_shun : public Command +/** An XLineFactory specialized to generate shun pointers + */ +class ShunFactory : public XLineFactory { - private: - InspIRCd *Srv; - ModuleShunBase* base; + public: + ShunFactory() : XLineFactory("SHUN") { } + + /** Generate a shun + */ + XLine* Generate(time_t set_time, long duration, std::string source, std::string reason, std::string xline_specific_mask) + { + return new Shun(set_time, duration, source, reason, xline_specific_mask); + } +}; +//typedef std::vector shunlist; + +class CommandShun : public Command +{ public: - cmd_shun(InspIRCd* Me, ModuleShunBase* b) - : Command(Me, "SHUN", "o", 1), Srv(Me), base(b) + CommandShun(Module* Creator) : Command(Creator, "SHUN", 1, 3) { - this->source = "m_shun.so"; + flags_needed = 'o'; this->syntax = " [] :"; } - CmdResult Handle(const char* const*parameters, int pcnt, User *user) + CmdResult Handle(const std::vector& parameters, User *user) { /* syntax: SHUN nick!user@host time :reason goes here */ /* 'time' is a human-readable timestring, like 2d3h2s. */ + + std::string target = parameters[0]; - base->ExpireBans(); + User *find = ServerInstance->FindNick(target.c_str()); + if (find) + target = std::string("*!*@") + find->GetIPString(); - if(pcnt == 1) + if (parameters.size() == 1) { - /* form: SHUN mask removes a SHUN */ - for(shunlist::iterator iter = base->shuns.begin(); iter != base->shuns.end(); iter++) + if (ServerInstance->XLines->DelLine(target.c_str(), "SHUN", user)) { - if(parameters[0] == iter->banmask) - { - Srv->SNO->WriteToSnoMask('X', "*** %s removed shun '%s', set %ld seconds ago with reason '%s'", user->nick, iter->banmask.c_str(), Srv->Time() - iter->set_on, iter->reason.c_str()); - base->shuns.erase(iter); - return CMD_SUCCESS; - } + ServerInstance->SNO->WriteToSnoMask('x',"%s removed SHUN on %s",user->nick.c_str(),target.c_str()); + } + else + { + // XXX todo implement stats + user->WriteServ("NOTICE %s :*** Shun %s not found in list, try /stats S.",user->nick.c_str(),target.c_str()); } - user->WriteServ("NOTICE %s :*** The mask %s is not currently shunned, try /stats s", user->nick, parameters[0]); - return CMD_FAILURE; + return CMD_SUCCESS; } - else if (pcnt >= 2) + else if (parameters.size() >= 2) { - /* full form to add a shun */ - if(Srv->IsValidMask(parameters[0])) + // Adding - XXX todo make this respect tag perhaps.. + long duration; + std::string expr; + if (parameters.size() > 2) + { + duration = ServerInstance->Duration(parameters[1]); + expr = parameters[2]; + } + else { - // parameters[0] = Foamy!*@* - // parameters[1] = 1h3m2s - // parameters[2] = Tortoise abuser - for(shunlist::iterator iter = base->shuns.begin(); iter != base->shuns.end(); iter++) + duration = 0; + expr = parameters[1]; + } + Shun *r = NULL; + + try + { + r = new Shun(ServerInstance->Time(), duration, user->nick.c_str(), expr.c_str(), target.c_str()); + } + catch (...) + { + ; // Do nothing. If we get here, the regex was fucked up, and they already got told it fucked up. + } + + if (r) + { + if (ServerInstance->XLines->AddLine(r, user)) { - if (parameters[0] == iter->banmask) + if (!duration) + { + ServerInstance->SNO->WriteToSnoMask('x',"%s added permanent SHUN for %s: %s", + user->nick.c_str(), target.c_str(), expr.c_str()); + } + else { - user->WriteServ("NOTICE %s :*** Shun on %s already exists", user->nick, parameters[0]); - return CMD_FAILURE; + time_t c_requires_crap = duration + ServerInstance->Time(); + ServerInstance->SNO->WriteToSnoMask('x', "%s added timed SHUN for %s to expire on %s: %s", + user->nick.c_str(), target.c_str(), ServerInstance->TimeString(c_requires_crap).c_str(), expr.c_str()); } + + ServerInstance->XLines->ApplyLines(); } - - long length = Srv->Duration(parameters[1]); - - std::string reason = (pcnt > 2) ? parameters[2] : "No reason supplied"; - - base->shuns.push_back(Shun(parameters[0], user->nick, Srv->Time(), length, reason)); - - std::sort(base->shuns.begin(), base->shuns.end()); - - if(length > 0) - Srv->SNO->WriteToSnoMask('X', "*** %s added %ld second shun on '%s' (%s)", user->nick, length, parameters[0], reason.c_str()); else - Srv->SNO->WriteToSnoMask('X', "*** %s added permanent shun on '%s' (%s)", user->nick, parameters[0], reason.c_str()); - - return CMD_SUCCESS; - } - else - { - user->WriteServ("NOTICE %s :*** Invalid ban mask (%s)", user->nick, parameters[0]); + { + delete r; + user->WriteServ("NOTICE %s :*** Shun for %s already exists", user->nick.c_str(), expr.c_str()); + } } } return CMD_FAILURE; } + + RouteDescriptor GetRouting(User* user, const std::vector& parameters) + { + return ROUTE_BROADCAST; + } }; -class ModuleShun : public Module, public ModuleShunBase +class ModuleShun : public Module { - cmd_shun* mycommand; + CommandShun cmd; + ShunFactory f; + std::set ShunEnabledCommands; + bool NotifyOfShun; + bool affectopers; public: - ModuleShun(InspIRCd* Me) - : Module::Module(Me) + ModuleShun() : cmd(this) { - this->Srv = Me; - mycommand = new cmd_shun(Srv, this); - Srv->AddCommand(mycommand); + ServerInstance->XLines->RegisterFactory(&f); + ServerInstance->AddCommand(&cmd); + + Implementation eventlist[] = { I_OnStats, I_OnPreCommand, I_OnUserConnect, I_OnRehash }; + ServerInstance->Modules->Attach(eventlist, this, 4); + OnRehash(NULL); } - void Implements(char* List) + virtual ~ModuleShun() { - List[I_OnPreCommand] = List[I_OnSyncOtherMetaData] = List[I_OnDecodeMetaData] = List[I_OnStats] = 1; + ServerInstance->XLines->DelAll("SHUN"); + ServerInstance->XLines->UnregisterFactory(&f); } - - virtual int OnStats(char symbol, User* user, string_list& out) + + virtual ModResult OnStats(char symbol, User* user, string_list& out) { - ExpireBans(); - - if(symbol == 's') - { - for(shunlist::iterator iter = shuns.begin(); iter != shuns.end(); iter++) - { - std::ostringstream format; - format << Srv->Config->ServerName << " 223 " << user->nick << " :" << iter->banmask << " " << iter->set_on << " " << iter->length << " " << iter->set_by << " " << iter->reason; - out.push_back(format.str()); - } - } - - return 0; + if (symbol != 'S') + return MOD_RES_PASSTHRU; + + ServerInstance->XLines->InvokeStats("SHUN", 223, user, out); + return MOD_RES_DENY; } - virtual int OnPreCommand(const std::string &command, const char* const*parameters, int pcnt, User* user, bool validated, const std::string &original_line) + virtual void OnRehash(User* user) { - if((command != "PONG") && (command != "PING")) + ConfigReader MyConf; + std::string cmds = MyConf.ReadValue("shun", "enabledcommands", 0); + + if (cmds.empty()) + cmds = "PING PONG QUIT"; + + ShunEnabledCommands.clear(); + NotifyOfShun = true; + affectopers = false; + + std::stringstream dcmds(cmds); + std::string thiscmd; + + while (dcmds >> thiscmd) { - ExpireBans(); - - for(shunlist::iterator iter = shuns.begin(); iter != shuns.end(); iter++) - if(Srv->MatchText(user->GetFullHost(), iter->banmask) || Srv->MatchText(user->GetFullRealHost(), iter->banmask)) - return 1; + ShunEnabledCommands.insert(thiscmd); } - - return 0; + + NotifyOfShun = MyConf.ReadFlag("shun", "notifyuser", "yes", 0); + affectopers = MyConf.ReadFlag("shun", "affectopers", "no", 0); } - virtual void OnSyncOtherMetaData(Module* proto, void* opaque, bool displayable) + virtual void OnUserConnect(User* user) { - for(shunlist::iterator iter = shuns.begin(); iter != shuns.end(); iter++) + if (!IS_LOCAL(user)) + return; + + // Apply lines on user connect + XLine *rl = ServerInstance->XLines->MatchesLine("SHUN", user); + + if (rl) { - proto->ProtoSendMetaData(opaque, TYPE_OTHER, NULL, "shun", EncodeShun(*iter)); + // Bang. :P + rl->Apply(user); } } - virtual void OnDecodeMetaData(int target_type, void* target, const std::string &extname, const std::string &extdata) + virtual ModResult OnPreCommand(std::string &command, std::vector& parameters, User* user, bool validated, const std::string &original_line) { - if((target_type == TYPE_OTHER) && (extname == "shun")) + if (validated) + return MOD_RES_PASSTHRU; + + if (!ServerInstance->XLines->MatchesLine("SHUN", user)) { - shuns.push_back(DecodeShun(extdata)); - std::sort(shuns.begin(), shuns.end()); + /* Not shunned, don't touch. */ + return MOD_RES_PASSTHRU; } - } - virtual ~ModuleShun() - { + if (!affectopers && IS_OPER(user)) + { + /* Don't do anything if the user is an operator and affectopers isn't set */ + return MOD_RES_PASSTHRU; + } + + std::set::iterator i = ShunEnabledCommands.find(command); + + if (i == ShunEnabledCommands.end()) + { + if (NotifyOfShun) + user->WriteServ("NOTICE %s :*** Command %s not processed, as you have been blocked from issuing commands (SHUN)", user->nick.c_str(), command.c_str()); + return MOD_RES_DENY; + } + + if (command == "QUIT") + { + /* Allow QUIT but dont show any quit message */ + parameters.clear(); + } + else if (command == "PART") + { + /* same for PART */ + parameters[1] = ""; + } + + /* if we're here, allow the command. */ + return MOD_RES_PASSTHRU; } virtual Version GetVersion() { - return Version(1,0,0,0,0,API_VERSION); + return Version("Provides the /shun command, which stops a user executing all commands except PING and PONG.",VF_VENDOR|VF_COMMON,API_VERSION); } };