-/* +------------------------------------+
- * | Inspire Internet Relay Chat Daemon |
- * +------------------------------------+
- *
- * InspIRCd: (C) 2002-2007 InspIRCd Development Team
- * See: http://www.inspircd.org/wiki/index.php/Credits
- *
- * This program is free but copyrighted software; see
- * the file COPYING for details.
- *
- * ---------------------------------------------------
- */
-
-#include <string>
-#include <deque>
-#include <map>
-#include <sqlite3.h>
-
-#include "users.h"
-#include "channels.h"
-#include "modules.h"
-#include "inspircd.h"
-#include "configreader.h"
-
-#include "m_sqlv2.h"
-
-/* $ModDesc: sqlite3 provider */
-/* $CompileFlags: pkgconfincludes("sqlite3","/sqlite3.h","") */
-/* $LinkerFlags: pkgconflibs("sqlite3","/libsqlite3.so","-lsqlite3") */
-/* $ModDep: m_sqlv2.h */
-
-
-class SQLConn;
-class SQLite3Result;
-class ResultNotifier;
-
-typedef std::map<std::string, SQLConn*> ConnMap;
-typedef std::deque<classbase*> paramlist;
-typedef std::deque<SQLite3Result*> ResultQueue;
-
-ResultNotifier* resultnotify = NULL;
-
-
-class ResultNotifier : public InspSocket
-{
- Module* mod;
- insp_sockaddr sock_us;
- socklen_t uslen;
-
- public:
- /* Create a socket on a random port. Let the tcp stack allocate us an available port */
-#ifdef IPV6
- ResultNotifier(InspIRCd* SI, Module* m) : InspSocket(SI, "::1", 0, true, 3000), mod(m)
-#else
- ResultNotifier(InspIRCd* SI, Module* m) : InspSocket(SI, "127.0.0.1", 0, true, 3000), mod(m)
-#endif
- {
- uslen = sizeof(sock_us);
- if (getsockname(this->fd,(sockaddr*)&sock_us,&uslen))
- {
- throw ModuleException("Could not create random listening port on localhost");
- }
- }
-
- ResultNotifier(InspIRCd* SI, Module* m, int newfd, char* ip) : InspSocket(SI, newfd, ip), mod(m)
- {
- }
-
- /* Using getsockname and ntohs, we can determine which port number we were allocated */
- int GetPort()
- {
-#ifdef IPV6
- return ntohs(sock_us.sin6_port);
-#else
- return ntohs(sock_us.sin_port);
-#endif
- }
-
- virtual int OnIncomingConnection(int newsock, char* ip)
- {
- Dispatch();
- return false;
- }
-
- void Dispatch();
-};
-
-
-class SQLite3Result : public SQLresult
-{
- private:
- int currentrow;
- int rows;
- int cols;
-
- std::vector<std::string> colnames;
- std::vector<SQLfieldList> fieldlists;
- SQLfieldList emptyfieldlist;
-
- SQLfieldList* fieldlist;
- SQLfieldMap* fieldmap;
-
- public:
- SQLite3Result(Module* self, Module* to, unsigned int id)
- : SQLresult(self, to, id), currentrow(0), rows(0), cols(0), fieldlist(NULL), fieldmap(NULL)
- {
- }
-
- ~SQLite3Result()
- {
- }
-
- void AddRow(int colsnum, char **data, char **colname)
- {
- colnames.clear();
- cols = colsnum;
- for (int i = 0; i < colsnum; i++)
- {
- fieldlists.resize(fieldlists.size()+1);
- colnames.push_back(colname[i]);
- SQLfield sf(data[i] ? data[i] : "", data[i] ? false : true);
- fieldlists[rows].push_back(sf);
- }
- rows++;
- }
-
- void UpdateAffectedCount()
- {
- rows++;
- }
-
- virtual int Rows()
- {
- return rows;
- }
-
- virtual int Cols()
- {
- return cols;
- }
-
- virtual std::string ColName(int column)
- {
- if (column < (int)colnames.size())
- {
- return colnames[column];
- }
- else
- {
- throw SQLbadColName();
- }
- return "";
- }
-
- virtual int ColNum(const std::string &column)
- {
- for (unsigned int i = 0; i < colnames.size(); i++)
- {
- if (column == colnames[i])
- return i;
- }
- throw SQLbadColName();
- return 0;
- }
-
- virtual SQLfield GetValue(int row, int column)
- {
- if ((row >= 0) && (row < rows) && (column >= 0) && (column < Cols()))
- {
- return fieldlists[row][column];
- }
-
- throw SQLbadColName();
-
- /* XXX: We never actually get here because of the throw */
- return SQLfield("",true);
- }
-
- virtual SQLfieldList& GetRow()
- {
- if (currentrow < rows)
- return fieldlists[currentrow];
- else
- return emptyfieldlist;
- }
-
- virtual SQLfieldMap& GetRowMap()
- {
- /* In an effort to reduce overhead we don't actually allocate the map
- * until the first time it's needed...so...
- */
- if(fieldmap)
- {
- fieldmap->clear();
- }
- else
- {
- fieldmap = new SQLfieldMap;
- }
-
- if (currentrow < rows)
- {
- for (int i = 0; i < Cols(); i++)
- {
- fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i)));
- }
- currentrow++;
- }
-
- return *fieldmap;
- }
-
- virtual SQLfieldList* GetRowPtr()
- {
- fieldlist = new SQLfieldList();
-
- if (currentrow < rows)
- {
- for (int i = 0; i < Rows(); i++)
- {
- fieldlist->push_back(fieldlists[currentrow][i]);
- }
- currentrow++;
- }
- return fieldlist;
- }
-
- virtual SQLfieldMap* GetRowMapPtr()
- {
- fieldmap = new SQLfieldMap();
-
- if (currentrow < rows)
- {
- for (int i = 0; i < Cols(); i++)
- {
- fieldmap->insert(std::make_pair(colnames[i],GetValue(currentrow, i)));
- }
- currentrow++;
- }
-
- return fieldmap;
- }
-
- virtual void Free(SQLfieldMap* fm)
- {
- delete fm;
- }
-
- virtual void Free(SQLfieldList* fl)
- {
- delete fl;
- }
-
-
-};
-
-class SQLConn : public classbase
-{
- private:
- ResultQueue results;
- InspIRCd* Instance;
- Module* mod;
- SQLhost host;
- sqlite3* conn;
-
- public:
- SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)
- : Instance(SI), mod(m), host(hi)
- {
- if (OpenDB() != SQLITE_OK)
- {
- Instance->Log(DEFAULT, "WARNING: Could not open DB with id: " + host.id);
- CloseDB();
- }
- }
-
- ~SQLConn()
- {
- CloseDB();
- }
-
- SQLerror Query(SQLrequest &req)
- {
- /* Pointer to the buffer we screw around with substitution in */
- char* query;
-
- /* Pointer to the current end of query, where we append new stuff */
- char* queryend;
-
- /* Total length of the unescaped parameters */
- unsigned long paramlen;
-
- /* Total length of query, used for binary-safety in mysql_real_query */
- unsigned long querylength = 0;
-
- paramlen = 0;
- for(ParamL::iterator i = req.query.p.begin(); i != req.query.p.end(); i++)
- {
- paramlen += i->size();
- }
-
- /* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be.
- * sizeofquery + (totalparamlength*2) + 1
- *
- * The +1 is for null-terminating the string for mysql_real_escape_string
- */
- query = new char[req.query.q.length() + (paramlen*2) + 1];
- queryend = query;
-
- for(unsigned long i = 0; i < req.query.q.length(); i++)
- {
- if(req.query.q[i] == '?')
- {
- if(req.query.p.size())
- {
- char* escaped;
- escaped = sqlite3_mprintf("%q", req.query.p.front().c_str());
- for (char* n = escaped; *n; n++)
- {
- *queryend = *n;
- queryend++;
- }
- sqlite3_free(escaped);
- req.query.p.pop_front();
- }
- else
- break;
- }
- else
- {
- *queryend = req.query.q[i];
- queryend++;
- }
- querylength++;
- }
- *queryend = 0;
- req.query.q = query;
-
- SQLite3Result* res = new SQLite3Result(mod, req.GetSource(), req.id);
- res->dbid = host.id;
- res->query = req.query.q;
- paramlist params;
- params.push_back(this);
- params.push_back(res);
-
- char *errmsg = 0;
- sqlite3_update_hook(conn, QueryUpdateHook, ¶ms);
- if (sqlite3_exec(conn, req.query.q.data(), QueryResult, ¶ms, &errmsg) != SQLITE_OK)
- {
- std::string error(errmsg);
- sqlite3_free(errmsg);
- delete[] query;
- delete res;
- return SQLerror(QSEND_FAIL, error);
- }
- delete[] query;
-
- results.push_back(res);
- SendNotify();
- return SQLerror();
- }
-
- static int QueryResult(void *params, int argc, char **argv, char **azColName)
- {
- paramlist* p = (paramlist*)params;
- ((SQLConn*)(*p)[0])->ResultReady(((SQLite3Result*)(*p)[1]), argc, argv, azColName);
- return 0;
- }
-
- static void QueryUpdateHook(void *params, int eventid, char const * azSQLite, char const * azColName, sqlite_int64 rowid)
- {
- paramlist* p = (paramlist*)params;
- ((SQLConn*)(*p)[0])->AffectedReady(((SQLite3Result*)(*p)[1]));
- }\r
-
- void ResultReady(SQLite3Result *res, int cols, char **data, char **colnames)
- {
- res->AddRow(cols, data, colnames);
- }
-
- void AffectedReady(SQLite3Result *res)
- {
- res->UpdateAffectedCount();
- }
-
- int OpenDB()
- {
- return sqlite3_open(host.host.c_str(), &conn);
- }
-
- void CloseDB()
- {
- sqlite3_interrupt(conn);
- sqlite3_close(conn);
- }
-
- SQLhost GetConfHost()
- {
- return host;
- }
-
- void SendResults()
- {
- while (results.size())
- {
- SQLite3Result* res = results[0];
- if (res->GetDest())
- {
- res->Send();
- }
- else
- {
- /* If the client module is unloaded partway through a query then the provider will set
- * the pointer to NULL. We cannot just cancel the query as the result will still come
- * through at some point...and it could get messy if we play with invalid pointers...
- */
- delete res;
- }
- results.pop_front();
- }
- }
-
- void ClearResults()
- {
- while (results.size())
- {
- SQLite3Result* res = results[0];
- delete res;
- results.pop_front();
- }
- }
-
- void SendNotify()
- {
- int QueueFD;
- if ((QueueFD = socket(AF_FAMILY, SOCK_STREAM, 0)) == -1)
- {
- /* crap, we're out of sockets... */
- return;
- }
-
- insp_sockaddr addr;
-
-#ifdef IPV6
- insp_aton("::1", &addr.sin6_addr);
- addr.sin6_family = AF_FAMILY;
- addr.sin6_port = htons(resultnotify->GetPort());
-#else
- insp_inaddr ia;
- insp_aton("127.0.0.1", &ia);
- addr.sin_family = AF_FAMILY;
- addr.sin_addr = ia;
- addr.sin_port = htons(resultnotify->GetPort());
-#endif
-
- if (connect(QueueFD, (sockaddr*)&addr,sizeof(addr)) == -1)
- {
- /* wtf, we cant connect to it, but we just created it! */
- return;
- }
- }
-
-};
-
-
-class ModuleSQLite3 : public Module
-{
- private:
- ConnMap connections;
- unsigned long currid;
-
- public:
- ModuleSQLite3(InspIRCd* Me)
- : Module::Module(Me), currid(0)
- {
- ServerInstance->UseInterface("SQLutils");
-
- if (!ServerInstance->PublishFeature("SQL", this))
- {
- throw ModuleException("m_sqlite3: Unable to publish feature 'SQL'");
- }
-
- resultnotify = new ResultNotifier(ServerInstance, this);
-
- ReadConf();
-
- ServerInstance->PublishInterface("SQL", this);
- }
-
- virtual ~ModuleSQLite3()
- {
- ClearQueue();
- ClearAllConnections();
- resultnotify->SetFd(-1);
- resultnotify->state = I_ERROR;
- resultnotify->OnError(I_ERR_SOCKET);
- resultnotify->ClosePending = true;
- delete resultnotify;
- ServerInstance->UnpublishInterface("SQL", this);
- ServerInstance->UnpublishFeature("SQL");
- ServerInstance->DoneWithInterface("SQLutils");
- }
-
- void Implements(char* List)
- {
- List[I_OnRequest] = List[I_OnRehash] = 1;
- }
-
- void SendQueue()
- {
- for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
- {
- iter->second->SendResults();
- }
- }
-
- void ClearQueue()
- {
- for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
- {
- iter->second->ClearResults();
- }
- }
-
- bool HasHost(const SQLhost &host)
- {
- for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
- {
- if (host == iter->second->GetConfHost())
- return true;
- }
- return false;
- }
-
- bool HostInConf(const SQLhost &h)
- {
- ConfigReader conf(ServerInstance);
- for(int i = 0; i < conf.Enumerate("database"); i++)
- {
- SQLhost host;
- host.id = conf.ReadValue("database", "id", i);
- host.host = conf.ReadValue("database", "hostname", i);
- host.port = conf.ReadInteger("database", "port", i, true);
- host.name = conf.ReadValue("database", "name", i);
- host.user = conf.ReadValue("database", "username", i);
- host.pass = conf.ReadValue("database", "password", i);
- host.ssl = conf.ReadFlag("database", "ssl", "0", i);
- if (h == host)
- return true;
- }
- return false;
- }
-
- void ReadConf()
- {
- ClearOldConnections();
-
- ConfigReader conf(ServerInstance);
- for(int i = 0; i < conf.Enumerate("database"); i++)
- {
- SQLhost host;
-
- host.id = conf.ReadValue("database", "id", i);
- host.host = conf.ReadValue("database", "hostname", i);
- host.port = conf.ReadInteger("database", "port", i, true);
- host.name = conf.ReadValue("database", "name", i);
- host.user = conf.ReadValue("database", "username", i);
- host.pass = conf.ReadValue("database", "password", i);
- host.ssl = conf.ReadFlag("database", "ssl", "0", i);
-
- if (HasHost(host))
- continue;
-
- this->AddConn(host);
- }
- }
-
- void AddConn(const SQLhost& hi)
- {
- if (HasHost(hi))
- {
- ServerInstance->Log(DEFAULT, "WARNING: A sqlite connection with id: %s already exists. Aborting database open attempt.", hi.id.c_str());
- return;
- }
-
- SQLConn* newconn;
-
- newconn = new SQLConn(ServerInstance, this, hi);
-
- connections.insert(std::make_pair(hi.id, newconn));
- }
-
- void ClearOldConnections()
- {
- ConnMap::iterator iter,safei;
- for (iter = connections.begin(); iter != connections.end(); iter++)
- {
- if (!HostInConf(iter->second->GetConfHost()))
- {
- DELETE(iter->second);
- safei = iter;
- --iter;
- connections.erase(safei);
- }
- }
- }
-
- void ClearAllConnections()
- {
- ConnMap::iterator i;
- while ((i = connections.begin()) != connections.end())
- {
- connections.erase(i);
- DELETE(i->second);
- }
- }
-
- virtual void OnRehash(userrec* user, const std::string ¶meter)
- {
- ReadConf();
- }
-
- virtual char* OnRequest(Request* request)
- {
- if(strcmp(SQLREQID, request->GetId()) == 0)
- {
- SQLrequest* req = (SQLrequest*)request;
- ConnMap::iterator iter;
- if((iter = connections.find(req->dbid)) != connections.end())
- {
- req->id = NewID();
- req->error = iter->second->Query(*req);
- return SQLSUCCESS;
- }
- else
- {
- req->error.Id(BAD_DBID);
- return NULL;
- }
- }
- return NULL;
- }
-
- unsigned long NewID()
- {
- if (currid+1 == 0)
- currid++;
-
- return ++currid;
- }
-
- virtual Version GetVersion()
- {
- return Version(1,1,0,0,VF_VENDOR|VF_SERVICEPROVIDER,API_VERSION);
- }
-
-};
-
-void ResultNotifier::Dispatch()
-{
- ((ModuleSQLite3*)mod)->SendQueue();
-}
-
-class ModuleSQLite3Factory : public ModuleFactory
-{
- public:
- ModuleSQLite3Factory()
- {
- }
-
- ~ModuleSQLite3Factory()
- {
- }
-
- virtual Module * CreateModule(InspIRCd* Me)
- {
- return new ModuleSQLite3(Me);
- }
-};
-
-extern "C" void * init_module( void )
-{
- return new ModuleSQLite3Factory;
-}
+/* +------------------------------------+\r
+ * | Inspire Internet Relay Chat Daemon |\r
+ * +------------------------------------+\r
+ *\r
+ * InspIRCd: (C) 2002-2007 InspIRCd Development Team\r
+ * See: http://www.inspircd.org/wiki/index.php/Credits\r
+ *\r
+ * This program is free but copyrighted software; see\r
+ * the file COPYING for details.\r
+ *\r
+ * ---------------------------------------------------\r
+ */\r
+\r
+#include "inspircd.h"\r
+#include <sqlite3.h>\r
+#include "users.h"\r
+#include "channels.h"\r
+#include "modules.h"\r
+\r
+#include "m_sqlv2.h"\r
+\r
+/* $ModDesc: sqlite3 provider */\r
+/* $CompileFlags: pkgconfversion("sqlite3","3.3") pkgconfincludes("sqlite3","/sqlite3.h","") */\r
+/* $LinkerFlags: pkgconflibs("sqlite3","/libsqlite3.so","-lsqlite3") */\r
+/* $ModDep: m_sqlv2.h */\r
+\r
+\r
+class SQLConn;\r
+class SQLite3Result;\r
+class ResultNotifier;\r
+\r
+typedef std::map<std::string, SQLConn*> ConnMap;\r
+typedef std::deque<classbase*> paramlist;\r
+typedef std::deque<SQLite3Result*> ResultQueue;\r
+\r
+ResultNotifier* resultnotify = NULL;\r
+\r
+\r
+class ResultNotifier : public InspSocket\r
+{\r
+ Module* mod;\r
+ insp_sockaddr sock_us;\r
+ socklen_t uslen;\r
+\r
+ public:\r
+ /* Create a socket on a random port. Let the tcp stack allocate us an available port */\r
+#ifdef IPV6\r
+ ResultNotifier(InspIRCd* SI, Module* m) : InspSocket(SI, "::1", 0, true, 3000), mod(m)\r
+#else\r
+ ResultNotifier(InspIRCd* SI, Module* m) : InspSocket(SI, "127.0.0.1", 0, true, 3000), mod(m)\r
+#endif\r
+ {\r
+ uslen = sizeof(sock_us);\r
+ if (getsockname(this->fd,(sockaddr*)&sock_us,&uslen))\r
+ {\r
+ throw ModuleException("Could not create random listening port on localhost");\r
+ }\r
+ }\r
+\r
+ ResultNotifier(InspIRCd* SI, Module* m, int newfd, char* ip) : InspSocket(SI, newfd, ip), mod(m)\r
+ {\r
+ }\r
+\r
+ /* Using getsockname and ntohs, we can determine which port number we were allocated */\r
+ int GetPort()\r
+ {\r
+#ifdef IPV6\r
+ return ntohs(sock_us.sin6_port);\r
+#else\r
+ return ntohs(sock_us.sin_port);\r
+#endif\r
+ }\r
+\r
+ virtual int OnIncomingConnection(int newsock, char* ip)\r
+ {\r
+ Dispatch();\r
+ return false;\r
+ }\r
+\r
+ void Dispatch();\r
+};\r
+\r
+\r
+class SQLite3Result : public SQLresult\r
+{\r
+ private:\r
+ int currentrow;\r
+ int rows;\r
+ int cols;\r
+\r
+ std::vector<std::string> colnames;\r
+ std::vector<SQLfieldList> fieldlists;\r
+ SQLfieldList emptyfieldlist;\r
+\r
+ SQLfieldList* fieldlist;\r
+ SQLfieldMap* fieldmap;\r
+\r
+ public:\r
+ SQLite3Result(Module* self, Module* to, unsigned int id)\r
+ : SQLresult(self, to, id), currentrow(0), rows(0), cols(0), fieldlist(NULL), fieldmap(NULL)\r
+ {\r
+ }\r
+\r
+ ~SQLite3Result()\r
+ {\r
+ }\r
+\r
+ void AddRow(int colsnum, char **data, char **colname)\r
+ {\r
+ colnames.clear();\r
+ cols = colsnum;\r
+ for (int i = 0; i < colsnum; i++)\r
+ {\r
+ fieldlists.resize(fieldlists.size()+1);\r
+ colnames.push_back(colname[i]);\r
+ SQLfield sf(data[i] ? data[i] : "", data[i] ? false : true);\r
+ fieldlists[rows].push_back(sf);\r
+ }\r
+ rows++;\r
+ }\r
+\r
+ void UpdateAffectedCount()\r
+ {\r
+ rows++;\r
+ }\r
+\r
+ virtual int Rows()\r
+ {\r
+ return rows;\r
+ }\r
+\r
+ virtual int Cols()\r
+ {\r
+ return cols;\r
+ }\r
+\r
+ virtual std::string ColName(int column)\r
+ {\r
+ if (column < (int)colnames.size())\r
+ {\r
+ return colnames[column];\r
+ }\r
+ else\r
+ {\r
+ throw SQLbadColName();\r
+ }\r
+ return "";\r
+ }\r
+\r
+ virtual int ColNum(const std::string &column)\r
+ {\r
+ for (unsigned int i = 0; i < colnames.size(); i++)\r
+ {\r
+ if (column == colnames[i])\r
+ return i;\r
+ }\r
+ throw SQLbadColName();\r
+ return 0;\r
+ }\r
+\r
+ virtual SQLfield GetValue(int row, int column)\r
+ {\r
+ if ((row >= 0) && (row < rows) && (column >= 0) && (column < Cols()))\r
+ {\r
+ return fieldlists[row][column];\r
+ }\r
+\r
+ throw SQLbadColName();\r
+\r
+ /* XXX: We never actually get here because of the throw */\r
+ return SQLfield("",true);\r
+ }\r
+\r
+ virtual SQLfieldList& GetRow()\r
+ {\r
+ if (currentrow < rows)\r
+ return fieldlists[currentrow];\r
+ else\r
+ return emptyfieldlist;\r
+ }\r
+\r
+ virtual SQLfieldMap& GetRowMap()\r
+ {\r
+ /* In an effort to reduce overhead we don't actually allocate the map\r
+ * until the first time it's needed...so...\r
+ */\r
+ if(fieldmap)\r
+ {\r
+ fieldmap->clear();\r
+ }\r
+ else\r
+ {\r
+ fieldmap = new SQLfieldMap;\r
+ }\r
+\r
+ if (currentrow < rows)\r
+ {\r
+ for (int i = 0; i < Cols(); i++)\r
+ {\r
+ fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i)));\r
+ }\r
+ currentrow++;\r
+ }\r
+\r
+ return *fieldmap;\r
+ }\r
+\r
+ virtual SQLfieldList* GetRowPtr()\r
+ {\r
+ fieldlist = new SQLfieldList();\r
+\r
+ if (currentrow < rows)\r
+ {\r
+ for (int i = 0; i < Rows(); i++)\r
+ {\r
+ fieldlist->push_back(fieldlists[currentrow][i]);\r
+ }\r
+ currentrow++;\r
+ }\r
+ return fieldlist;\r
+ }\r
+\r
+ virtual SQLfieldMap* GetRowMapPtr()\r
+ {\r
+ fieldmap = new SQLfieldMap();\r
+\r
+ if (currentrow < rows)\r
+ {\r
+ for (int i = 0; i < Cols(); i++)\r
+ {\r
+ fieldmap->insert(std::make_pair(colnames[i],GetValue(currentrow, i)));\r
+ }\r
+ currentrow++;\r
+ }\r
+\r
+ return fieldmap;\r
+ }\r
+\r
+ virtual void Free(SQLfieldMap* fm)\r
+ {\r
+ delete fm;\r
+ }\r
+\r
+ virtual void Free(SQLfieldList* fl)\r
+ {\r
+ delete fl;\r
+ }\r
+\r
+\r
+};\r
+\r
+class SQLConn : public classbase\r
+{\r
+ private:\r
+ ResultQueue results;\r
+ InspIRCd* Instance;\r
+ Module* mod;\r
+ SQLhost host;\r
+ sqlite3* conn;\r
+\r
+ public:\r
+ SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)\r
+ : Instance(SI), mod(m), host(hi)\r
+ {\r
+ if (OpenDB() != SQLITE_OK)\r
+ {\r
+ Instance->Log(DEFAULT, "WARNING: Could not open DB with id: " + host.id);\r
+ CloseDB();\r
+ }\r
+ }\r
+\r
+ ~SQLConn()\r
+ {\r
+ CloseDB();\r
+ }\r
+\r
+ SQLerror Query(SQLrequest &req)\r
+ {\r
+ /* Pointer to the buffer we screw around with substitution in */\r
+ char* query;\r
+\r
+ /* Pointer to the current end of query, where we append new stuff */\r
+ char* queryend;\r
+\r
+ /* Total length of the unescaped parameters */\r
+ unsigned long paramlen;\r
+\r
+ /* Total length of query, used for binary-safety in mysql_real_query */\r
+ unsigned long querylength = 0;\r
+\r
+ paramlen = 0;\r
+ for(ParamL::iterator i = req.query.p.begin(); i != req.query.p.end(); i++)\r
+ {\r
+ paramlen += i->size();\r
+ }\r
+\r
+ /* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be.\r
+ * sizeofquery + (totalparamlength*2) + 1\r
+ *\r
+ * The +1 is for null-terminating the string for mysql_real_escape_string\r
+ */\r
+ query = new char[req.query.q.length() + (paramlen*2) + 1];\r
+ queryend = query;\r
+\r
+ for(unsigned long i = 0; i < req.query.q.length(); i++)\r
+ {\r
+ if(req.query.q[i] == '?')\r
+ {\r
+ if(req.query.p.size())\r
+ {\r
+ char* escaped;\r
+ escaped = sqlite3_mprintf("%q", req.query.p.front().c_str());\r
+ for (char* n = escaped; *n; n++)\r
+ {\r
+ *queryend = *n;\r
+ queryend++;\r
+ }\r
+ sqlite3_free(escaped);\r
+ req.query.p.pop_front();\r
+ }\r
+ else\r
+ break;\r
+ }\r
+ else\r
+ {\r
+ *queryend = req.query.q[i];\r
+ queryend++;\r
+ }\r
+ querylength++;\r
+ }\r
+ *queryend = 0;\r
+ req.query.q = query;\r
+\r
+ SQLite3Result* res = new SQLite3Result(mod, req.GetSource(), req.id);\r
+ res->dbid = host.id;\r
+ res->query = req.query.q;\r
+ paramlist params;\r
+ params.push_back(this);\r
+ params.push_back(res);\r
+\r
+ char *errmsg = 0;\r
+ sqlite3_update_hook(conn, QueryUpdateHook, ¶ms);\r
+ if (sqlite3_exec(conn, req.query.q.data(), QueryResult, ¶ms, &errmsg) != SQLITE_OK)\r
+ {\r
+ std::string error(errmsg);\r
+ sqlite3_free(errmsg);\r
+ delete[] query;\r
+ delete res;\r
+ return SQLerror(QSEND_FAIL, error);\r
+ }\r
+ delete[] query;\r
+\r
+ results.push_back(res);\r
+ SendNotify();\r
+ return SQLerror();\r
+ }\r
+\r
+ static int QueryResult(void *params, int argc, char **argv, char **azColName)\r
+ {\r
+ paramlist* p = (paramlist*)params;\r
+ ((SQLConn*)(*p)[0])->ResultReady(((SQLite3Result*)(*p)[1]), argc, argv, azColName);\r
+ return 0;\r
+ }\r
+\r
+ static void QueryUpdateHook(void *params, int eventid, char const * azSQLite, char const * azColName, sqlite_int64 rowid)\r
+ {\r
+ paramlist* p = (paramlist*)params;\r
+ ((SQLConn*)(*p)[0])->AffectedReady(((SQLite3Result*)(*p)[1]));\r
+ }\r
+\r
+ void ResultReady(SQLite3Result *res, int cols, char **data, char **colnames)\r
+ {\r
+ res->AddRow(cols, data, colnames);\r
+ }\r
+\r
+ void AffectedReady(SQLite3Result *res)\r
+ {\r
+ res->UpdateAffectedCount();\r
+ }\r
+\r
+ int OpenDB()\r
+ {\r
+ return sqlite3_open(host.host.c_str(), &conn);\r
+ }\r
+\r
+ void CloseDB()\r
+ {\r
+ sqlite3_interrupt(conn);\r
+ sqlite3_close(conn);\r
+ }\r
+\r
+ SQLhost GetConfHost()\r
+ {\r
+ return host;\r
+ }\r
+\r
+ void SendResults()\r
+ {\r
+ while (results.size())\r
+ {\r
+ SQLite3Result* res = results[0];\r
+ if (res->GetDest())\r
+ {\r
+ res->Send();\r
+ }\r
+ else\r
+ {\r
+ /* If the client module is unloaded partway through a query then the provider will set\r
+ * the pointer to NULL. We cannot just cancel the query as the result will still come\r
+ * through at some point...and it could get messy if we play with invalid pointers...\r
+ */\r
+ delete res;\r
+ }\r
+ results.pop_front();\r
+ }\r
+ }\r
+\r
+ void ClearResults()\r
+ {\r
+ while (results.size())\r
+ {\r
+ SQLite3Result* res = results[0];\r
+ delete res;\r
+ results.pop_front();\r
+ }\r
+ }\r
+\r
+ void SendNotify()\r
+ {\r
+ int QueueFD;\r
+ if ((QueueFD = socket(AF_FAMILY, SOCK_STREAM, 0)) == -1)\r
+ {\r
+ /* crap, we're out of sockets... */\r
+ return;\r
+ }\r
+\r
+ insp_sockaddr addr;\r
+\r
+#ifdef IPV6\r
+ insp_aton("::1", &addr.sin6_addr);\r
+ addr.sin6_family = AF_FAMILY;\r
+ addr.sin6_port = htons(resultnotify->GetPort());\r
+#else\r
+ insp_inaddr ia;\r
+ insp_aton("127.0.0.1", &ia);\r
+ addr.sin_family = AF_FAMILY;\r
+ addr.sin_addr = ia;\r
+ addr.sin_port = htons(resultnotify->GetPort());\r
+#endif\r
+\r
+ if (connect(QueueFD, (sockaddr*)&addr,sizeof(addr)) == -1)\r
+ {\r
+ /* wtf, we cant connect to it, but we just created it! */\r
+ return;\r
+ }\r
+ }\r
+\r
+};\r
+\r
+\r
+class ModuleSQLite3 : public Module\r
+{\r
+ private:\r
+ ConnMap connections;\r
+ unsigned long currid;\r
+\r
+ public:\r
+ ModuleSQLite3(InspIRCd* Me)\r
+ : Module::Module(Me), currid(0)\r
+ {\r
+ ServerInstance->UseInterface("SQLutils");\r
+\r
+ if (!ServerInstance->PublishFeature("SQL", this))\r
+ {\r
+ throw ModuleException("m_sqlite3: Unable to publish feature 'SQL'");\r
+ }\r
+\r
+ resultnotify = new ResultNotifier(ServerInstance, this);\r
+\r
+ ReadConf();\r
+\r
+ ServerInstance->PublishInterface("SQL", this);\r
+ }\r
+\r
+ virtual ~ModuleSQLite3()\r
+ {\r
+ ClearQueue();\r
+ ClearAllConnections();\r
+ resultnotify->SetFd(-1);\r
+ resultnotify->state = I_ERROR;\r
+ resultnotify->OnError(I_ERR_SOCKET);\r
+ resultnotify->ClosePending = true;\r
+ delete resultnotify;\r
+ ServerInstance->UnpublishInterface("SQL", this);\r
+ ServerInstance->UnpublishFeature("SQL");\r
+ ServerInstance->DoneWithInterface("SQLutils");\r
+ }\r
+\r
+ void Implements(char* List)\r
+ {\r
+ List[I_OnRequest] = List[I_OnRehash] = 1;\r
+ }\r
+\r
+ void SendQueue()\r
+ {\r
+ for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)\r
+ {\r
+ iter->second->SendResults();\r
+ }\r
+ }\r
+\r
+ void ClearQueue()\r
+ {\r
+ for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)\r
+ {\r
+ iter->second->ClearResults();\r
+ }\r
+ }\r
+\r
+ bool HasHost(const SQLhost &host)\r
+ {\r
+ for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)\r
+ {\r
+ if (host == iter->second->GetConfHost())\r
+ return true;\r
+ }\r
+ return false;\r
+ }\r
+\r
+ bool HostInConf(const SQLhost &h)\r
+ {\r
+ ConfigReader conf(ServerInstance);\r
+ for(int i = 0; i < conf.Enumerate("database"); i++)\r
+ {\r
+ SQLhost host;\r
+ host.id = conf.ReadValue("database", "id", i);\r
+ host.host = conf.ReadValue("database", "hostname", i);\r
+ host.port = conf.ReadInteger("database", "port", i, true);\r
+ host.name = conf.ReadValue("database", "name", i);\r
+ host.user = conf.ReadValue("database", "username", i);\r
+ host.pass = conf.ReadValue("database", "password", i);\r
+ host.ssl = conf.ReadFlag("database", "ssl", "0", i);\r
+ if (h == host)\r
+ return true;\r
+ }\r
+ return false;\r
+ }\r
+\r
+ void ReadConf()\r
+ {\r
+ ClearOldConnections();\r
+\r
+ ConfigReader conf(ServerInstance);\r
+ for(int i = 0; i < conf.Enumerate("database"); i++)\r
+ {\r
+ SQLhost host;\r
+\r
+ host.id = conf.ReadValue("database", "id", i);\r
+ host.host = conf.ReadValue("database", "hostname", i);\r
+ host.port = conf.ReadInteger("database", "port", i, true);\r
+ host.name = conf.ReadValue("database", "name", i);\r
+ host.user = conf.ReadValue("database", "username", i);\r
+ host.pass = conf.ReadValue("database", "password", i);\r
+ host.ssl = conf.ReadFlag("database", "ssl", "0", i);\r
+\r
+ if (HasHost(host))\r
+ continue;\r
+\r
+ this->AddConn(host);\r
+ }\r
+ }\r
+\r
+ void AddConn(const SQLhost& hi)\r
+ {\r
+ if (HasHost(hi))\r
+ {\r
+ ServerInstance->Log(DEFAULT, "WARNING: A sqlite connection with id: %s already exists. Aborting database open attempt.", hi.id.c_str());\r
+ return;\r
+ }\r
+\r
+ SQLConn* newconn;\r
+\r
+ newconn = new SQLConn(ServerInstance, this, hi);\r
+\r
+ connections.insert(std::make_pair(hi.id, newconn));\r
+ }\r
+\r
+ void ClearOldConnections()\r
+ {\r
+ ConnMap::iterator iter,safei;\r
+ for (iter = connections.begin(); iter != connections.end(); iter++)\r
+ {\r
+ if (!HostInConf(iter->second->GetConfHost()))\r
+ {\r
+ DELETE(iter->second);\r
+ safei = iter;\r
+ --iter;\r
+ connections.erase(safei);\r
+ }\r
+ }\r
+ }\r
+\r
+ void ClearAllConnections()\r
+ {\r
+ ConnMap::iterator i;\r
+ while ((i = connections.begin()) != connections.end())\r
+ {\r
+ connections.erase(i);\r
+ DELETE(i->second);\r
+ }\r
+ }\r
+\r
+ virtual void OnRehash(userrec* user, const std::string ¶meter)\r
+ {\r
+ ReadConf();\r
+ }\r
+\r
+ virtual char* OnRequest(Request* request)\r
+ {\r
+ if(strcmp(SQLREQID, request->GetId()) == 0)\r
+ {\r
+ SQLrequest* req = (SQLrequest*)request;\r
+ ConnMap::iterator iter;\r
+ if((iter = connections.find(req->dbid)) != connections.end())\r
+ {\r
+ req->id = NewID();\r
+ req->error = iter->second->Query(*req);\r
+ return SQLSUCCESS;\r
+ }\r
+ else\r
+ {\r
+ req->error.Id(BAD_DBID);\r
+ return NULL;\r
+ }\r
+ }\r
+ return NULL;\r
+ }\r
+\r
+ unsigned long NewID()\r
+ {\r
+ if (currid+1 == 0)\r
+ currid++;\r
+\r
+ return ++currid;\r
+ }\r
+\r
+ virtual Version GetVersion()\r
+ {\r
+ return Version(1,1,0,0,VF_VENDOR|VF_SERVICEPROVIDER,API_VERSION);\r
+ }\r
+\r
+};\r
+\r
+void ResultNotifier::Dispatch()\r
+{\r
+ ((ModuleSQLite3*)mod)->SendQueue();\r
+}\r
+\r
+class ModuleSQLite3Factory : public ModuleFactory\r
+{\r
+ public:\r
+ ModuleSQLite3Factory()\r
+ {\r
+ }\r
+\r
+ ~ModuleSQLite3Factory()\r
+ {\r
+ }\r
+\r
+ virtual Module * CreateModule(InspIRCd* Me)\r
+ {\r
+ return new ModuleSQLite3(Me);\r
+ }\r
+};\r
+\r
+extern "C" void * init_module( void )\r
+{\r
+ return new ModuleSQLite3Factory;\r
+}\r
projects / user / henk / code / inspircd.git / blobdiff