X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_safelist.cpp;h=0160de7c2458a18e3c384495cb198dda39a57b85;hb=6d03943426dcce76ba66567a9b18425a5ebb4c0c;hp=6e1789097d7635d0b2dbf43269fc37e3643a9958;hpb=aaf5226111f515f4baa68e95ea6a1db740828ac3;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_safelist.cpp b/src/modules/m_safelist.cpp index 6e1789097..0160de7c2 100644 --- a/src/modules/m_safelist.cpp +++ b/src/modules/m_safelist.cpp @@ -2,284 +2,235 @@ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * - * InspIRCd is copyright (C) 2002-2006 ChatSpike-Dev. - * E-mail: - * - * - * - * Written by Craig Edwards, Craig McLure, and others. + * 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. * * --------------------------------------------------- */ -using namespace std; - -#include "users.h" -#include "channels.h" -#include "modules.h" -#include "helperfuncs.h" -#include "message.h" -#include - -extern time_t TIME; - -class ListData +#include "inspircd.h" + +/** Holds a users m_safelist state + */ +class ListData : public classbase { public: long list_start; long list_position; bool list_ended; + const std::string glob; + int minusers; + int maxusers; ListData() : list_start(0), list_position(0), list_ended(false) {}; - ListData(long pos, time_t t) : list_start(t), list_position(pos), list_ended(false) {}; + ListData(long pos, time_t t, const std::string &pattern, int mi, int ma) : list_start(t), list_position(pos), list_ended(false), glob(pattern), minusers(mi), maxusers(ma) {}; }; /* $ModDesc: A module overriding /list, and making it safe - stop those sendq problems. */ - -typedef std::vector UserList; -UserList listusers; /* vector of people doing a /list */ - -/* - * To create a timer which recurs every second, we inherit from InspTimer. - * InspTimer is only one-shot however, so at the end of each Tick() we simply - * insert another of ourselves into the pending queue :) - */ -class ListTimer : public InspTimer -{ - private: - - Server* Srv; - char buffer[MAXBUF]; - chanrec *chan; - - public: - - ListTimer(long interval, Server* Me) : InspTimer(interval,TIME), Srv(Me) - { - } - - virtual void Tick(time_t TIME) - { - bool go_again = true; - - while (go_again) - { - go_again = false; - for (UserList::iterator iter = listusers.begin(); iter != listusers.end(); iter++) - { - /* - * What we do here: - * - Get where they are up to - * - If it's > GetChannelCount, erase them from the iterator, set go_again to true - * - If not, spool the next 20 channels - */ - userrec* u = (userrec*)(*iter); - ListData* ld = (ListData*)u->GetExt("safelist_cache"); - if (ld->list_position > Srv->GetChannelCount()) - { - u->Shrink("safelist_cache"); - delete ld; - listusers.erase(iter); - go_again = true; - break; - } - - log(DEBUG, "m_safelist.so: resuming spool of list to client %s at channel %ld", u->nick, ld->list_position); - chan = NULL; - /* Attempt to fill up to half the user's sendq with /LIST output */ - long amount_sent = 0; - do - { - log(DEBUG,"Channel %ld",ld->list_position); - if (!ld->list_position) - WriteServ(u->fd,"321 %s Channel :Users Name",u->nick); - chan = Srv->GetChannelIndex(ld->list_position); - /* spool details */ - bool has_user = chan->HasUser(u); - if ((chan) && (((!(chan->binarymodes & CM_PRIVATE)) && (!(chan->binarymodes & CM_SECRET))) || (has_user))) - { - /* Increment total plus linefeed */ - int counter = snprintf(buffer,MAXBUF,"322 %s %s %d :[+%s] %s",u->nick,chan->name,usercount_i(chan),chanmodes(chan,has_user),chan->topic); - amount_sent += counter + 4 + Srv->GetServerName().length(); - log(DEBUG,"m_safelist.so: Sent %ld of safe %ld / 4",amount_sent,u->sendqmax); - WriteServ_NoFormat(u->fd,buffer); - } - else - { - if (!chan) - { - if (!ld->list_ended) - { - ld->list_ended = true; - WriteServ(u->fd,"323 %s :End of channel list.",u->nick); - } - } - } - - ld->list_position++; - } - while ((chan != NULL) && (amount_sent < (u->sendqmax / 4))); - } - } - - ListTimer* MyTimer = new ListTimer(1,Srv); - Srv->AddTimer(MyTimer); - } -}; class ModuleSafeList : public Module { - private: - Server *Srv; - ListTimer* MyTimer; + time_t ThrottleSecs; + size_t ServerNameSize; + int global_listing; + int LimitList; + SimpleExtItem listData; + LocalIntExt listTime; public: - ModuleSafeList(Server* Me) : Module::Module(Me) + ModuleSafeList() : listData("safelist_data", this), listTime("safelist_last", this) { - Srv = Me; - - MyTimer = new ListTimer(1,Srv); - Srv->AddTimer(MyTimer); + OnRehash(NULL); + Extensible::Register(&listData); + Extensible::Register(&listTime); + Implementation eventlist[] = { I_OnBufferFlushed, I_OnPreCommand, I_On005Numeric, I_OnRehash }; + ServerInstance->Modules->Attach(eventlist, this, 4); } - - virtual ~ModuleSafeList() + + ~ModuleSafeList() { } - - virtual Version GetVersion() + + void OnRehash(User* user) { - return Version(1,0,0,0,VF_VENDOR); + ConfigReader MyConf; + ThrottleSecs = MyConf.ReadInteger("safelist", "throttle", "60", 0, true); + LimitList = MyConf.ReadInteger("safelist", "maxlisters", "50", 0, true); + ServerNameSize = strlen(ServerInstance->Config->ServerName) + 4; + global_listing = 0; } - - void Implements(char* List) + + Version GetVersion() { - List[I_OnPreCommand] = List[I_OnCleanup] = List[I_OnUserQuit] = List[I_On005Numeric] = 1; + return Version("A module overriding /list, and making it safe - stop those sendq problems.",VF_VENDOR,API_VERSION); } + /* * OnPreCommand() * Intercept the LIST command. - */ - virtual int OnPreCommand(std::string command, char **parameters, int pcnt, userrec *user, bool validated) + */ + ModResult OnPreCommand(std::string &command, std::vector ¶meters, User *user, bool validated, const std::string &original_line) { /* If the command doesnt appear to be valid, we dont want to mess with it. */ if (!validated) - return 0; - + return MOD_RES_PASSTHRU; + if (command == "LIST") { - return this->HandleList(parameters, pcnt, user); + return this->HandleList(parameters, user); } - return 0; + return MOD_RES_PASSTHRU; } - + /* * HandleList() * Handle (override) the LIST command. */ - int HandleList(char** parameters, int pcnt, userrec* user) + ModResult HandleList(const std::vector ¶meters, User* user) { + int pcnt = parameters.size(); + int minusers = 0, maxusers = 0; + + if (global_listing >= LimitList && !IS_OPER(user)) + { + user->WriteServ("NOTICE %s :*** Server load is currently too heavy. Please try again later.", user->nick.c_str()); + user->WriteNumeric(321, "%s Channel :Users Name",user->nick.c_str()); + user->WriteNumeric(323, "%s :End of channel list.",user->nick.c_str()); + return MOD_RES_DENY; + } + /* First, let's check if the user is currently /list'ing */ - ListData *ld = (ListData*)user->GetExt("safelist_cache"); - + ListData *ld = listData.get(user); + if (ld) { /* user is already /list'ing, we don't want to do shit. */ - return 1; + return MOD_RES_DENY; } - time_t* last_list_time = (time_t*)user->GetExt("safelist_last"); - if (last_list_time) + /* Work around mIRC suckyness. YOU SUCK, KHALED! */ + if (pcnt == 1) { - if (TIME < (*last_list_time)+60) + if (parameters[0][0] == '<') { - WriteServ(user->fd,"NOTICE %s :*** Woah there, slow down a little, you can't /LIST so often!",user->nick); - return 1; + maxusers = atoi(parameters[0].c_str()+1); + ServerInstance->Logs->Log("m_safelist",DEBUG,"Max users: %d", maxusers); + pcnt = 0; } + else if (parameters[0][0] == '>') + { + minusers = atoi(parameters[0].c_str()+1); + ServerInstance->Logs->Log("m_safelist",DEBUG,"Min users: %d", minusers); + pcnt = 0; + } + } - delete last_list_time; - user->Shrink("safelist_last"); + time_t last_list_time = listTime.get(user); + if (last_list_time && ServerInstance->Time() < last_list_time + ThrottleSecs) + { + user->WriteServ("NOTICE %s :*** Woah there, slow down a little, you can't /LIST so often!",user->nick.c_str()); + user->WriteNumeric(321, "%s Channel :Users Name",user->nick.c_str()); + user->WriteNumeric(323, "%s :End of channel list.",user->nick.c_str()); + return MOD_RES_DENY; } - + /* * start at channel 0! ;) */ - ld = new ListData(0,TIME); - user->Extend("safelist_cache", (char*)ld); - listusers.push_back(user); - - time_t* llt = new time_t; - *llt = TIME; - user->Extend("safelist_last",(char*)llt); - - return 1; + ld = new ListData(0,ServerInstance->Time(), (pcnt && (parameters[0][0] != '<' && parameters[0][0] != '>')) ? parameters[0] : "*", minusers, maxusers); + listData.set(user, ld); + listTime.set(user, ServerInstance->Time()); + + user->WriteNumeric(321, "%s Channel :Users Name",user->nick.c_str()); + + global_listing++; + + return MOD_RES_DENY; } - virtual void OnCleanup(int target_type, void* item) - { - if(target_type == TYPE_USER) + void OnBufferFlushed(User* user) + { + char buffer[MAXBUF]; + ListData* ld = listData.get(user); + if (ld) { - userrec* u = (userrec*)item; - ListData* ld = (ListData*)u->GetExt("safelist_cache"); - if (ld) - { - u->Shrink("safelist_cache"); - delete ld; - } - for (UserList::iterator iter = listusers.begin(); iter != listusers.end(); iter++) + Channel* chan = NULL; + unsigned long amount_sent = 0; + do { - userrec* u2 = (userrec*)(*iter); - if (u2 == u) + chan = ServerInstance->GetChannelIndex(ld->list_position); + bool is_special = (chan && (chan->HasUser(user) || user->HasPrivPermission("channels/auspex"))); + long users = chan ? chan->GetUserCounter() : 0; + + bool too_few = (ld->minusers && (users <= ld->minusers)); + bool too_many = (ld->maxusers && (users >= ld->maxusers)); + + if (chan && (too_many || too_few)) + { + ld->list_position++; + continue; + } + + if (chan) + { + bool display = (InspIRCd::Match(chan->name, ld->glob) || (!chan->topic.empty() && InspIRCd::Match(chan->topic, ld->glob))); + + if (!users || !display) + { + ld->list_position++; + continue; + } + + /* +s, not in chan / not got channels/auspex */ + if (chan->IsModeSet('s') && !is_special) + { + ld->list_position++; + continue; + } + + if (chan->IsModeSet('p') && !is_special) + { + /* Channel is +p and user is outside/not privileged */ + int counter = snprintf(buffer, MAXBUF, "322 %s * %ld :", user->nick.c_str(), users); + amount_sent += counter + ServerNameSize; + user->WriteServ(std::string(buffer)); + } + else + { + /* User is in the channel/privileged, channel is not +s */ + int counter = snprintf(buffer, MAXBUF, "322 %s %s %ld :[+%s] %s", user->nick.c_str(), chan->name.c_str(), users, chan->ChanModes(is_special), chan->topic.c_str()); + amount_sent += counter + ServerNameSize; + user->WriteServ(std::string(buffer)); + } + } + else { - listusers.erase(iter); - break; + if (!ld->list_ended) + { + ld->list_ended = true; + user->WriteNumeric(323, "%s :End of channel list.",user->nick.c_str()); + } } + + ld->list_position++; } - time_t* last_list_time = (time_t*)u->GetExt("safelist_last"); - if (last_list_time) + while ((chan != NULL) && (amount_sent < (user->MyClass->GetSendqMax() / 4))); + if (ld->list_ended) { - delete last_list_time; - u->Shrink("safelist_last"); + listData.unset(user); + global_listing--; } } } - virtual void On005Numeric(std::string &output) + void On005Numeric(std::string &output) { output.append(" SAFELIST"); } - virtual void OnUserQuit(userrec* user, std::string message) - { - this->OnCleanup(TYPE_USER,user); - } - }; - - - -/******************************************************************************************************/ - -class ModuleSafeListFactory : public ModuleFactory -{ - public: - ModuleSafeListFactory() - { - } - - ~ModuleSafeListFactory() - { - } - - virtual Module * CreateModule(Server* Me) - { - return new ModuleSafeList(Me); - } - -}; - -extern "C" void * init_module( void ) -{ - return new ModuleSafeListFactory; -} + +MODULE_INIT(ModuleSafeList)