Merge pull request #1337 from SaberUK/master+merge

[user/henk/code/inspircd.git] / src / modules / m_sasl.cpp

diff --git a/src/modules/m_sasl.cpp b/src/modules/m_sasl.cpp
index 639fe677863ece5a76dd5c39448393298cce6813..9f7e1527bc78e6c4b46775efaca6b27b2cc412ad 100644 (file)
--- a/src/modules/m_sasl.cpp
+++ b/src/modules/m_sasl.cpp
@@ -23,10 +23,73 @@
 #include "modules/account.h"
 #include "modules/sasl.h"
 #include "modules/ssl.h"
+#include "modules/spanningtree.h"
+
+static std::string sasl_target;
+
+class ServerTracker : public SpanningTreeEventListener
+{
+       bool online;
+
+       void Update(const Server* server, bool linked)
+       {
+               if (sasl_target == "*")
+                       return;
+
+               if (InspIRCd::Match(server->GetName(), sasl_target))
+               {
+                       ServerInstance->Logs->Log(MODNAME, LOG_VERBOSE, "SASL target server \"%s\" %s", sasl_target.c_str(), (linked ? "came online" : "went offline"));
+                       online = linked;
+               }
+       }
+
+       void OnServerLink(const Server* server) CXX11_OVERRIDE
+       {
+               Update(server, true);
+       }
+
+       void OnServerSplit(const Server* server) CXX11_OVERRIDE
+       {
+               Update(server, false);
+       }
+
+ public:
+       ServerTracker(Module* mod)
+               : SpanningTreeEventListener(mod)
+       {
+               Reset();
+       }
+
+       void Reset()
+       {
+               if (sasl_target == "*")
+               {
+                       online = true;
+                       return;
+               }
+
+               online = false;
+
+               ProtocolInterface::ServerList servers;
+               ServerInstance->PI->GetServerList(servers);
+               for (ProtocolInterface::ServerList::const_iterator i = servers.begin(); i != servers.end(); ++i)
+               {
+                       const ProtocolInterface::ServerInfo& server = *i;
+                       if (InspIRCd::Match(server.servername, sasl_target))
+                       {
+                               online = true;
+                               break;
+                       }
+               }
+       }
+
+       bool IsOnline() const { return online; }
+};
 
 class SASLCap : public Cap::Capability
 {
        std::string mechlist;
+       const ServerTracker& servertracker;
 
        bool OnRequest(LocalUser* user, bool adding) CXX11_OVERRIDE
        {
@@ -38,14 +101,20 @@ class SASLCap : public Cap::Capability
                return (user->registered != REG_ALL);
        }
 
+       bool OnList(LocalUser* user) CXX11_OVERRIDE
+       {
+               return servertracker.IsOnline();
+       }
+
        const std::string* GetValue(LocalUser* user) const CXX11_OVERRIDE
        {
                return &mechlist;
        }
 
  public:
-       SASLCap(Module* mod)
+       SASLCap(Module* mod, const ServerTracker& tracker)
                : Cap::Capability(mod, "sasl")
+               , servertracker(tracker)
        {
        }
 
@@ -62,7 +131,6 @@ class SASLCap : public Cap::Capability
 enum SaslState { SASL_INIT, SASL_COMM, SASL_DONE };
 enum SaslResult { SASL_OK, SASL_FAIL, SASL_ABORT };
 
-static std::string sasl_target = "*";
 static Events::ModuleEventProvider* saslevprov;
 
 static void SendSASL(const parameterlist& params)
@@ -85,10 +153,63 @@ class SaslAuthenticator
        SaslResult result;
        bool state_announced;
 
+       /* taken from m_services_account */
+       static bool ReadCGIIRCExt(const char* extname, User* user, std::string& out)
+       {
+               ExtensionItem* wiext = ServerInstance->Extensions.GetItem(extname);
+               if (!wiext)
+                       return false;
+
+               if (wiext->creator->ModuleSourceFile != "m_cgiirc.so")
+                       return false;
+
+               StringExtItem* stringext = static_cast<StringExtItem*>(wiext);
+               std::string* addr = stringext->get(user);
+               if (!addr)
+                       return false;
+
+               out = *addr;
+               return true;
+       }
+
+
+       void SendHostIP()
+       {
+               std::string host, ip;
+
+               if (!ReadCGIIRCExt("cgiirc_webirc_hostname", user, host))
+               {
+                       host = user->host;
+               }
+               if (!ReadCGIIRCExt("cgiirc_webirc_ip", user, ip))
+               {
+                       ip = user->GetIPString();
+               }
+               else
+               {
+                       /* IP addresses starting with a : on irc are a Bad Thing (tm) */
+                       if (ip.c_str()[0] == ':')
+                               ip.insert(ip.begin(),1,'0');
+               }
+
+               parameterlist params;
+               params.push_back(sasl_target);
+               params.push_back("SASL");
+               params.push_back(user->uuid);
+               params.push_back("*");
+               params.push_back("H");
+               params.push_back(host);
+               params.push_back(ip);
+
+               SendSASL(params);
+       }
+
  public:
        SaslAuthenticator(User* user_, const std::string& method)
                : user(user_), state(SASL_INIT), state_announced(false)
        {
+               SendHostIP();
+
                parameterlist params;
                params.push_back(user->uuid);
                params.push_back("*");
@@ -177,7 +298,7 @@ class SaslAuthenticator
 
                SendSASL(params);
 
-               if (parameters[0][0] == '*')
+               if (parameters[0].c_str()[0] == '*')
                {
                        this->Abort();
                        return false;
@@ -219,6 +340,7 @@ class CommandAuthenticate : public Command
                : Command(Creator, "AUTHENTICATE", 1), authExt(ext), cap(Cap)
        {
                works_before_reg = true;
+               allow_empty_last_param = false;
        }
 
        CmdResult Handle (const std::vector<std::string>& parameters, User *user)
@@ -227,6 +349,9 @@ class CommandAuthenticate : public Command
                        if (!cap.get(user))
                                return CMD_FAILURE;
 
+                       if (parameters[0].find(' ') != std::string::npos || parameters[0][0] == ':')
+                               return CMD_FAILURE;
+
                        SaslAuthenticator *sasl = authExt.get(user);
                        if (!sasl)
                                authExt.set(user, new SaslAuthenticator(user, parameters[0]));
@@ -280,6 +405,7 @@ class CommandSASL : public Command
 class ModuleSASL : public Module
 {
        SimpleExtItem<SaslAuthenticator> authExt;
+       ServerTracker servertracker;
        SASLCap cap;
        CommandAuthenticate auth;
        CommandSASL sasl;
@@ -288,7 +414,8 @@ class ModuleSASL : public Module
  public:
        ModuleSASL()
                : authExt("sasl_auth", ExtensionItem::EXT_USER, this)
-               , cap(this)
+               , servertracker(this)
+               , cap(this, servertracker)
                , auth(this, authExt, cap)
                , sasl(this, authExt)
                , sasleventprov(this, "event/sasl")
@@ -305,9 +432,10 @@ class ModuleSASL : public Module
        void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
        {
                sasl_target = ServerInstance->Config->ConfValue("sasl")->getString("target", "*");
+               servertracker.Reset();
        }
 
-       ModResult OnUserRegister(LocalUser *user) CXX11_OVERRIDE
+       void OnUserConnect(LocalUser *user) CXX11_OVERRIDE
        {
                SaslAuthenticator *sasl_ = authExt.get(user);
                if (sasl_)
@@ -315,8 +443,6 @@ class ModuleSASL : public Module
                        sasl_->Abort();
                        authExt.unset(user);
                }
-
-               return MOD_RES_PASSTHRU;
        }
 
        void OnDecodeMetaData(Extensible* target, const std::string& extname, const std::string& extdata) CXX11_OVERRIDE