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         virtual void GetCols(std::vector<std::string>& result)
  62         {
  63                 result.assign(columns.begin(), columns.end());
  64         }
  65 };
  66
  67 class SQLConn : public SQLProvider
  68 {
  69  private:
  70         sqlite3* conn;
  71         reference<ConfigTag> config;
  72
  73  public:
  74         SQLConn(Module* Parent, ConfigTag* tag) : SQLProvider(Parent, "SQL/" + tag->getString("id")), config(tag)
  75         {
  76                 std::string host = tag->getString("hostname");
  77                 if (sqlite3_open_v2(host.c_str(), &conn, SQLITE_OPEN_READWRITE, 0) != SQLITE_OK)
  78                 {
  79                         ServerInstance->Logs->Log("m_sqlite3",DEFAULT, "WARNING: Could not open DB with id: " + tag->getString("id"));
  80                         conn = NULL;
  81                 }
  82         }
  83
  84         ~SQLConn()
  85         {
  86                 sqlite3_interrupt(conn);
  87                 sqlite3_close(conn);
  88         }
  89
  90         void Query(SQLQuery* query)
  91         {
  92                 SQLite3Result res;
  93                 sqlite3_stmt *stmt;
  94                 int err = sqlite3_prepare_v2(conn, query->query.c_str(), query->query.length(), &stmt, NULL);
  95                 if (err != SQLITE_OK)
  96                 {
  97                         SQLerror error(SQL_QSEND_FAIL, sqlite3_errmsg(conn));
  98                         query->OnError(error);
  99                         return;
 100                 }
 101                 int cols = sqlite3_column_count(stmt);
 102                 res.columns.resize(cols);
 103                 for(int i=0; i < cols; i++)
 104                 {
 105                         res.columns[i] = sqlite3_column_name(stmt, i);
 106                 }
 107                 while (1)
 108                 {
 109                         err = sqlite3_step(stmt);
 110                         if (err == SQLITE_ROW)
 111                         {
 112                                 // Add the row
 113                                 res.fieldlists.resize(res.rows + 1);
 114                                 res.fieldlists[res.rows].resize(cols);
 115                                 for(int i=0; i < cols; i++)
 116                                 {
 117                                         const char* txt = (const char*)sqlite3_column_text(stmt, i);
 118                                         if (txt)
 119                                                 res.fieldlists[res.rows][i] = SQLEntry(txt);
 120                                 }
 121                                 res.rows++;
 122                         }
 123                         else if (err == SQLITE_DONE)
 124                         {
 125                                 query->OnResult(res);
 126                                 break;
 127                         }
 128                         else
 129                         {
 130                                 SQLerror error(SQL_QREPLY_FAIL, sqlite3_errmsg(conn));
 131                                 query->OnError(error);
 132                                 break;
 133                         }
 134                 }
 135                 sqlite3_finalize(stmt);
 136         }
 137
 138         std::string FormatQuery(const std::string& q, const ParamL& p)
 139         {
 140                 std::string res;
 141                 unsigned int param = 0;
 142                 for(std::string::size_type i = 0; i < q.length(); i++)
 143                 {
 144                         if (q[i] != '?')
 145                                 res.push_back(q[i]);
 146                         else
 147                         {
 148                                 // TODO numbered parameter support ('?1')
 149                                 if (param < p.size())
 150                                 {
 151                                         char* escaped = sqlite3_mprintf("%q", p[param++].c_str());
 152                                         res.append(escaped);
 153                                         sqlite3_free(escaped);
 154                                 }
 155                         }
 156                 }
 157                 return res;
 158         }
 159
 160         std::string FormatQuery(const std::string& q, const ParamM& p)
 161         {
 162                 std::string res;
 163                 for(std::string::size_type i = 0; i < q.length(); i++)
 164                 {
 165                         if (q[i] != '$')
 166                                 res.push_back(q[i]);
 167                         else
 168                         {
 169                                 std::string field;
 170                                 i++;
 171                                 while (i < q.length() && isalpha(q[i]))
 172                                         field.push_back(q[i++]);
 173                                 i--;
 174
 175                                 ParamM::const_iterator it = p.find(field);
 176                                 if (it != p.end())
 177                                 {
 178                                         char* escaped = sqlite3_mprintf("%q", it->second.c_str());
 179                                         res.append(escaped);
 180                                         sqlite3_free(escaped);
 181                                 }
 182                         }
 183                 }
 184                 return res;
 185         }
 186
 187         virtual void submit(SQLQuery* query)
 188         {
 189                 Query(query);
 190                 delete query;
 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)