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