src/modules/m_sqloper.cpp

   1 /*
   2  * InspIRCd -- Internet Relay Chat Daemon
   3  *
   4  *   Copyright (C) 2017 Dylan Frank <b00mx0r@aureus.pw>
   5  *   Copyright (C) 2009-2010 Daniel De Graaf <danieldg@inspircd.org>
   6  *
   7  * This file is part of InspIRCd.  InspIRCd is free software: you can
   8  * redistribute it and/or modify it under the terms of the GNU General Public
   9  * License as published by the Free Software Foundation, version 2.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  13  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
  14  * details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20
  21 #include "inspircd.h"
  22 #include "modules/sql.h"
  23
  24 class OperQuery : public SQL::Query
  25 {
  26  public:
  27         // This variable will store all the OPER blocks from the DB
  28         std::vector<std::string>& my_blocks;
  29         /** We want to store the username and password if this is called during an /OPER, as we're responsible for /OPER post-DB fetch
  30          *  Note: uid will be empty if this DB update was not called as a result of a user command (i.e. /REHASH)
  31          */
  32         const std::string uid, username, password;
  33         OperQuery(Module* me, std::vector<std::string>& mb, const std::string& u, const std::string& un, const std::string& pw)
  34                 : SQL::Query(me)
  35                 , my_blocks(mb)
  36                 , uid(u)
  37                 , username(un)
  38                 , password(pw)
  39         {
  40         }
  41         OperQuery(Module* me, std::vector<std::string>& mb)
  42                 : SQL::Query(me)
  43                 , my_blocks(mb)
  44         {
  45         }
  46
  47         void OnResult(SQL::Result& res) CXX11_OVERRIDE
  48         {
  49                 ServerConfig::OperIndex& oper_blocks = ServerInstance->Config->oper_blocks;
  50
  51                 // Remove our previous blocks from oper_blocks for a clean update
  52                 for (std::vector<std::string>::const_iterator i = my_blocks.begin(); i != my_blocks.end(); ++i)
  53                 {
  54                         oper_blocks.erase(*i);
  55                 }
  56                 my_blocks.clear();
  57
  58                 SQL::Row row;
  59                 // Iterate through DB results to create oper blocks from sqloper rows
  60                 while (res.GetRow(row))
  61                 {
  62                         std::vector<std::string> cols;
  63                         res.GetCols(cols);
  64
  65                         // Create the oper tag as if we were the conf file.
  66                         ConfigItems* items;
  67                         reference<ConfigTag> tag = ConfigTag::create("oper", MODNAME, 0, items);
  68
  69                         /** Iterate through each column in the SQLOpers table. An infinite number of fields can be specified.
  70                          *  Column 'x' with cell value 'y' will be the same as x=y in an OPER block in opers.conf.
  71                          */
  72                         for (unsigned int i=0; i < cols.size(); ++i)
  73                         {
  74                                 if (!row[i].IsNull())
  75                                         (*items)[cols[i]] = row[i];
  76                         }
  77                         const std::string name = tag->getString("name");
  78
  79                         // Skip both duplicate sqloper blocks and sqloper blocks that attempt to override conf blocks.
  80                         if (oper_blocks.find(name) != oper_blocks.end())
  81                                 continue;
  82
  83                         const std::string type = tag->getString("type");
  84                         ServerConfig::OperIndex::iterator tblk = ServerInstance->Config->OperTypes.find(type);
  85                         if (tblk == ServerInstance->Config->OperTypes.end())
  86                         {
  87                                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "Sqloper block " + name + " has missing type " + type);
  88                                 ServerInstance->SNO->WriteGlobalSno('a', "m_sqloper: Oper block %s has missing type %s", name.c_str(), type.c_str());
  89                                 continue;
  90                         }
  91
  92                         OperInfo* ifo = new OperInfo(type);
  93
  94                         ifo->type_block = tblk->second->type_block;
  95                         ifo->oper_block = tag;
  96                         ifo->class_blocks.assign(tblk->second->class_blocks.begin(), tblk->second->class_blocks.end());
  97                         oper_blocks[name] = ifo;
  98                         my_blocks.push_back(name);
  99                 }
 100
 101                 // If this was done as a result of /OPER and not a config read
 102                 if (!uid.empty())
 103                 {
 104                         // Now that we've updated the DB, call any other /OPER hooks and then call /OPER
 105                         OperExec();
 106                 }
 107         }
 108
 109         void OnError(SQL::Error& error) CXX11_OVERRIDE
 110         {
 111                 ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "query failed (%s)", error.ToString());
 112                 ServerInstance->SNO->WriteGlobalSno('a', "m_sqloper: failed to update blocks from database");
 113                 if (!uid.empty())
 114                 {
 115                         // Fallback. We don't want to block a netadmin from /OPER
 116                         OperExec();
 117                 }
 118         }
 119
 120         // Call /oper after placing all blocks from the SQL table into the config->oper_blocks list.
 121         void OperExec()
 122         {
 123                 User* user = ServerInstance->FindNick(uid);
 124                 LocalUser* localuser = IS_LOCAL(user);
 125                 // This should never be true
 126                 if (!localuser)
 127                         return;
 128
 129                 Command* oper_command = ServerInstance->Parser.GetHandler("OPER");
 130
 131                 if (oper_command)
 132                 {
 133                         CommandBase::Params params;
 134                         params.push_back(username);
 135                         params.push_back(password);
 136
 137                         // Begin callback to other modules (i.e. sslinfo) now that we completed the DB fetch
 138                         ModResult MOD_RESULT;
 139
 140                         std::string origin = "OPER";
 141                         FIRST_MOD_RESULT(OnPreCommand, MOD_RESULT, (origin, params, localuser, true));
 142                         if (MOD_RESULT == MOD_RES_DENY)
 143                                 return;
 144
 145                         // Now handle /OPER.
 146                         ClientProtocol::TagMap tags;
 147                         oper_command->Handle(user, CommandBase::Params(params, tags));
 148                 }
 149                 else
 150                 {
 151                         ServerInstance->Logs->Log(MODNAME, LOG_SPARSE, "BUG: WHAT?! Why do we have no OPER command?!");
 152                 }
 153         }
 154 };
 155
 156 class ModuleSQLOper : public Module
 157 {
 158         // Whether OperQuery is running
 159         bool active;
 160         std::string query;
 161         // Stores oper blocks from DB
 162         std::vector<std::string> my_blocks;
 163         dynamic_reference<SQL::Provider> SQL;
 164
 165 public:
 166         ModuleSQLOper()
 167                 : active(false)
 168                 , SQL(this, "SQL")
 169         {
 170         }
 171
 172         void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
 173         {
 174                 // Clear list of our blocks, as ConfigReader just wiped them anyway
 175                 my_blocks.clear();
 176
 177                 ConfigTag* tag = ServerInstance->Config->ConfValue("sqloper");
 178
 179                 std::string dbid = tag->getString("dbid");
 180                 if (dbid.empty())
 181                         SQL.SetProvider("SQL");
 182                 else
 183                         SQL.SetProvider("SQL/" + dbid);
 184
 185                 query = tag->getString("query", "SELECT * FROM ircd_opers WHERE active=1;");
 186                 // Update sqloper list from the database.
 187                 GetOperBlocks();
 188         }
 189
 190         ~ModuleSQLOper()
 191         {
 192                 // Remove all oper blocks that were from the DB
 193                 for (std::vector<std::string>::const_iterator i = my_blocks.begin(); i != my_blocks.end(); ++i)
 194                 {
 195                         ServerInstance->Config->oper_blocks.erase(*i);
 196                 }
 197         }
 198
 199         ModResult OnPreCommand(std::string& command, CommandBase::Params& parameters, LocalUser* user, bool validated) CXX11_OVERRIDE
 200         {
 201                 // If we are not in the middle of an existing /OPER and someone is trying to oper-up
 202                 if (validated && command == "OPER" && parameters.size() >= 2 && !active)
 203                 {
 204                         if (SQL)
 205                         {
 206                                 GetOperBlocks(user->uuid, parameters[0], parameters[1]);
 207                                 /** We need to reload oper blocks from the DB before other
 208                                  *  hooks can run (i.e. sslinfo). We will re-call /OPER later.
 209                                  */
 210                                 return MOD_RES_DENY;
 211                         }
 212                         ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "database not present");
 213                 }
 214                 else if (active)
 215                 {
 216                         active = false;
 217                 }
 218                 // There is either no DB or we successfully reloaded oper blocks
 219                 return MOD_RES_PASSTHRU;
 220         }
 221
 222         // The one w/o params is for non-/OPER DB updates, such as a rehash.
 223         void GetOperBlocks()
 224         {
 225                 SQL->Submit(new OperQuery(this, my_blocks), query);
 226         }
 227         void GetOperBlocks(const std::string u, const std::string& un, const std::string& pw)
 228         {
 229                 active = true;
 230                 // Call to SQL query to fetch oper list from SQL table.
 231                 SQL->Submit(new OperQuery(this, my_blocks, u, un, pw), query);
 232         }
 233
 234         void Prioritize() CXX11_OVERRIDE
 235         {
 236                 /** Run before other /OPER hooks that expect populated blocks, i.e. sslinfo or a TOTP module.
 237                  *  We issue a DENY first, and will re-run OnPreCommand later to trigger the other hooks post-DB update.
 238                  */
 239                 ServerInstance->Modules.SetPriority(this, I_OnPreCommand, PRIORITY_FIRST);
 240         }
 241
 242         Version GetVersion() CXX11_OVERRIDE
 243         {
 244                 return Version("Allows storage of oper credentials in an SQL table", VF_VENDOR);
 245         }
 246 };
 247
 248 MODULE_INIT(ModuleSQLOper)