X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fm_hostchange.cpp;h=8d7abede47bbaca538b9db5465900bd5095ce5fd;hb=7ba36f5348a6cca1c0da820c60ae17063f3cdad5;hp=f7ff58fa17aba57b79e9723f2b867c3a11ebb961;hpb=bab14f0dd2345c9d7dcbc47c918563709e1ac094;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/m_hostchange.cpp b/src/modules/m_hostchange.cpp index f7ff58fa1..8d7abede4 100644 --- a/src/modules/m_hostchange.cpp +++ b/src/modules/m_hostchange.cpp @@ -1 +1,244 @@ -/* +------------------------------------+ * | Inspire Internet Relay Chat Daemon | * +------------------------------------+ * * InspIRCd: (C) 2002-2007 InspIRCd Development Team * See: http://www.inspircd.org/wiki/index.php/Credits * * This program is free but copyrighted software; see * the file COPYING for details. * * --------------------------------------------------- */ #include "inspircd.h" #include "users.h" #include "channels.h" #include "modules.h" /* $ModDesc: Provides masking of user hostnames in a different way to m_cloaking */ /** Holds information on a host set by m_hostchange */ class Host : public classbase { public: std::string action; std::string newhost; }; typedef std::map hostchanges_t; class ModuleHostChange : public Module { private: hostchanges_t hostchanges; std::string MySuffix; std::string MyPrefix; std::string MySeparator; public: ModuleHostChange(InspIRCd* Me) : Module(Me) { OnRehash(NULL,""); } virtual ~ModuleHostChange() { for (hostchanges_t::iterator i = hostchanges.begin(); i != hostchanges.end(); i++) { DELETE(i->second); } hostchanges.clear(); } Priority Prioritize() { return (Priority)ServerInstance->PriorityAfter("m_cloaking.so"); } void Implements(char* List) { List[I_OnRehash] = List[I_OnUserConnect] = 1; } virtual void OnRehash(userrec* user, const std::string ¶meter) { ConfigReader Conf(ServerInstance); MySuffix = Conf.ReadValue("host","suffix",0); MyPrefix = Conf.ReadValue("host","prefix","",0); MySeparator = Conf.ReadValue("host","separator",".",0); for (hostchanges_t::iterator i = hostchanges.begin(); i != hostchanges.end(); i++) { DELETE(i->second); } hostchanges.clear(); for (int index = 0; index < Conf.Enumerate("hostchange"); index++) { std::string mask = Conf.ReadValue("hostchange","mask",index); std::string action = Conf.ReadValue("hostchange","action",index); std::string newhost = Conf.ReadValue("hostchange","value",index); Host* x = new Host; x->action = action; x->newhost = newhost; hostchanges[mask] = x; } } virtual Version GetVersion() { // returns the version number of the module to be // listed in /MODULES return Version(1,1,0,1,VF_VENDOR,API_VERSION); } virtual void OnUserConnect(userrec* user) { for (hostchanges_t::iterator i = hostchanges.begin(); i != hostchanges.end(); i++) { if (ServerInstance->MatchText(std::string(user->ident)+"@"+std::string(user->host),i->first)) { Host* h = (Host*)i->second; // host of new user matches a hostchange tag's mask std::string newhost; if (h->action == "set") { newhost = h->newhost; } else if (h->action == "suffix") { newhost = MySuffix; } else if (h->action == "addnick") { // first take their nick and strip out non-dns, leaving just [A-Z0-9\-] std::string complete; std::string old = user->nick; for (unsigned int j = 0; j < old.length(); j++) { if (((old[j] >= 'A') && (old[j] <= 'Z')) || ((old[j] >= 'a') && (old[j] <= 'z')) || ((old[j] >= '0') && (old[j] <= '9')) || (old[j] == '-')) { complete = complete + old[j]; } } if (complete.empty()) complete = "i-have-a-lame-nick"; if (!MyPrefix.empty()) newhost = MyPrefix + MySeparator + complete; else newhost = complete + MySeparator + MySuffix; } if (!newhost.empty()) { user->WriteServ("NOTICE "+std::string(user->nick)+" :Setting your virtual host: " + newhost); if (!user->ChangeDisplayedHost(newhost.c_str())) user->WriteServ("NOTICE "+std::string(user->nick)+" :Could not set your virtual host: " + newhost); return; } } } } }; MODULE_INIT(ModuleHostChange) \ No newline at end of file +/* + * InspIRCd -- Internet Relay Chat Daemon + * + * Copyright (C) 2013, 2018-2020 Sadie Powell + * Copyright (C) 2012-2014 Attila Molnar + * Copyright (C) 2012 Robby + * Copyright (C) 2009 Robin Burchell + * Copyright (C) 2009 Daniel De Graaf + * Copyright (C) 2007 Dennis Friis + * Copyright (C) 2006-2007, 2010 Craig Edwards + * + * 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" +#include "modules/account.h" + +// Holds information about a rule. +class HostRule +{ + public: + enum HostChangeAction + { + // Add the user's account name to their hostname. + HCA_ADDACCOUNT, + + // Add the user's nickname to their hostname. + HCA_ADDNICK, + + // Set the user's hostname to the specific value. + HCA_SET + }; + + private: + HostChangeAction action; + std::string host; + std::string mask; + insp::flat_set ports; + std::string prefix; + std::string suffix; + + public: + HostRule(const std::string& Mask, const std::string& Host, const insp::flat_set& Ports) + : action(HCA_SET) + , host(Host) + , mask(Mask) + , ports(Ports) + { + } + + HostRule(HostChangeAction Action, const std::string& Mask, const insp::flat_set& Ports, const std::string& Prefix, const std::string& Suffix) + : action(Action) + , mask(Mask) + , ports(Ports) + , prefix(Prefix) + , suffix(Suffix) + { + } + + HostChangeAction GetAction() const + { + return action; + } + + const std::string& GetHost() const + { + return host; + } + + bool Matches(LocalUser* user) const + { + if (!ports.empty() && !ports.count(user->server_sa.port())) + return false; + + if (InspIRCd::MatchCIDR(user->MakeHost(), mask)) + return true; + + return InspIRCd::MatchCIDR(user->MakeHostIP(), mask); + } + + void Wrap(const std::string& value, std::string& out) const + { + if (!prefix.empty()) + out.append(prefix); + + out.append(value); + + if (!suffix.empty()) + out.append(suffix); + } +}; + +typedef std::vector HostRules; + +class ModuleHostChange : public Module +{ +private: + std::bitset hostmap; + HostRules hostrules; + + std::string CleanName(const std::string& name) + { + std::string buffer; + buffer.reserve(name.length()); + for (std::string::const_iterator iter = name.begin(); iter != name.end(); ++iter) + { + if (hostmap.test(static_cast(*iter))) + { + buffer.push_back(*iter); + } + } + return buffer; + } + + public: + void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE + { + HostRules rules; + + ConfigTagList tags = ServerInstance->Config->ConfTags("hostchange"); + for (ConfigIter i = tags.first; i != tags.second; ++i) + { + ConfigTag* tag = i->second; + + // Ensure that we have the parameter. + const std::string mask = tag->getString("mask"); + if (mask.empty()) + throw ModuleException(" is a mandatory field, at " + tag->getTagLocation()); + + insp::flat_set ports; + const std::string portlist = tag->getString("ports"); + if (!portlist.empty()) + { + irc::portparser portrange(portlist, false); + while (int port = portrange.GetToken()) + ports.insert(port); + } + + // Determine what type of host rule this is. + const std::string action = tag->getString("action"); + if (stdalgo::string::equalsci(action, "addaccount")) + { + // The hostname is in the format [prefix][suffix]. + rules.push_back(HostRule(HostRule::HCA_ADDACCOUNT, mask, ports, tag->getString("prefix"), tag->getString("suffix"))); + } + else if (stdalgo::string::equalsci(action, "addnick")) + { + // The hostname is in the format [prefix][suffix]. + rules.push_back(HostRule(HostRule::HCA_ADDNICK, mask, ports, tag->getString("prefix"), tag->getString("suffix"))); + } + else if (stdalgo::string::equalsci(action, "set")) + { + // Ensure that we have the parameter. + const std::string value = tag->getString("value"); + if (value.empty()) + throw ModuleException(" is a mandatory field when using the 'set' action, at " + tag->getTagLocation()); + + // The hostname is in the format . + rules.push_back(HostRule(mask, value, ports)); + continue; + } + else + { + throw ModuleException(action + " is an invalid type, at " + tag->getTagLocation()); + } + } + + ConfigTag* tag = ServerInstance->Config->ConfValue("hostname"); + const std::string hmap = tag->getString("charmap", "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.-_/0123456789", 1); + + hostmap.reset(); + for (std::string::const_iterator iter = hmap.begin(); iter != hmap.end(); ++iter) + hostmap.set(static_cast(*iter)); + hostrules.swap(rules); + } + + Version GetVersion() CXX11_OVERRIDE + { + return Version("Allows the server administrator to define custom rules for applying hostnames to users.", VF_VENDOR); + } + + void OnUserConnect(LocalUser* user) CXX11_OVERRIDE + { + for (HostRules::const_iterator iter = hostrules.begin(); iter != hostrules.end(); ++iter) + { + const HostRule& rule = *iter; + if (!rule.Matches(user)) + continue; + + std::string newhost; + if (rule.GetAction() == HostRule::HCA_ADDACCOUNT) + { + // Retrieve the account name. + const AccountExtItem* accountext = GetAccountExtItem(); + const std::string* accountptr = accountext ? accountext->get(user) : NULL; + if (!accountptr) + continue; + + // Remove invalid hostname characters. + std::string accountname = CleanName(*accountptr); + if (accountname.empty()) + continue; + + // Create the hostname. + rule.Wrap(accountname, newhost); + } + else if (rule.GetAction() == HostRule::HCA_ADDNICK) + { + // Remove invalid hostname characters. + const std::string nickname = CleanName(user->nick); + if (nickname.empty()) + continue; + + // Create the hostname. + rule.Wrap(nickname, newhost); + } + else if (rule.GetAction() == HostRule::HCA_SET) + { + newhost.assign(rule.GetHost()); + } + + if (!newhost.empty()) + { + user->WriteNotice("Setting your virtual host: " + newhost); + if (!user->ChangeDisplayedHost(newhost)) + user->WriteNotice("Could not set your virtual host: " + newhost); + return; + } + } + } +}; + +MODULE_INIT(ModuleHostChange)