]> git.netwichtig.de Git - user/henk/code/inspircd.git/blobdiff - src/modules/m_permchannels.cpp
Update copyright headers.
[user/henk/code/inspircd.git] / src / modules / m_permchannels.cpp
index a19a184e08bb91d4cdfd05c15581ce99e7815e91..35736bf711e47670a9bc7a4408727758f5c499a2 100644 (file)
@@ -1,7 +1,14 @@
 /*
  * InspIRCd -- Internet Relay Chat Daemon
  *
+ *   Copyright (C) 2014 Justin Crawford <Justasic@Gmail.com>
+ *   Copyright (C) 2013-2014, 2017-2021 Sadie Powell <sadie@witchery.services>
+ *   Copyright (C) 2013-2014, 2016 Attila Molnar <attilamolnar@hush.com>
+ *   Copyright (C) 2012, 2019 Robby <robby@chatbelgie.be>
+ *   Copyright (C) 2012, 2014 Adam <Adam@anope.org>
+ *   Copyright (C) 2010 Craig Edwards <brain@inspircd.org>
  *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
+ *   Copyright (C) 2009 Uli Schlachter <psychon@inspircd.org>
  *   Copyright (C) 2008-2009 Robin Burchell <robin+git@viroteck.net>
  *
  * This file is part of InspIRCd.  InspIRCd is free software: you can
 #include <fstream>
 
 
-struct ListModeData
-{
-       std::string modes;
-       std::string params;
-};
-
 /** Handles the +P channel mode
  */
 class PermChannel : public ModeHandler
@@ -40,7 +41,7 @@ class PermChannel : public ModeHandler
                oper = true;
        }
 
-       ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding)
+       ModeAction OnModeChange(User* source, User* dest, Channel* channel, std::string& parameter, bool adding) CXX11_OVERRIDE
        {
                if (adding == channel->IsModeSet(this))
                        return MODEACTION_DENY;
@@ -53,17 +54,16 @@ class PermChannel : public ModeHandler
        }
 };
 
