src/listmode.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2009 Daniel De Graaf <danieldg@inspircd.org>
   5  *
   6  * This file is part of InspIRCd.  InspIRCd is free software: you can
   7  * redistribute it and/or modify it under the terms of the GNU General Public
   8  * License as published by the Free Software Foundation, version 2.
   9  *
  10  * This program is distributed in the hope that it will be useful, but WITHOUT
  11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  12  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  13  * details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "inspircd.h"
  20 #include "listmode.h"
  21
  22 ListModeBase::ListModeBase(Module* Creator, const std::string& Name, char modechar, const std::string &eolstr, unsigned int lnum, unsigned int eolnum, bool autotidy, const std::string &ctag)
  23         : ModeHandler(Creator, Name, modechar, PARAM_ALWAYS, MODETYPE_CHANNEL, MC_LIST),
  24         listnumeric(lnum), endoflistnumeric(eolnum), endofliststring(eolstr), tidy(autotidy),
  25         configtag(ctag)
  26         , extItem("listbase_mode_" + name + "_list", ExtensionItem::EXT_CHANNEL, Creator)
  27 {
  28         list = true;
  29 }
  30
  31 void ListModeBase::DisplayList(User* user, Channel* channel)
  32 {
  33         ChanData* cd = extItem.get(channel);
  34         if (cd)
  35         {
  36                 for (ModeList::const_iterator it = cd->list.begin(); it != cd->list.end(); ++it)
  37                 {
  38                         user->WriteNumeric(listnumeric, channel->name, it->mask, it->setter, (unsigned long) it->time);
  39                 }
  40         }
  41         user->WriteNumeric(endoflistnumeric, channel->name, endofliststring);
  42 }
  43
  44 void ListModeBase::DisplayEmptyList(User* user, Channel* channel)
  45 {
  46         user->WriteNumeric(endoflistnumeric, channel->name, endofliststring);
  47 }
  48
  49 void ListModeBase::RemoveMode(Channel* channel, Modes::ChangeList& changelist)
  50 {
  51         ChanData* cd = extItem.get(channel);
  52         if (cd)
  53         {
  54                 for (ModeList::iterator it = cd->list.begin(); it != cd->list.end(); it++)
  55                 {
  56                         changelist.push_remove(this, it->mask);
  57                 }
  58         }
  59 }
  60
  61 void ListModeBase::DoRehash()
  62 {
  63         ConfigTagList tags = ServerInstance->Config->ConfTags(configtag);
  64
  65         limitlist oldlimits = chanlimits;
  66         chanlimits.clear();
  67
  68         for (ConfigIter i = tags.first; i != tags.second; i++)
  69         {
  70                 // For each <banlist> tag
  71                 ConfigTag* c = i->second;
  72                 ListLimit limit(c->getString("chan"), c->getInt("limit"));
  73
  74                 if (limit.mask.size() && limit.limit > 0)
  75                         chanlimits.push_back(limit);
  76         }
  77
  78         // Add the default entry. This is inserted last so if the user specifies a
  79         // wildcard record in the config it will take precedence over this entry.
  80         chanlimits.push_back(ListLimit("*", DEFAULT_LIST_SIZE));
  81
  82         // Most of the time our settings are unchanged, so we can avoid iterating the chanlist
  83         if (oldlimits == chanlimits)
  84                 return;
  85
  86         const chan_hash& chans = ServerInstance->GetChans();
  87         for (chan_hash::const_iterator i = chans.begin(); i != chans.end(); ++i)
  88         {
  89                 ChanData* cd = extItem.get(i->second);
  90                 if (cd)
  91                         cd->maxitems = -1;
  92         }
  93 }
  94
  95 unsigned int ListModeBase::FindLimit(const std::string& channame)
  96 {
  97         for (limitlist::iterator it = chanlimits.begin(); it != chanlimits.end(); ++it)
  98         {
  99                 if (InspIRCd::Match(channame, it->mask))
 100                 {
 101                         // We have a pattern matching the channel
 102                         return it->limit;
 103                 }
 104         }
 105         return DEFAULT_LIST_SIZE;
 106 }
 107
 108 unsigned int ListModeBase::GetLimitInternal(const std::string& channame, ChanData* cd)
 109 {
 110         if (cd->maxitems < 0)
 111                 cd->maxitems = FindLimit(channame);
 112         return cd->maxitems;
 113 }
 114
 115 unsigned int ListModeBase::GetLimit(Channel* channel)
 116 {
 117         ChanData* cd = extItem.get(channel);
 118         if (!cd) // just find the limit
 119                 return FindLimit(channel->name);
 120
 121         return GetLimitInternal(channel->name, cd);
 122 }
 123
 124 unsigned int ListModeBase::GetLowerLimit()
 125 {
 126         unsigned int limit = UINT_MAX;
 127         for (limitlist::iterator iter = chanlimits.begin(); iter != chanlimits.end(); ++iter)
 128         {
 129                 if (iter->limit < limit)
 130                         limit = iter->limit;
 131         }
 132         return limit == UINT_MAX ? DEFAULT_LIST_SIZE : limit;
 133 }
 134
 135 ModeAction ListModeBase::OnModeChange(User* source, User*, Channel* channel, std::string &parameter, bool adding)
 136 {
 137         // Try and grab the list
 138         ChanData* cd = extItem.get(channel);
 139
 140         if (adding)
 141         {
 142                 if (tidy)
 143                         ModeParser::CleanMask(parameter);
 144
 145                 if (parameter.length() > 250)
 146                         return MODEACTION_DENY;
 147
 148                 // If there was no list
 149                 if (!cd)
 150                 {
 151                         // Make one
 152                         cd = new ChanData;
 153                         extItem.set(channel, cd);
 154                 }
 155
 156                 // Check if the item already exists in the list
 157                 for (ModeList::iterator it = cd->list.begin(); it != cd->list.end(); it++)
 158                 {
 159                         if (parameter == it->mask)
 160                         {
 161                                 /* Give a subclass a chance to error about this */
 162                                 TellAlreadyOnList(source, channel, parameter);
 163
 164                                 // it does, deny the change
 165                                 return MODEACTION_DENY;
 166                         }
 167                 }
 168
 169                 if ((IS_LOCAL(source)) && (cd->list.size() >= GetLimitInternal(channel->name, cd)))
 170                 {
 171                         /* List is full, give subclass a chance to send a custom message */
 172                         TellListTooLong(source, channel, parameter);
 173                         return MODEACTION_DENY;
 174                 }
 175
 176                 /* Ok, it *could* be allowed, now give someone subclassing us
 177                  * a chance to validate the parameter.
 178                  * The param is passed by reference, so they can both modify it
 179                  * and tell us if we allow it or not.
 180                  *
 181                  * eg, the subclass could:
 182                  * 1) allow
 183                  * 2) 'fix' parameter and then allow
 184                  * 3) deny
 185                  */
 186                 if (ValidateParam(source, channel, parameter))
 187                 {
 188                         // And now add the mask onto the list...
 189                         cd->list.push_back(ListItem(parameter, source->nick, ServerInstance->Time()));
 190                         return MODEACTION_ALLOW;
 191                 }
 192                 else
 193                 {
 194                         /* If they deny it they have the job of giving an error message */
 195                         return MODEACTION_DENY;
 196                 }
 197         }
 198         else
 199         {
 200                 // We're taking the mode off
 201                 if (cd)
 202                 {
 203                         for (ModeList::iterator it = cd->list.begin(); it != cd->list.end(); ++it)
 204                         {
 205                                 if (parameter == it->mask)
 206                                 {
 207                                         stdalgo::vector::swaperase(cd->list, it);
 208                                         return MODEACTION_ALLOW;
 209                                 }
 210                         }
 211                 }
 212
 213                 /* Tried to remove something that wasn't set */
 214                 TellNotSet(source, channel, parameter);
 215                 return MODEACTION_DENY;
 216         }
 217 }
 218
 219 bool ListModeBase::ValidateParam(User*, Channel*, std::string&)
 220 {
 221         return true;
 222 }
 223
 224 void ListModeBase::TellListTooLong(User* source, Channel* channel, std::string& parameter)
 225 {
 226         source->WriteNumeric(ERR_BANLISTFULL, channel->name, parameter, "Channel ban list is full");
 227 }
 228
 229 void ListModeBase::TellAlreadyOnList(User*, Channel*, std::string&)
 230 {
 231 }
 232
 233 void ListModeBase::TellNotSet(User*, Channel*, std::string&)
 234 {
 235 }