src/modules/extra/m_sqlite3.cpp

   1 /*       +------------------------------------+\r
   2  *       | Inspire Internet Relay Chat Daemon |\r
   3  *       +------------------------------------+\r
   4  *\r
   5  *  InspIRCd: (C) 2002-2007 InspIRCd Development Team\r
   6  * See: http://www.inspircd.org/wiki/index.php/Credits\r
   7  *\r
   8  * This program is free but copyrighted software; see\r
   9  *            the file COPYING for details.\r
  10  *\r
  11  * ---------------------------------------------------\r
  12  */\r
  13 \r
  14 #include "inspircd.h"\r
  15 #include <sqlite3.h>\r
  16 #include "users.h"\r
  17 #include "channels.h"\r
  18 #include "modules.h"\r
  19 \r
  20 #include "m_sqlv2.h"\r
  21 \r
  22 /* $ModDesc: sqlite3 provider */\r
  23 /* $CompileFlags: pkgconfversion("sqlite3","3.3") pkgconfincludes("sqlite3","/sqlite3.h","") */\r
  24 /* $LinkerFlags: pkgconflibs("sqlite3","/libsqlite3.so","-lsqlite3") */\r
  25 /* $ModDep: m_sqlv2.h */\r
  26 \r
  27 \r
  28 class SQLConn;\r
  29 class SQLite3Result;\r
  30 class ResultNotifier;\r
  31 \r
  32 typedef std::map<std::string, SQLConn*> ConnMap;\r
  33 typedef std::deque<classbase*> paramlist;\r
  34 typedef std::deque<SQLite3Result*> ResultQueue;\r
  35 \r
  36 ResultNotifier* resultnotify = NULL;\r
  37 \r
  38 \r
  39 class ResultNotifier : public InspSocket\r
  40 {\r
  41         Module* mod;\r
  42         insp_sockaddr sock_us;\r
  43         socklen_t uslen;\r
  44 \r
  45  public:\r
  46         /* Create a socket on a random port. Let the tcp stack allocate us an available port */\r
  47 #ifdef IPV6\r
  48         ResultNotifier(InspIRCd* SI, Module* m) : InspSocket(SI, "::1", 0, true, 3000), mod(m)\r
  49 #else\r
  50         ResultNotifier(InspIRCd* SI, Module* m) : InspSocket(SI, "127.0.0.1", 0, true, 3000), mod(m)\r
  51 #endif\r
  52         {\r
  53                 uslen = sizeof(sock_us);\r
  54                 if (getsockname(this->fd,(sockaddr*)&sock_us,&uslen))\r
  55                 {\r
  56                         throw ModuleException("Could not create random listening port on localhost");\r
  57                 }\r
  58         }\r
  59 \r
  60         ResultNotifier(InspIRCd* SI, Module* m, int newfd, char* ip) : InspSocket(SI, newfd, ip), mod(m)\r
  61         {\r
  62         }\r
  63 \r
  64         /* Using getsockname and ntohs, we can determine which port number we were allocated */\r
  65         int GetPort()\r
  66         {\r
  67 #ifdef IPV6\r
  68                 return ntohs(sock_us.sin6_port);\r
  69 #else\r
  70                 return ntohs(sock_us.sin_port);\r
  71 #endif\r
  72         }\r
  73 \r
  74         virtual int OnIncomingConnection(int newsock, char* ip)\r
  75         {\r
  76                 Dispatch();\r
  77                 return false;\r
  78         }\r
  79 \r
  80         void Dispatch();\r
  81 };\r
  82 \r
  83 \r
  84 class SQLite3Result : public SQLresult\r
  85 {\r
  86   private:\r
  87         int currentrow;\r
  88         int rows;\r
  89         int cols;\r
  90 \r
  91         std::vector<std::string> colnames;\r
  92         std::vector<SQLfieldList> fieldlists;\r
  93         SQLfieldList emptyfieldlist;\r
  94 \r
  95         SQLfieldList* fieldlist;\r
  96         SQLfieldMap* fieldmap;\r
  97 \r
  98   public:\r
  99         SQLite3Result(Module* self, Module* to, unsigned int id)\r
 100         : SQLresult(self, to, id), currentrow(0), rows(0), cols(0), fieldlist(NULL), fieldmap(NULL)\r
 101         {\r
 102         }\r
 103 \r
 104         ~SQLite3Result()\r
 105         {\r
 106         }\r
 107 \r
 108         void AddRow(int colsnum, char **data, char **colname)\r
 109         {\r
 110                 colnames.clear();\r
 111                 cols = colsnum;\r
 112                 for (int i = 0; i < colsnum; i++)\r
 113                 {\r
 114                         fieldlists.resize(fieldlists.size()+1);\r
 115                         colnames.push_back(colname[i]);\r
 116                         SQLfield sf(data[i] ? data[i] : "", data[i] ? false : true);\r
 117                         fieldlists[rows].push_back(sf);\r
 118                 }\r
 119                 rows++;\r
 120         }\r
 121 \r
 122         void UpdateAffectedCount()\r
 123         {\r
 124                 rows++;\r
 125         }\r
 126 \r
 127         virtual int Rows()\r
 128         {\r
 129                 return rows;\r
 130         }\r
 131 \r
 132         virtual int Cols()\r
 133         {\r
 134                 return cols;\r
 135         }\r
 136 \r
 137         virtual std::string ColName(int column)\r
 138         {\r
 139                 if (column < (int)colnames.size())\r
 140                 {\r
 141                         return colnames[column];\r
 142                 }\r
 143                 else\r
 144                 {\r
 145                         throw SQLbadColName();\r
 146                 }\r
 147                 return "";\r
 148         }\r
 149 \r
 150         virtual int ColNum(const std::string &column)\r
 151         {\r
 152                 for (unsigned int i = 0; i < colnames.size(); i++)\r
 153                 {\r
 154                         if (column == colnames[i])\r
 155                                 return i;\r
 156                 }\r
 157                 throw SQLbadColName();\r
 158                 return 0;\r
 159         }\r
 160 \r
 161         virtual SQLfield GetValue(int row, int column)\r
 162         {\r
 163                 if ((row >= 0) && (row < rows) && (column >= 0) && (column < Cols()))\r
 164                 {\r
 165                         return fieldlists[row][column];\r
 166                 }\r
 167 \r
 168                 throw SQLbadColName();\r
 169 \r
 170                 /* XXX: We never actually get here because of the throw */\r
 171                 return SQLfield("",true);\r
 172         }\r
 173 \r
 174         virtual SQLfieldList& GetRow()\r
 175         {\r
 176                 if (currentrow < rows)\r
 177                         return fieldlists[currentrow];\r
 178                 else\r
 179                         return emptyfieldlist;\r
 180         }\r
 181 \r
 182         virtual SQLfieldMap& GetRowMap()\r
 183         {\r
 184                 /* In an effort to reduce overhead we don't actually allocate the map\r
 185                  * until the first time it's needed...so...\r
 186                  */\r
 187                 if(fieldmap)\r
 188                 {\r
 189                         fieldmap->clear();\r
 190                 }\r
 191                 else\r
 192                 {\r
 193                         fieldmap = new SQLfieldMap;\r
 194                 }\r
 195 \r
 196                 if (currentrow < rows)\r
 197                 {\r
 198                         for (int i = 0; i < Cols(); i++)\r
 199                         {\r
 200                                 fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i)));\r
 201                         }\r
 202                         currentrow++;\r
 203                 }\r
 204 \r
 205                 return *fieldmap;\r
 206         }\r
 207 \r
 208         virtual SQLfieldList* GetRowPtr()\r
 209         {\r
 210                 fieldlist = new SQLfieldList();\r
 211 \r
 212                 if (currentrow < rows)\r
 213                 {\r
 214                         for (int i = 0; i < Rows(); i++)\r
 215                         {\r
 216                                 fieldlist->push_back(fieldlists[currentrow][i]);\r
 217                         }\r
 218                         currentrow++;\r
 219                 }\r
 220                 return fieldlist;\r
 221         }\r
 222 \r
 223         virtual SQLfieldMap* GetRowMapPtr()\r
 224         {\r
 225                 fieldmap = new SQLfieldMap();\r
 226 \r
 227                 if (currentrow < rows)\r
 228                 {\r
 229                         for (int i = 0; i < Cols(); i++)\r
 230                         {\r
 231                                 fieldmap->insert(std::make_pair(colnames[i],GetValue(currentrow, i)));\r
 232                         }\r
 233                         currentrow++;\r
 234                 }\r
 235 \r
 236                 return fieldmap;\r
 237         }\r
 238 \r
 239         virtual void Free(SQLfieldMap* fm)\r
 240         {\r
 241                 delete fm;\r
 242         }\r
 243 \r
 244         virtual void Free(SQLfieldList* fl)\r
 245         {\r
 246                 delete fl;\r
 247         }\r
 248 \r
 249 \r
 250 };\r
 251 \r
 252 class SQLConn : public classbase\r
 253 {\r
 254   private:\r
 255         ResultQueue results;\r
 256         InspIRCd* Instance;\r
 257         Module* mod;\r
 258         SQLhost host;\r
 259         sqlite3* conn;\r
 260 \r
 261   public:\r
 262         SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)\r
 263         : Instance(SI), mod(m), host(hi)\r
 264         {\r
 265                 if (OpenDB() != SQLITE_OK)\r
 266                 {\r
 267                         Instance->Log(DEFAULT, "WARNING: Could not open DB with id: " + host.id);\r
 268                         CloseDB();\r
 269                 }\r
 270         }\r
 271 \r
 272         ~SQLConn()\r
 273         {\r
 274                 CloseDB();\r
 275         }\r
 276 \r
 277         SQLerror Query(SQLrequest &req)\r
 278         {\r
 279                 /* Pointer to the buffer we screw around with substitution in */\r
 280                 char* query;\r
 281 \r
 282                 /* Pointer to the current end of query, where we append new stuff */\r
 283                 char* queryend;\r
 284 \r
 285                 /* Total length of the unescaped parameters */\r
 286                 unsigned long paramlen;\r
 287 \r
 288                 /* Total length of query, used for binary-safety in mysql_real_query */\r
 289                 unsigned long querylength = 0;\r
 290 \r
 291                 paramlen = 0;\r
 292                 for(ParamL::iterator i = req.query.p.begin(); i != req.query.p.end(); i++)\r
 293                 {\r
 294                         paramlen += i->size();\r
 295                 }\r
 296 \r
 297                 /* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be.\r
 298                  * sizeofquery + (totalparamlength*2) + 1\r
 299                  *\r
 300                  * The +1 is for null-terminating the string for mysql_real_escape_string\r
 301                  */\r
 302                 query = new char[req.query.q.length() + (paramlen*2) + 1];\r
 303                 queryend = query;\r
 304 \r
 305                 for(unsigned long i = 0; i < req.query.q.length(); i++)\r
 306                 {\r
 307                         if(req.query.q[i] == '?')\r
 308                         {\r
 309                                 if(req.query.p.size())\r
 310                                 {\r
 311                                         char* escaped;\r
 312                                         escaped = sqlite3_mprintf("%q", req.query.p.front().c_str());\r
 313                                         for (char* n = escaped; *n; n++)\r
 314                                         {\r
 315                                                 *queryend = *n;\r
 316                                                 queryend++;\r
 317                                         }\r
 318                                         sqlite3_free(escaped);\r
 319                                         req.query.p.pop_front();\r
 320                                 }\r
 321                                 else\r
 322                                         break;\r
 323                         }\r
 324                         else\r
 325                         {\r
 326                                 *queryend = req.query.q[i];\r
 327                                 queryend++;\r
 328                         }\r
 329                         querylength++;\r
 330                 }\r
 331                 *queryend = 0;\r
 332                 req.query.q = query;\r
 333 \r
 334                 SQLite3Result* res = new SQLite3Result(mod, req.GetSource(), req.id);\r
 335                 res->dbid = host.id;\r
 336                 res->query = req.query.q;\r
 337                 paramlist params;\r
 338                 params.push_back(this);\r
 339                 params.push_back(res);\r
 340 \r
 341                 char *errmsg = 0;\r
 342                 sqlite3_update_hook(conn, QueryUpdateHook, &params);\r
 343                 if (sqlite3_exec(conn, req.query.q.data(), QueryResult, &params, &errmsg) != SQLITE_OK)\r
 344                 {\r
 345                         std::string error(errmsg);\r
 346                         sqlite3_free(errmsg);\r
 347                         delete[] query;\r
 348                         delete res;\r
 349                         return SQLerror(QSEND_FAIL, error);\r
 350                 }\r
 351                 delete[] query;\r
 352 \r
 353                 results.push_back(res);\r
 354                 SendNotify();\r
 355                 return SQLerror();\r
 356         }\r
 357 \r
 358         static int QueryResult(void *params, int argc, char **argv, char **azColName)\r
 359         {\r
 360                 paramlist* p = (paramlist*)params;\r
 361                 ((SQLConn*)(*p)[0])->ResultReady(((SQLite3Result*)(*p)[1]), argc, argv, azColName);\r
 362                 return 0;\r
 363         }\r
 364 \r
 365         static void QueryUpdateHook(void *params, int eventid, char const * azSQLite, char const * azColName, sqlite_int64 rowid)\r
 366         {\r
 367                 paramlist* p = (paramlist*)params;\r
 368                 ((SQLConn*)(*p)[0])->AffectedReady(((SQLite3Result*)(*p)[1]));\r
 369         }\r
 370 \r
 371         void ResultReady(SQLite3Result *res, int cols, char **data, char **colnames)\r
 372         {\r
 373                 res->AddRow(cols, data, colnames);\r
 374         }\r
 375 \r
 376         void AffectedReady(SQLite3Result *res)\r
 377         {\r
 378                 res->UpdateAffectedCount();\r
 379         }\r
 380 \r
 381         int OpenDB()\r
 382         {\r
 383                 return sqlite3_open(host.host.c_str(), &conn);\r
 384         }\r
 385 \r
 386         void CloseDB()\r
 387         {\r
 388                 sqlite3_interrupt(conn);\r
 389                 sqlite3_close(conn);\r
 390         }\r
 391 \r
 392         SQLhost GetConfHost()\r
 393         {\r
 394                 return host;\r
 395         }\r
 396 \r
 397         void SendResults()\r
 398         {\r
 399                 while (results.size())\r
 400                 {\r
 401                         SQLite3Result* res = results[0];\r
 402                         if (res->GetDest())\r
 403                         {\r
 404                                 res->Send();\r
 405                         }\r
 406                         else\r
 407                         {\r
 408                                 /* If the client module is unloaded partway through a query then the provider will set\r
 409                                  * the pointer to NULL. We cannot just cancel the query as the result will still come\r
 410                                  * through at some point...and it could get messy if we play with invalid pointers...\r
 411                                  */\r
 412                                 delete res;\r
 413                         }\r
 414                         results.pop_front();\r
 415                 }\r
 416         }\r
 417 \r
 418         void ClearResults()\r
 419         {\r
 420                 while (results.size())\r
 421                 {\r
 422                         SQLite3Result* res = results[0];\r
 423                         delete res;\r
 424                         results.pop_front();\r
 425                 }\r
 426         }\r
 427 \r
 428         void SendNotify()\r
 429         {\r
 430                 int QueueFD;\r
 431                 if ((QueueFD = socket(AF_FAMILY, SOCK_STREAM, 0)) == -1)\r
 432                 {\r
 433                         /* crap, we're out of sockets... */\r
 434                         return;\r
 435                 }\r
 436 \r
 437                 insp_sockaddr addr;\r
 438 \r
 439 #ifdef IPV6\r
 440                 insp_aton("::1", &addr.sin6_addr);\r
 441                 addr.sin6_family = AF_FAMILY;\r
 442                 addr.sin6_port = htons(resultnotify->GetPort());\r
 443 #else\r
 444                 insp_inaddr ia;\r
 445                 insp_aton("127.0.0.1", &ia);\r
 446                 addr.sin_family = AF_FAMILY;\r
 447                 addr.sin_addr = ia;\r
 448                 addr.sin_port = htons(resultnotify->GetPort());\r
 449 #endif\r
 450 \r
 451                 if (connect(QueueFD, (sockaddr*)&addr,sizeof(addr)) == -1)\r
 452                 {\r
 453                         /* wtf, we cant connect to it, but we just created it! */\r
 454                         return;\r
 455                 }\r
 456         }\r
 457 \r
 458 };\r
 459 \r
 460 \r
 461 class ModuleSQLite3 : public Module\r
 462 {\r
 463   private:\r
 464         ConnMap connections;\r
 465         unsigned long currid;\r
 466 \r
 467   public:\r
 468         ModuleSQLite3(InspIRCd* Me)\r
 469         : Module::Module(Me), currid(0)\r
 470         {\r
 471                 ServerInstance->UseInterface("SQLutils");\r
 472 \r
 473                 if (!ServerInstance->PublishFeature("SQL", this))\r
 474                 {\r
 475                         throw ModuleException("m_sqlite3: Unable to publish feature 'SQL'");\r
 476                 }\r
 477 \r
 478                 resultnotify = new ResultNotifier(ServerInstance, this);\r
 479 \r
 480                 ReadConf();\r
 481 \r
 482                 ServerInstance->PublishInterface("SQL", this);\r
 483         }\r
 484 \r
 485         virtual ~ModuleSQLite3()\r
 486         {\r
 487                 ClearQueue();\r
 488                 ClearAllConnections();\r
 489                 resultnotify->SetFd(-1);\r
 490                 resultnotify->state = I_ERROR;\r
 491                 resultnotify->OnError(I_ERR_SOCKET);\r
 492                 resultnotify->ClosePending = true;\r
 493                 delete resultnotify;\r
 494                 ServerInstance->UnpublishInterface("SQL", this);\r
 495                 ServerInstance->UnpublishFeature("SQL");\r
 496                 ServerInstance->DoneWithInterface("SQLutils");\r
 497         }\r
 498 \r
 499         void Implements(char* List)\r
 500         {\r
 501                 List[I_OnRequest] = List[I_OnRehash] = 1;\r
 502         }\r
 503 \r
 504         void SendQueue()\r
 505         {\r
 506                 for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)\r
 507                 {\r
 508                         iter->second->SendResults();\r
 509                 }\r
 510         }\r
 511 \r
 512         void ClearQueue()\r
 513         {\r
 514                 for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)\r
 515                 {\r
 516                         iter->second->ClearResults();\r
 517                 }\r
 518         }\r
 519 \r
 520         bool HasHost(const SQLhost &host)\r
 521         {\r
 522                 for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)\r
 523                 {\r
 524                         if (host == iter->second->GetConfHost())\r
 525                                 return true;\r
 526                 }\r
 527                 return false;\r
 528         }\r
 529 \r
 530         bool HostInConf(const SQLhost &h)\r
 531         {\r
 532                 ConfigReader conf(ServerInstance);\r
 533                 for(int i = 0; i < conf.Enumerate("database"); i++)\r
 534                 {\r
 535                         SQLhost host;\r
 536                         host.id         = conf.ReadValue("database", "id", i);\r
 537                         host.host       = conf.ReadValue("database", "hostname", i);\r
 538                         host.port       = conf.ReadInteger("database", "port", i, true);\r
 539                         host.name       = conf.ReadValue("database", "name", i);\r
 540                         host.user       = conf.ReadValue("database", "username", i);\r
 541                         host.pass       = conf.ReadValue("database", "password", i);\r
 542                         host.ssl        = conf.ReadFlag("database", "ssl", "0", i);\r
 543                         if (h == host)\r
 544                                 return true;\r
 545                 }\r
 546                 return false;\r
 547         }\r
 548 \r
 549         void ReadConf()\r
 550         {\r
 551                 ClearOldConnections();\r
 552 \r
 553                 ConfigReader conf(ServerInstance);\r
 554                 for(int i = 0; i < conf.Enumerate("database"); i++)\r
 555                 {\r
 556                         SQLhost host;\r
 557 \r
 558                         host.id         = conf.ReadValue("database", "id", i);\r
 559                         host.host       = conf.ReadValue("database", "hostname", i);\r
 560                         host.port       = conf.ReadInteger("database", "port", i, true);\r
 561                         host.name       = conf.ReadValue("database", "name", i);\r
 562                         host.user       = conf.ReadValue("database", "username", i);\r
 563                         host.pass       = conf.ReadValue("database", "password", i);\r
 564                         host.ssl        = conf.ReadFlag("database", "ssl", "0", i);\r
 565 \r
 566                         if (HasHost(host))\r
 567                                 continue;\r
 568 \r
 569                         this->AddConn(host);\r
 570                 }\r
 571         }\r
 572 \r
 573         void AddConn(const SQLhost& hi)\r
 574         {\r
 575                 if (HasHost(hi))\r
 576                 {\r
 577                         ServerInstance->Log(DEFAULT, "WARNING: A sqlite connection with id: %s already exists. Aborting database open attempt.", hi.id.c_str());\r
 578                         return;\r
 579                 }\r
 580 \r
 581                 SQLConn* newconn;\r
 582 \r
 583                 newconn = new SQLConn(ServerInstance, this, hi);\r
 584 \r
 585                 connections.insert(std::make_pair(hi.id, newconn));\r
 586         }\r
 587 \r
 588         void ClearOldConnections()\r
 589         {\r
 590                 ConnMap::iterator iter,safei;\r
 591                 for (iter = connections.begin(); iter != connections.end(); iter++)\r
 592                 {\r
 593                         if (!HostInConf(iter->second->GetConfHost()))\r
 594                         {\r
 595                                 DELETE(iter->second);\r
 596                                 safei = iter;\r
 597                                 --iter;\r
 598                                 connections.erase(safei);\r
 599                         }\r
 600                 }\r
 601         }\r
 602 \r
 603         void ClearAllConnections()\r
 604         {\r
 605                 ConnMap::iterator i;\r
 606                 while ((i = connections.begin()) != connections.end())\r
 607                 {\r
 608                         connections.erase(i);\r
 609                         DELETE(i->second);\r
 610                 }\r
 611         }\r
 612 \r
 613         virtual void OnRehash(userrec* user, const std::string &parameter)\r
 614         {\r
 615                 ReadConf();\r
 616         }\r
 617 \r
 618         virtual char* OnRequest(Request* request)\r
 619         {\r
 620                 if(strcmp(SQLREQID, request->GetId()) == 0)\r
 621                 {\r
 622                         SQLrequest* req = (SQLrequest*)request;\r
 623                         ConnMap::iterator iter;\r
 624                         if((iter = connections.find(req->dbid)) != connections.end())\r
 625                         {\r
 626                                 req->id = NewID();\r
 627                                 req->error = iter->second->Query(*req);\r
 628                                 return SQLSUCCESS;\r
 629                         }\r
 630                         else\r
 631                         {\r
 632                                 req->error.Id(BAD_DBID);\r
 633                                 return NULL;\r
 634                         }\r
 635                 }\r
 636                 return NULL;\r
 637         }\r
 638 \r
 639         unsigned long NewID()\r
 640         {\r
 641                 if (currid+1 == 0)\r
 642                         currid++;\r
 643 \r
 644                 return ++currid;\r
 645         }\r
 646 \r
 647         virtual Version GetVersion()\r
 648         {\r
 649                 return Version(1,1,0,0,VF_VENDOR|VF_SERVICEPROVIDER,API_VERSION);\r
 650         }\r
 651 \r
 652 };\r
 653 \r
 654 void ResultNotifier::Dispatch()\r
 655 {\r
 656         ((ModuleSQLite3*)mod)->SendQueue();\r
 657 }\r
 658 \r
 659 class ModuleSQLite3Factory : public ModuleFactory\r
 660 {\r
 661   public:\r
 662         ModuleSQLite3Factory()\r
 663         {\r
 664         }\r
 665 \r
 666         ~ModuleSQLite3Factory()\r
 667         {\r
 668         }\r
 669 \r
 670         virtual Module * CreateModule(InspIRCd* Me)\r
 671         {\r
 672                 return new ModuleSQLite3(Me);\r
 673         }\r
 674 };\r
 675 \r
 676 extern "C" void * init_module( void )\r
 677 {\r
 678         return new ModuleSQLite3Factory;\r
 679 }\r