-// Not in a class due to circular dependancy hell.
+// Not in a class due to circular dependency hell.
 static std::string permchannelsconf;
 static bool WriteDatabase(PermChannel& permchanmode, Module* mod, bool save_listmodes)
 {
-       ChanModeReference ban(mod, "ban");
        /*
         * We need to perform an atomic write so as not to fuck things up.
         * So, let's write to a temporary file, flush it, then rename the file..
         *     -- w00t
         */
-       
+
        // If the user has not specified a configuration file then we don't write one.
        if (permchannelsconf.empty())
                return true;
@@ -72,15 +72,19 @@ static bool WriteDatabase(PermChannel& permchanmode, Module* mod, bool save_list
        std::ofstream stream(permchannelsnewconf.c_str());
        if (!stream.is_open())
        {
-               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Cannot create database! %s (%d)", strerror(errno), errno);
-               ServerInstance->SNO->WriteToSnoMask('a', "database: cannot create new db: %s (%d)", strerror(errno), errno);
+               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Cannot create database \"%s\"! %s (%d)", permchannelsnewconf.c_str(), strerror(errno), errno);
+               ServerInstance->SNO->WriteToSnoMask('a', "database: cannot create new permchan db \"%s\": %s (%d)", permchannelsnewconf.c_str(), strerror(errno), errno);
                return false;
        }
-       
-       stream << "# This file is automatically generated by m_permchannels. Any changes will be overwritten." << std::endl
+
+       stream
+               << "# This file was automatically generated by the " << INSPIRCD_VERSION << " permchannels module on " << InspIRCd::TimeString(ServerInstance->Time()) << "." << std::endl
+               << "# Any changes to this file will be automatically overwritten." << std::endl
+               << std::endl
                << "<config format=\"xml\">" << std::endl;
 
-       for (chan_hash::const_iterator i = ServerInstance->chanlist->begin(); i != ServerInstance->chanlist->end(); i++)
+       const chan_hash& chans = ServerInstance->GetChans();
+       for (chan_hash::const_iterator i = chans.begin(); i != chans.end(); ++i)
        {
                Channel* chan = i->second;
                if (!chan->IsModeSet(permchanmode))
@@ -89,33 +93,45 @@ static bool WriteDatabase(PermChannel& permchanmode, Module* mod, bool save_list
                std::string chanmodes = chan->ChanModes(true);
                if (save_listmodes)
                {
-                       ListModeData lm;
+                       std::string modes;
+                       std::string params;
 
-                       // Bans are managed by the core, so we have to process them separately
-                       static_cast<ListModeBase*>(*ban)->DoSyncChannel(chan, mod, &lm);
+                       const ModeParser::ListModeList& listmodes = ServerInstance->Modes->GetListModes();
+                       for (ModeParser::ListModeList::const_iterator j = listmodes.begin(); j != listmodes.end(); ++j)
+                       {
+                               ListModeBase* lm = *j;
+                               ListModeBase::ModeList* list = lm->GetList(chan);
+                               if (!list || list->empty())
+                                       continue;
 
-                       // All other listmodes are managed by modules, so we need to ask them (call their
-                       // OnSyncChannel() handler) to give our ProtoSendMode() a list of modes that are
-                       // set on the channel. The ListModeData struct is passed as an opaque pointer
-                       // that will be passed back to us by the module handling the mode.
-                       FOREACH_MOD(OnSyncChannel, (chan, mod, &lm));
+                               size_t n = 0;
+                               // Append the parameters
+                               for (ListModeBase::ModeList::const_iterator k = list->begin(); k != list->end(); ++k, n++)
+                               {
+                                       params += k->mask;
+                                       params += ' ';
+                               }
+
+                               // Append the mode letters (for example "IIII", "gg")
+                               modes.append(n, lm->GetModeChar());
+                       }
 
-                       if (!lm.modes.empty())
+                       if (!params.empty())
                        {
                                // Remove the last space
-                               lm.params.erase(lm.params.end()-1);
+                               params.erase(params.end()-1);
 
                                // If there is at least a space in chanmodes (that is, a non-listmode has a parameter)
                                // insert the listmode mode letters before the space. Otherwise just append them.
                                std::string::size_type p = chanmodes.find(' ');
                                if (p == std::string::npos)
-                                       chanmodes += lm.modes;
+                                       chanmodes += modes;
                                else
-                                       chanmodes.insert(p, lm.modes);
+                                       chanmodes.insert(p, modes);
 
                                // Append the listmode parameters (the masks themselves)
                                chanmodes += ' ';
-                               chanmodes += lm.params;
+                               chanmodes += params;
                        }
                }
 
@@ -130,80 +146,54 @@ static bool WriteDatabase(PermChannel& permchanmode, Module* mod, bool save_list
 
        if (stream.fail())
        {
-               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Cannot write to new database! %s (%d)", strerror(errno), errno);
-               ServerInstance->SNO->WriteToSnoMask('a', "database: cannot write to new db: %s (%d)", strerror(errno), errno);
+               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Cannot write to new database \"%s\"! %s (%d)", permchannelsnewconf.c_str(), strerror(errno), errno);
+               ServerInstance->SNO->WriteToSnoMask('a', "database: cannot write to new permchan db \"%s\": %s (%d)", permchannelsnewconf.c_str(), strerror(errno), errno);
                return false;
        }
        stream.close();
 
 #ifdef _WIN32
-       if (remove(permchannelsconf.c_str()))
-       {
-               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Cannot remove old database! %s (%d)", strerror(errno), errno);
-               ServerInstance->SNO->WriteToSnoMask('a', "database: cannot remove old database: %s (%d)", strerror(errno), errno);
-               return false;
-       }
+       remove(permchannelsconf.c_str());
 #endif
-       // Use rename to move temporary to new db - this is guarenteed not to fuck up, even in case of a crash.
+       // Use rename to move temporary to new db - this is guaranteed not to fuck up, even in case of a crash.
        if (rename(permchannelsnewconf.c_str(), permchannelsconf.c_str()) < 0)
        {
-               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Cannot move new to old database! %s (%d)", strerror(errno), errno);
-               ServerInstance->SNO->WriteToSnoMask('a', "database: cannot replace old with new db: %s (%d)", strerror(errno), errno);
+               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Cannot replace old database \"%s\" with new database \"%s\"! %s (%d)", permchannelsconf.c_str(), permchannelsnewconf.c_str(), strerror(errno), errno);
+               ServerInstance->SNO->WriteToSnoMask('a', "database: cannot replace old permchan db \"%s\" with new db \"%s\": %s (%d)", permchannelsconf.c_str(), permchannelsnewconf.c_str(), strerror(errno), errno);
                return false;
        }
 
        return true;
 }
 
-class ModulePermanentChannels : public Module
+class ModulePermanentChannels
+       : public Module
+       , public Timer
+
 {
        PermChannel p;
        bool dirty;
+       bool loaded;
        bool save_listmodes;
 public:
 
-       ModulePermanentChannels() : p(this), dirty(false)
-       {
-       }
-
-       void init() CXX11_OVERRIDE
+       ModulePermanentChannels()
+               : Timer(0, true)
+               , p(this)
+               , dirty(false)
+               , loaded(false)
        {
-               ServerInstance->Modules->AddService(p);
-
-               OnRehash(NULL);
        }
 
-       CullResult cull()
-       {
-               /*
-                * DelMode can't remove the +P mode on empty channels, or it will break
-                * merging modes with remote servers. Remove the empty channels now as
-                * we know this is not the case.
-                */
-               chan_hash::iterator iter = ServerInstance->chanlist->begin();
-               while (iter != ServerInstance->chanlist->end())
-               {
-                       Channel* c = iter->second;
-                       if (c->GetUserCounter() == 0)
-                       {
-                               chan_hash::iterator at = iter;
-                               iter++;
-                               FOREACH_MOD(OnChannelDelete, (c));
-                               ServerInstance->chanlist->erase(at);
-                               ServerInstance->GlobalCulls.AddItem(c);
-                       }
-                       else
-                               iter++;
-               }
-               ServerInstance->Modes->DelMode(&p);
-               return Module::cull();
-       }
-
-       void OnRehash(User *user) CXX11_OVERRIDE
+       void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
        {
                ConfigTag* tag = ServerInstance->Config->ConfValue("permchanneldb");
                permchannelsconf = tag->getString("filename");
-               save_listmodes = tag->getBool("listmodes");
+               save_listmodes = tag->getBool("listmodes", true);
+               SetInterval(tag->getDuration("saveperiod", 5));
+
+               if (!permchannelsconf.empty())
+                       permchannelsconf = ServerInstance->Config->Paths.PrependConfig(permchannelsconf);
        }
 
        void LoadDatabase()
@@ -219,9 +209,9 @@ public:
                        std::string channel = tag->getString("channel");
                        std::string modes = tag->getString("modes");
 
-                       if ((channel.empty()) || (channel.length() > ServerInstance->Config->Limits.ChanMax))
+                       if (!ServerInstance->IsChannel(channel))
                        {
-                               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Ignoring permchannels tag with empty or too long channel name (\"" + channel + "\")");
+                               ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Ignoring permchannels tag with invalid channel name (\"" + channel + "\")");
                                continue;
                        }
 
@@ -232,17 +222,17 @@ public:
                                time_t TS = tag->getInt("ts", ServerInstance->Time(), 1);
                                c = new Channel(channel, TS);
 
-                               unsigned int topicset = tag->getInt("topicts");
-                               c->topic = tag->getString("topic");
+                               time_t topicset = tag->getInt("topicts", 0);
+                               std::string topic = tag->getString("topic");
 
-                               if ((topicset != 0) || (!c->topic.empty()))
+                               if ((topicset != 0) || (!topic.empty()))
                                {
                                        if (topicset == 0)
                                                topicset = ServerInstance->Time();
-                                       c->topicset = topicset;
-                                       c->setby = tag->getString("topicsetby");
-                                       if (c->setby.empty())
-                                               c->setby = ServerInstance->Config->ServerName;
+                                       std::string topicsetby = tag->getString("topicsetby");
+                                       if (topicsetby.empty())
+                                               topicsetby = ServerInstance->Config->GetServerName();
+                                       c->SetTopic(ServerInstance->FakeClient, topic, topicset, &topicsetby);
                                }
 
                                ServerInstance->Logs->Log(MODNAME, LOG_DEBUG, "Added %s with topic %s", channel.c_str(), c->topic.c_str());
@@ -262,7 +252,7 @@ public:
                                        ModeHandler* mode = ServerInstance->Modes->FindMode(*n, MODETYPE_CHANNEL);
                                        if (mode)
                                        {
-                                               if (mode->GetNumParams(true))
+                                               if (mode->NeedsParam(true))
                                                        list.GetToken(par);
                                                else
                                                        par.clear();
@@ -270,13 +260,17 @@ public:
                                                mode->OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, c, par, true);
                                        }
                                }
