src/modules/extra/m_sqlite3.cpp

   1 /*               +------------------------------------+
   2  *               | Inspire Internet Relay Chat Daemon |
   3  *               +------------------------------------+
   4  *
   5  *      InspIRCd: (C) 2002-2010 InspIRCd Development Team
   6  * See: http://wiki.inspircd.org/Credits
   7  *
   8  * This program is free but copyrighted software; see
   9  *                        the file COPYING for details.
  10  *
  11  * ---------------------------------------------------
  12  */
  13
  14 #include "inspircd.h"
  15 #include <sqlite3.h>
  16 #include "sql.h"
  17
  18 /* $ModDesc: sqlite3 provider */
  19 /* $CompileFlags: pkgconfversion("sqlite3","3.3") pkgconfincludes("sqlite3","/sqlite3.h","") */
  20 /* $LinkerFlags: pkgconflibs("sqlite3","/libsqlite3.so","-lsqlite3") */
  21 /* $NoPedantic */
  22
  23 class SQLConn;
  24 typedef std::map<std::string, SQLConn*> ConnMap;
  25
  26 class SQLite3Result : public SQLResult
  27 {
  28  public:
  29         int currentrow;
  30         int rows;
  31         std::vector<std::string> columns;
  32         std::vector<SQLEntries> fieldlists;
  33
  34         SQLite3Result() : currentrow(0), rows(0)
  35         {
  36         }
  37
  38         ~SQLite3Result()
  39         {
  40         }
  41
  42         virtual int Rows()
  43         {
  44                 return rows;
  45         }
  46
  47         virtual bool GetRow(SQLEntries& result)
  48         {
  49                 if (currentrow < rows)
  50                 {
  51                         result.assign(fieldlists[currentrow].begin(), fieldlists[currentrow].end());
  52                         currentrow++;
  53                         return true;
  54                 }
  55                 else
  56                 {
  57                         result.clear();
  58                         return false;
  59                 }
  60         }
  61
  62         virtual void GetCols(std::vector<std::string>& result)
  63         {
  64                 result.assign(columns.begin(), columns.end());
  65         }
  66 };
  67
  68 class SQLConn : public SQLProvider
  69 {
  70  private:
  71         sqlite3* conn;
  72         reference<ConfigTag> config;
  73
  74  public:
  75         SQLConn(Module* Parent, ConfigTag* tag) : SQLProvider(Parent, "SQL/" + tag->getString("id")), config(tag)
  76         {
  77                 std::string host = tag->getString("hostname");
  78                 if (sqlite3_open_v2(host.c_str(), &conn, SQLITE_OPEN_READWRITE, 0) != SQLITE_OK)
  79                 {
  80                         ServerInstance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: Could not open DB with id: " + tag->getString("id"));
  81                         conn = NULL;
  82                 }
  83         }
  84
  85         ~SQLConn()
  86         {
  87                 sqlite3_interrupt(conn);
  88                 sqlite3_close(conn);
  89         }
  90
  91         void Query(SQLQuery* query, const std::string& q)
  92         {
  93                 SQLite3Result res;
  94                 sqlite3_stmt *stmt;
  95                 int err = sqlite3_prepare_v2(conn, q.c_str(), q.length(), &stmt, NULL);
  96                 if (err != SQLITE_OK)
  97                 {
  98                         SQLerror error(SQL_QSEND_FAIL, sqlite3_errmsg(conn));
  99                         query->OnError(error);
 100                         return;
 101                 }
 102                 int cols = sqlite3_column_count(stmt);
 103                 res.columns.resize(cols);
 104                 for(int i=0; i < cols; i++)
 105                 {
 106                         res.columns[i] = sqlite3_column_name(stmt, i);
 107                 }
 108                 while (1)
 109                 {
 110                         err = sqlite3_step(stmt);
 111                         if (err == SQLITE_ROW)
 112                         {
 113                                 // Add the row
 114                                 res.fieldlists.resize(res.rows + 1);
 115                                 res.fieldlists[res.rows].resize(cols);
 116                                 for(int i=0; i < cols; i++)
 117                                 {
 118                                         const char* txt = (const char*)sqlite3_column_text(stmt, i);
 119                                         if (txt)
 120                                                 res.fieldlists[res.rows][i] = SQLEntry(txt);
 121                                 }
 122                                 res.rows++;
 123                         }
 124                         else if (err == SQLITE_DONE)
 125                         {
 126                                 query->OnResult(res);
 127                                 break;
 128                         }
 129                         else
 130                         {
 131                                 SQLerror error(SQL_QREPLY_FAIL, sqlite3_errmsg(conn));
 132                                 query->OnError(error);
 133                                 break;
 134                         }
 135                 }
 136                 sqlite3_finalize(stmt);
 137         }
 138
 139         virtual void submit(SQLQuery* query, const std::string& q)
 140         {
 141                 Query(query, q);
 142                 delete query;
 143         }
 144
 145         virtual void submit(SQLQuery* query, const std::string& q, const ParamL& p)
 146         {
 147                 std::string res;
 148                 unsigned int param = 0;
 149                 for(std::string::size_type i = 0; i < q.length(); i++)
 150                 {
 151                         if (q[i] != '?')
 152                                 res.push_back(q[i]);
 153                         else
 154                         {
 155                                 if (param < p.size())
 156                                 {
 157                                         char* escaped = sqlite3_mprintf("%q", p[param++].c_str());
 158                                         res.append(escaped);
 159                                         sqlite3_free(escaped);
 160                                 }
 161                         }
 162                 }
 163                 submit(query, res);
 164         }
 165
 166         virtual void submit(SQLQuery* query, const std::string& q, const ParamM& p)
 167         {
 168                 std::string res;
 169                 for(std::string::size_type i = 0; i < q.length(); i++)
 170                 {
 171                         if (q[i] != '$')
 172                                 res.push_back(q[i]);
 173                         else
 174                         {
 175                                 std::string field;
 176                                 i++;
 177                                 while (i < q.length() && isalnum(q[i]))
 178                                         field.push_back(q[i++]);
 179                                 i--;
 180
 181                                 ParamM::const_iterator it = p.find(field);
 182                                 if (it != p.end())
 183                                 {
 184                                         char* escaped = sqlite3_mprintf("%q", it->second.c_str());
 185                                         res.append(escaped);
 186                                         sqlite3_free(escaped);
 187                                 }
 188                         }
 189                 }
 190                 submit(query, res);
 191         }
 192 };
 193
 194 class ModuleSQLite3 : public Module
 195 {
 196  private:
 197         ConnMap conns;
 198
 199  public:
 200         ModuleSQLite3()
 201         {
 202         }
 203
 204         void init()
 205         {
 206                 ReadConf();
 207
 208                 Implementation eventlist[] = { I_OnRehash };
 209                 ServerInstance->Modules->Attach(eventlist, this, 1);
 210         }
 211
 212         virtual ~ModuleSQLite3()
 213         {
 214                 ClearConns();
 215         }
 216
 217         void ClearConns()
 218         {
 219                 for(ConnMap::iterator i = conns.begin(); i != conns.end(); i++)
 220                 {
 221                         SQLConn* conn = i->second;
 222                         ServerInstance->Modules->DelService(*conn);
 223                         delete conn;
 224                 }
 225                 conns.clear();
 226         }
 227
 228         void ReadConf()
 229         {
 230                 ClearConns();
 231                 ConfigTagList tags = ServerInstance->Config->ConfTags("database");
 232                 for(ConfigIter i = tags.first; i != tags.second; i++)
 233                 {
 234                         if (i->second->getString("module", "sqlite") != "sqlite")
 235                                 continue;
 236                         SQLConn* conn = new SQLConn(this, i->second);
 237                         conns.insert(std::make_pair(i->second->getString("id"), conn));
 238                         ServerInstance->Modules->AddService(*conn);
 239                 }
 240         }
 241
 242         void OnRehash(User* user)
 243         {
 244                 ReadConf();
 245         }
 246
 247         Version GetVersion()
 248         {
 249                 return Version("sqlite3 provider", VF_VENDOR);
 250         }
 251 };
 252
 253 MODULE_INIT(ModuleSQLite3)