X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_chanlog.cpp;h=6dbc0e7a860418d1154d36b00646d5bfa38040f4;hb=ccd4c11ea1a43d079eaae9708482ef4a9148796c;hp=a5fcbe5bf2b8ab7b207868c50f962ec87ff9280d;hpb=bb1140e2da4f2d166a9a919f24e596a440dc4df5;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_chanlog.cpp b/src/modules/m_chanlog.cpp index a5fcbe5bf..6dbc0e7a8 100644 --- a/src/modules/m_chanlog.cpp +++ b/src/modules/m_chanlog.cpp @@ -1,131 +1,158 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd: (C) 2002-2008 InspIRCd Development Team - * See: http://www.inspircd.org/wiki/index.php/Credits + * Copyright (C) 2008 Robin Burchell + * Copyright (C) 2008 Thomas Stagner * - * This program is free but copyrighted software; see - * the file COPYING for details. + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. * - * --------------------------------------------------- + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ + #include "inspircd.h" -class ChannelLogStream : public LogStream +/* $ModDesc: Logs snomask output to channel(s). */ + +class ModuleChanLog : public Module { private: - std::string channel; + /* + * Multimap so people can redirect a snomask to multiple channels. + */ + typedef std::multimap ChanLogTargets; + ChanLogTargets logstreams; public: - ChannelLogStream(InspIRCd *Instance, int loglevel, const std::string &chan) : LogStream(Instance, loglevel), channel(chan) + void init() { + Implementation eventlist[] = { I_OnRehash, I_OnSendSnotice }; + ServerInstance->Modules->Attach(eventlist, this, sizeof(eventlist)/sizeof(Implementation)); + + OnRehash(NULL); } - virtual void OnLog(int loglevel, const std::string &type, const std::string &msg) + virtual ~ModuleChanLog() { - Channel *c = ServerInstance->FindChan(channel); + } -printf("I got called\n"); - if (loglevel < this->loglvl) - return; + virtual void OnRehash(User *user) + { + std::string snomasks; + std::string channel; - if (c) + logstreams.clear(); + + ConfigTagList tags = ServerInstance->Config->ConfTags("chanlog"); + for (ConfigIter i = tags.first; i != tags.second; ++i) { - char buf[MAXBUF]; - snprintf(buf, MAXBUF, "\2%s\2: %s", type.c_str(), msg.c_str()); + channel = i->second->getString("channel"); + snomasks = i->second->getString("snomasks"); - c->WriteChannelWithServ(ServerInstance->Config->ServerName, "PRIVMSG %s :%s", c->name, buf); - ServerInstance->PI->SendChannelPrivmsg(c, 0, buf); + if (channel.empty() || snomasks.empty()) + { + ServerInstance->Logs->Log("m_chanlog", DEFAULT, "Malformed chanlog tag, ignoring"); + continue; + } + + for (std::string::const_iterator it = snomasks.begin(); it != snomasks.end(); it++) + { + logstreams.insert(std::make_pair(*it, channel)); + ServerInstance->Logs->Log("m_chanlog", DEFAULT, "Logging %c to %s", *it, channel.c_str()); + } } - } -}; -/* $ModDesc: Logs output to a channel instead of / as well as a file. */ + } -class ModuleChanLog : public Module -{ - private: - std::vector cls; - public: - ModuleChanLog(InspIRCd* Me) : Module(Me) + virtual ModResult OnSendSnotice(char &sno, std::string &desc, const std::string &msg) { - Implementation eventlist[] = { I_OnRehash }; - ServerInstance->Modules->Attach(eventlist, this, 1); + std::pair itpair = logstreams.equal_range(sno); + if (itpair.first == itpair.second) + return MOD_RES_PASSTHRU; - OnRehash(NULL, ""); - } + char buf[MAXBUF]; + snprintf(buf, MAXBUF, "\2%s\2: %s", desc.c_str(), msg.c_str()); - virtual ~ModuleChanLog() - { - std::vector::iterator i; - while ((i = cls.begin()) != cls.end()) + for (ChanLogTargets::const_iterator it = itpair.first; it != itpair.second; ++it) { - ServerInstance->Logs->DelLogStream(*i); - cls.erase(i); + Channel *c = ServerInstance->FindChan(it->second); + if (c) + { + c->WriteChannelWithServ(ServerInstance->Config->ServerName, "PRIVMSG %s :%s", c->name.c_str(), buf); + ServerInstance->PI->SendChannelPrivmsg(c, 0, buf); + } } + + return MOD_RES_PASSTHRU; } - virtual void OnRehash(User *user, const std::string ¶meter) + virtual Version GetVersion() { - ConfigReader Conf(ServerInstance); + return Version("Logs snomask output to channel(s).", VF_VENDOR); + } +}; - /* Since the CloseLogs prior to this hook just wiped out our logstreams for us, we just need to wipe the vector. */ - std::vector().swap(cls); - int index, max = Conf.Enumerate("log"); - cls.reserve(max); - for (index = 0; index < max; ++index) - { - std::string method = Conf.ReadValue("log", "method", index); +MODULE_INIT(ModuleChanLog) - //if (method != "file") - // continue; - std::string type = Conf.ReadValue("log", "type", index); - std::string level = Conf.ReadValue("log", "level", index); - int loglevel = DEFAULT; - if (level == "debug") - { - loglevel = DEBUG; - ServerInstance->Config->debugging = true; - } - else if (level == "verbose") - { - loglevel = VERBOSE; - } - else if (level == "default") - { - loglevel = DEFAULT; - } - else if (level == "sparse") - { - loglevel = SPARSE; - } - else if (level == "none") - { - loglevel = NONE; - } - std::string target = Conf.ReadValue("log", "target", index); -printf("looking at tag with method: %s type: %s level: %s target: %s", method.c_str(), type.c_str(), level.c_str(), target.c_str()); - ChannelLogStream* c = new ChannelLogStream(ServerInstance, loglevel, target); - ServerInstance->Logs->AddLogTypes(type, c, true); - cls.push_back(c); - } - } - virtual Version GetVersion() + +/* + * This is for the "old" chanlog module which intercepted messages going to the logfile.. + * I don't consider it all that useful, and it's quite dangerous if setup incorrectly, so + * this is defined out but left intact in case someone wants to develop it further someday. + * + * -- w00t (aug 23rd, 2008) + */ +#define OLD_CHANLOG 0 + +#if OLD_CHANLOG +class ChannelLogStream : public LogStream +{ + private: + std::string channel; + + public: + ChannelLogStream(int loglevel, const std::string &chan) : LogStream(loglevel), channel(chan) { - return Version(1,2,0,1,VF_VENDOR,API_VERSION); } -}; + virtual void OnLog(int loglevel, const std::string &type, const std::string &msg) + { + Channel *c = ServerInstance->FindChan(channel); + static bool Logging = false; -MODULE_INIT(ModuleChanLog) + if (loglevel < this->loglvl) + return; + + if (Logging) + return; + + if (c) + { + Logging = true; // this avoids (rare chance) loops with logging server IO on networks + char buf[MAXBUF]; + snprintf(buf, MAXBUF, "\2%s\2: %s", type.c_str(), msg.c_str()); + + c->WriteChannelWithServ(ServerInstance->Config->ServerName, "PRIVMSG %s :%s", c->name.c_str(), buf); + ServerInstance->PI->SendChannelPrivmsg(c, 0, buf); + Logging = false; + } + } +}; +#endif