+
+                               // We always apply the permchannels mode to permanent channels.
+                               par.clear();
+                               p.OnModeChange(ServerInstance->FakeClient, ServerInstance->FakeClient, c, par, true);
                        }
                }
        }
 
-       ModResult OnRawMode(User* user, Channel* chan, const char mode, const std::string &param, bool adding, int pcnt) CXX11_OVERRIDE
+       ModResult OnRawMode(User* user, Channel* chan, ModeHandler* mh, const std::string& param, bool adding) CXX11_OVERRIDE
        {
-               if (chan && (chan->IsModeSet(p) || mode == p.GetModeChar()))
+               if (chan && (chan->IsModeSet(p) || mh == &p))
                        dirty = true;
 
                return MOD_RES_PASSTHRU;
@@ -288,22 +282,21 @@ public:
                        dirty = true;
        }
 
-       void OnBackgroundTimer(time_t) CXX11_OVERRIDE
+       bool Tick(time_t) CXX11_OVERRIDE
        {
                if (dirty)
                        WriteDatabase(p, this, save_listmodes);
                dirty = false;
+               return true;
        }
 
-       void Prioritize()
+       void Prioritize() CXX11_OVERRIDE
        {
                // XXX: Load the DB here because the order in which modules are init()ed at boot is
                // alphabetical, this means we must wait until all modules have done their init()
                // to be able to set the modes they provide (e.g.: m_stripcolor is inited after us)
                // Prioritize() is called after all module initialization is complete, consequently
                // all modes are available now
-
-               static bool loaded = false;
                if (loaded)
                        return;
 
@@ -327,28 +320,9 @@ public:
                }
        }
 
-       void ProtoSendMode(void* opaque, TargetTypeFlags type, void* target, const std::vector<std::string>& modes, const std::vector<TranslateType>& translate)
-       {
-               // We never pass an empty modelist but better be sure
-               if (modes.empty())
-                       return;
-
-               ListModeData* lm = static_cast<ListModeData*>(opaque);
-
-               // Append the mode letters without the trailing '+' (for example "IIII", "gg")
-               lm->modes.append(modes[0].begin()+1, modes[0].end());
-
-               // Append the parameters
-               for (std::vector<std::string>::const_iterator i = modes.begin()+1; i != modes.end(); ++i)
-               {
-                       lm->params += *i;
-                       lm->params += ' ';
-               }
-       }
-
        Version GetVersion() CXX11_OVERRIDE
        {
-               return Version("Provides support for channel mode +P to provide permanent channels",VF_VENDOR);
+               return Version("Adds channel mode P (permanent) which prevents the channel from being deleted when the last user leaves.", VF_VENDOR);
        }
 
        ModResult OnChannelPreDelete(Channel *c) CXX11_OVERRIDE