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)
  92         {
  93                 SQLite3Result res;
  94                 sqlite3_stmt *stmt;
  95                 int err = sqlite3_prepare_v2(conn, query->query.c_str(), query->query.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         std::string FormatQuery(const std::string& q, const ParamL& p)
 140         {
 141                 std::string res;
 142                 unsigned int param = 0;
 143                 for(std::string::size_type i = 0; i < q.length(); i++)
 144                 {
 145                         if (q[i] != '?')
 146                                 res.push_back(q[i]);
 147                         else
 148                         {
 149                                 // TODO numbered parameter support ('?1')
 150                                 if (param < p.size())
 151                                 {
 152                                         char* escaped = sqlite3_mprintf("%q", p[param++].c_str());
 153                                         res.append(escaped);
 154                                         sqlite3_free(escaped);
 155                                 }
 156                         }
 157                 }
 158                 return res;
 159         }
 160
 161         std::string FormatQuery(const std::string& q, const ParamM& p)
 162         {
 163                 std::string res;
 164                 for(std::string::size_type i = 0; i < q.length(); i++)
 165                 {
 166                         if (q[i] != '$')
 167                                 res.push_back(q[i]);
 168                         else
 169                         {
 170                                 std::string field;
 171                                 i++;
 172                                 while (i < q.length() && isalpha(q[i]))
 173                                         field.push_back(q[i++]);
 174                                 i--;
 175
 176                                 ParamM::const_iterator it = p.find(field);
 177                                 if (it != p.end())
 178                                 {
 179                                         char* escaped = sqlite3_mprintf("%q", it->second.c_str());
 180                                         res.append(escaped);
 181                                         sqlite3_free(escaped);
 182                                 }
 183                         }
 184                 }
 185                 return res;
 186         }
 187
 188         virtual void submit(SQLQuery* query)
 189         {
 190                 Query(query);
 191                 delete query;
 192         }
 193 };
 194
 195 class ModuleSQLite3 : public Module
 196 {
 197  private:
 198         ConnMap conns;
 199
 200  public:
 201         ModuleSQLite3()
 202         {
 203         }
 204
 205         void init()
 206         {
 207                 ReadConf();
 208
 209                 Implementation eventlist[] = { I_OnRehash };
 210                 ServerInstance->Modules->Attach(eventlist, this, 1);
 211         }
 212
 213         virtual ~ModuleSQLite3()
 214         {
 215                 ClearConns();
 216         }
 217
 218         void ClearConns()
 219         {
 220                 for(ConnMap::iterator i = conns.begin(); i != conns.end(); i++)
 221                 {
 222                         SQLConn* conn = i->second;
 223                         ServerInstance->Modules->DelService(*conn);
 224                         delete conn;
 225                 }
 226                 conns.clear();
 227         }
 228
 229         void ReadConf()
 230         {
 231                 ClearConns();
 232                 ConfigTagList tags = ServerInstance->Config->ConfTags("database");
 233                 for(ConfigIter i = tags.first; i != tags.second; i++)
 234                 {
 235                         if (i->second->getString("module", "sqlite") != "sqlite")
 236                                 continue;
 237                         SQLConn* conn = new SQLConn(this, i->second);
 238                         conns.insert(std::make_pair(i->second->getString("id"), conn));
 239                         ServerInstance->Modules->AddService(*conn);
 240                 }
 241         }
 242
 243         void OnRehash(User* user)
 244         {
 245                 ReadConf();
 246         }
 247
 248         Version GetVersion()
 249         {
 250                 return Version("sqlite3 provider", VF_VENDOR);
 251         }
 252 };
 253
 254 MODULE_INIT(ModuleSQLite3)