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                         std::vector<std::string> 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, origin));
 142                         if (MOD_RESULT == MOD_RES_DENY)
 143                                 return;
 144
 145                         // Now handle /OPER.
 146                         oper_command->Handle(params, user);
 147                 }
 148                 else
 149                 {
 150                         ServerInstance->Logs->Log(MODNAME, LOG_SPARSE, "BUG: WHAT?! Why do we have no OPER command?!");
 151                 }
 152         }
 153 };
 154
 155 class ModuleSQLOper : public Module
 156 {
 157         // Whether OperQuery is running
 158         bool active;
 159         std::string query;
 160         // Stores oper blocks from DB
 161         std::vector<std::string> my_blocks;
 162         dynamic_reference<SQL::Provider> SQL;
 163
 164 public:
 165         ModuleSQLOper()
 166                 : active(false)
 167                 , SQL(this, "SQL")
 168         {
 169         }
 170
 171         void ReadConfig(ConfigStatus& status) CXX11_OVERRIDE
 172         {
 173                 // Clear list of our blocks, as ConfigReader just wiped them anyway
 174                 my_blocks.clear();
 175
 176                 ConfigTag* tag = ServerInstance->Config->ConfValue("sqloper");
 177
 178                 std::string dbid = tag->getString("dbid");
 179                 if (dbid.empty())
 180                         SQL.SetProvider("SQL");
 181                 else
 182                         SQL.SetProvider("SQL/" + dbid);
 183
 184                 query = tag->getString("query", "SELECT * FROM ircd_opers WHERE active=1;");
 185                 // Update sqloper list from the database.
 186                 GetOperBlocks();
 187         }
 188
 189         ~ModuleSQLOper()
 190         {
 191                 // Remove all oper blocks that were from the DB
 192                 for (std::vector<std::string>::const_iterator i = my_blocks.begin(); i != my_blocks.end(); ++i)
 193                 {
 194                         ServerInstance->Config->oper_blocks.erase(*i);
 195                 }
 196         }
 197
 198         ModResult OnPreCommand(std::string &command, std::vector<std::string> &parameters, LocalUser* user, bool validated, const std::string& original_line) CXX11_OVERRIDE
 199         {
 200                 // If we are not in the middle of an existing /OPER and someone is trying to oper-up
 201                 if (validated && command == "OPER" && parameters.size() >= 2 && !active)
 202                 {
 203                         if (SQL)
 204                         {
 205                                 GetOperBlocks(user->uuid, parameters[0], parameters[1]);
 206                                 /** We need to reload oper blocks from the DB before other
 207                                  *  hooks can run (i.e. sslinfo). We will re-call /OPER later.
 208                                  */
 209                                 return MOD_RES_DENY;
 210                         }
 211                         ServerInstance->Logs->Log(MODNAME, LOG_DEFAULT, "database not present");
 212                 }
 213                 else if (active)
 214                 {
 215                         active = false;
 216                 }
 217                 // There is either no DB or we successfully reloaded oper blocks
 218                 return MOD_RES_PASSTHRU;
 219         }
 220
 221         // The one w/o params is for non-/OPER DB updates, such as a rehash.
 222         void GetOperBlocks()
 223         {
 224                 SQL->Submit(new OperQuery(this, my_blocks), query);
 225         }
 226         void GetOperBlocks(const std::string u, const std::string& un, const std::string& pw)
 227         {
 228                 active = true;
 229                 // Call to SQL query to fetch oper list from SQL table.
 230                 SQL->Submit(new OperQuery(this, my_blocks, u, un, pw), query);
 231         }
 232
 233         void Prioritize() CXX11_OVERRIDE
 234         {
 235                 /** Run before other /OPER hooks that expect populated blocks, i.e. sslinfo or a TOTP module.
 236                  *  We issue a DENY first, and will re-run OnPreCommand later to trigger the other hooks post-DB update.
 237                  */
 238                 ServerInstance->Modules.SetPriority(this, I_OnPreCommand, PRIORITY_FIRST);
 239         }
 240
 241         Version GetVersion() CXX11_OVERRIDE
 242         {
 243                 return Version("Allows storage of oper credentials in an SQL table", VF_VENDOR);
 244         }
 245 };
 246
 247 MODULE_INIT(ModuleSQLOper)