src/modules/extra/m_mssql.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2008 InspIRCd Development Team
   6  * See: http://www.inspircd.org/wiki/index.php/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 <tds.h>
  16 #include <tdsconvert.h>
  17 #include "users.h"
  18 #include "channels.h"
  19 #include "modules.h"
  20
  21 #include "m_sqlv2.h"
  22
  23 /* $ModDesc: MsSQL provider */
  24 /* $LinkerFlags: -ltds */
  25 /* $ModDep: m_sqlv2.h */
  26
  27 class SQLConn;
  28 class MsSQLResult;
  29 class ResultNotifier;
  30
  31 typedef std::map<std::string, SQLConn*> ConnMap;
  32 typedef std::deque<classbase*> paramlist;
  33 typedef std::deque<MsSQLResult*> ResultQueue;
  34
  35 ResultNotifier* resultnotify = NULL;
  36
  37
  38 class ResultNotifier : public BufferedSocket
  39 {
  40         Module* mod;
  41         insp_sockaddr sock_us;
  42         socklen_t uslen;
  43
  44  public:
  45         /* Create a socket on a random port. Let the tcp stack allocate us an available port */
  46 #ifdef IPV6
  47         ResultNotifier(InspIRCd* SI, Module* m) : BufferedSocket(SI, "::1", 0, true, 3000), mod(m)
  48 #else
  49         ResultNotifier(InspIRCd* SI, Module* m) : BufferedSocket(SI, "127.0.0.1", 0, true, 3000), mod(m)
  50 #endif
  51         {
  52                 uslen = sizeof(sock_us);
  53                 if (getsockname(this->fd,(sockaddr*)&sock_us,&uslen))
  54                 {
  55                         throw ModuleException("Could not create random listening port on localhost");
  56                 }
  57         }
  58
  59         ResultNotifier(InspIRCd* SI, Module* m, int newfd, char* ip) : BufferedSocket(SI, newfd, ip), mod(m)
  60         {
  61         }
  62
  63         /* Using getsockname and ntohs, we can determine which port number we were allocated */
  64         int GetPort()
  65         {
  66 #ifdef IPV6
  67                 return ntohs(sock_us.sin6_port);
  68 #else
  69                 return ntohs(sock_us.sin_port);
  70 #endif
  71         }
  72
  73         virtual int OnIncomingConnection(int newsock, char* ip)
  74         {
  75                 Dispatch();
  76                 return false;
  77         }
  78
  79         void Dispatch();
  80 };
  81
  82
  83 class MsSQLResult : public SQLresult
  84 {
  85   private:
  86         int currentrow;
  87         int rows;
  88         int cols;
  89
  90         std::vector<std::string> colnames;
  91         std::vector<SQLfieldList> fieldlists;
  92         SQLfieldList emptyfieldlist;
  93
  94         SQLfieldList* fieldlist;
  95         SQLfieldMap* fieldmap;
  96
  97   public:
  98         MsSQLResult(Module* self, Module* to, unsigned int rid)
  99         : SQLresult(self, to, rid), currentrow(0), rows(0), cols(0), fieldlist(NULL), fieldmap(NULL)
 100         {
 101         }
 102
 103         ~MsSQLResult()
 104         {
 105         }
 106
 107         void AddRow(int colsnum, char **dat, char **colname)
 108         {
 109                 colnames.clear();
 110                 cols = colsnum;
 111                 for (int i = 0; i < colsnum; i++)
 112                 {
 113                         fieldlists.resize(fieldlists.size()+1);
 114                         colnames.push_back(colname[i]);
 115                         SQLfield sf(dat[i] ? dat[i] : "", dat[i] ? false : true);
 116                         fieldlists[rows].push_back(sf);
 117                 }
 118                 rows++;
 119         }
 120
 121         void UpdateAffectedCount()
 122         {
 123                 rows++;
 124         }
 125
 126         virtual int Rows()
 127         {
 128                 return rows;
 129         }
 130
 131         virtual int Cols()
 132         {
 133                 return cols;
 134         }
 135
 136         virtual std::string ColName(int column)
 137         {
 138                 if (column < (int)colnames.size())
 139                 {
 140                         return colnames[column];
 141                 }
 142                 else
 143                 {
 144                         throw SQLbadColName();
 145                 }
 146                 return "";
 147         }
 148
 149         virtual int ColNum(const std::string &column)
 150         {
 151                 for (unsigned int i = 0; i < colnames.size(); i++)
 152                 {
 153                         if (column == colnames[i])
 154                                 return i;
 155                 }
 156                 throw SQLbadColName();
 157                 return 0;
 158         }
 159
 160         virtual SQLfield GetValue(int row, int column)
 161         {
 162                 if ((row >= 0) && (row < rows) && (column >= 0) && (column < Cols()))
 163                 {
 164                         return fieldlists[row][column];
 165                 }
 166
 167                 throw SQLbadColName();
 168
 169                 /* XXX: We never actually get here because of the throw */
 170                 return SQLfield("",true);
 171         }
 172
 173         virtual SQLfieldList& GetRow()
 174         {
 175                 if (currentrow < rows)
 176                         return fieldlists[currentrow];
 177                 else
 178                         return emptyfieldlist;
 179         }
 180
 181         virtual SQLfieldMap& GetRowMap()
 182         {
 183                 /* In an effort to reduce overhead we don't actually allocate the map
 184                  * until the first time it's needed...so...
 185                  */
 186                 if(fieldmap)
 187                 {
 188                         fieldmap->clear();
 189                 }
 190                 else
 191                 {
 192                         fieldmap = new SQLfieldMap;
 193                 }
 194
 195                 if (currentrow < rows)
 196                 {
 197                         for (int i = 0; i < Cols(); i++)
 198                         {
 199                                 fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i)));
 200                         }
 201                         currentrow++;
 202                 }
 203
 204                 return *fieldmap;
 205         }
 206
 207         virtual SQLfieldList* GetRowPtr()
 208         {
 209                 fieldlist = new SQLfieldList();
 210
 211                 if (currentrow < rows)
 212                 {
 213                         for (int i = 0; i < Rows(); i++)
 214                         {
 215                                 fieldlist->push_back(fieldlists[currentrow][i]);
 216                         }
 217                         currentrow++;
 218                 }
 219                 return fieldlist;
 220         }
 221
 222         virtual SQLfieldMap* GetRowMapPtr()
 223         {
 224                 fieldmap = new SQLfieldMap();
 225
 226                 if (currentrow < rows)
 227                 {
 228                         for (int i = 0; i < Cols(); i++)
 229                         {
 230                                 fieldmap->insert(std::make_pair(colnames[i],GetValue(currentrow, i)));
 231                         }
 232                         currentrow++;
 233                 }
 234
 235                 return fieldmap;
 236         }
 237
 238         virtual void Free(SQLfieldMap* fm)
 239         {
 240                 delete fm;
 241         }
 242
 243         virtual void Free(SQLfieldList* fl)
 244         {
 245                 delete fl;
 246         }
 247
 248
 249 };
 250
 251 class SQLConn : public classbase
 252 {
 253   private:
 254         ResultQueue results;
 255         InspIRCd* Instance;
 256         Module* mod;
 257         SQLhost host;
 258         TDSLOGIN* login;
 259         TDSSOCKET* sock;
 260         TDSCONNECTION* conn;
 261
 262   public:
 263         SQLConn(InspIRCd* SI, Module* m, const SQLhost& hi)
 264         : Instance(SI), mod(m), host(hi)
 265         {
 266                 if (OpenDB() == TDS_SUCCEED)
 267                 {
 268                         std::string query("USE " + host.name);
 269                         if (tds_submit_query(sock, query.c_str()) == TDS_SUCCEED)
 270                         {
 271                                 if (tds_process_simple_query(sock) != TDS_SUCCEED)
 272                                 {
 273                                         Instance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
 274                                         CloseDB();
 275                                 }
 276                         }
 277                         else
 278                         {
 279                                 Instance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not select database " + host.name + " for DB with id: " + host.id);
 280                                 CloseDB();
 281                         }
 282                 }
 283                 else
 284                 {
 285                         Instance->Logs->Log("m_mssql",DEFAULT, "WARNING: Could not connect to DB with id: " + host.id);
 286                         CloseDB();
 287                 }
 288         }
 289
 290         ~SQLConn()
 291         {
 292                 CloseDB();
 293         }
 294
 295         SQLerror Query(SQLrequest &req)
 296         {
 297                 if (!sock)
 298                         return SQLerror(BAD_CONN, "Socket was NULL, check if SQL server is running.");
 299
 300                 /* Pointer to the buffer we screw around with substitution in */
 301                 char* query;
 302
 303                 /* Pointer to the current end of query, where we append new stuff */
 304                 char* queryend;
 305
 306                 /* Total length of the unescaped parameters */
 307                 unsigned long paramlen;
 308
 309                 /* Total length of query, used for binary-safety in mysql_real_query */
 310                 unsigned long querylength = 0;
 311
 312                 paramlen = 0;
 313                 for(ParamL::iterator i = req.query.p.begin(); i != req.query.p.end(); i++)
 314                 {
 315                         paramlen += i->size();
 316                 }
 317
 318                 /* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be.
 319                  * sizeofquery + (totalparamlength*2) + 1
 320                  *
 321                  * The +1 is for null-terminating the string
 322                  */
 323                 query = new char[req.query.q.length() + (paramlen*2) + 1];
 324                 queryend = query;
 325
 326                 for(unsigned long i = 0; i < req.query.q.length(); i++)
 327                 {
 328                         if(req.query.q[i] == '?')
 329                         {
 330                                 if(req.query.p.size())
 331                                 {
 332                                         /* Custom escaping for this one. converting ' to '' should make SQL Server happy. Ugly but fast :]
 333                                          */
 334                                         char* escaped = new char[(req.query.p.front().length() * 2) + 1];
 335                                         char* escend = escaped;
 336                                         for (std::string::iterator p = req.query.p.front().begin(); p < req.query.p.front().end(); p++)
 337                                         {
 338                                                 if (*p == '\'')
 339                                                 {
 340                                                         *escend = *p;
 341                                                         escend++;
 342                                                         *escend = *p;
 343                                                 }
 344                                                 *escend = *p;
 345                                                 escend++;
 346                                         }
 347                                         *escend = 0;
 348
 349                                         for (char* n = escaped; *n; n++)
 350                                         {
 351                                                 *queryend = *n;
 352                                                 queryend++;
 353                                         }
 354                                         delete[] escaped;
 355                                         req.query.p.pop_front();
 356                                 }
 357                                 else
 358                                         break;
 359                         }
 360                         else
 361                         {
 362                                 *queryend = req.query.q[i];
 363                                 queryend++;
 364                         }
 365                         querylength++;
 366                 }
 367                 *queryend = 0;
 368                 req.query.q = query;
 369
 370                 MsSQLResult* res = new MsSQLResult(mod, req.GetSource(), req.id);
 371                 res->dbid = host.id;
 372                 res->query = req.query.q;
 373
 374                 char* msquery = strdup(req.query.q.data());
 375                 Instance->Logs->Log("m_mssql",DEBUG,"doing Query: %s",msquery);
 376                 if (tds_submit_query(sock, msquery) != TDS_SUCCEED)
 377                 {
 378                         std::string error("failed to execute: "+std::string(req.query.q.data()));
 379                         delete[] query;
 380                         delete res;
 381                         free(msquery);
 382                         return SQLerror(QSEND_FAIL, error);
 383                 }
 384                 delete[] query;
 385                 free(msquery);
 386
 387                 int tds_res;
 388                 while (tds_process_tokens(sock, &tds_res, NULL, TDS_TOKEN_RESULTS) == TDS_SUCCEED)
 389                 {
 390                         //Instance->Logs->Log("m_mssql",DEBUG,"<******> result type: %d", tds_res);
 391                         //Instance->Logs->Log("m_mssql",DEBUG,"AFFECTED ROWS: %d", sock->rows_affected);
 392                         switch (tds_res)
 393                         {
 394                                 case TDS_ROWFMT_RESULT:
 395                                         break;
 396
 397                                 case TDS_DONE_RESULT:
 398                                         if (sock->rows_affected > -1)
 399                                         {
 400                                                 for (int c = 0; c < sock->rows_affected; c++)  res->UpdateAffectedCount();
 401                                                 continue;
 402                                         }
 403                                         break;
 404
 405                                 case TDS_ROW_RESULT:
 406                                         while (tds_process_tokens(sock, &tds_res, NULL, TDS_STOPAT_ROWFMT|TDS_RETURN_DONE|TDS_RETURN_ROW) == TDS_SUCCEED)
 407                                         {
 408                                                 if (tds_res != TDS_ROW_RESULT)
 409                                                         break;
 410
 411                                                 if (!sock->current_results)
 412                                                         continue;
 413
 414                                                 if (sock->res_info->row_count > 0)
 415                                                 {
 416                                                         int cols = sock->res_info->num_cols;
 417                                                         char** name = new char*[MAXBUF];
 418                                                         char** data = new char*[MAXBUF];
 419                                                         for (int j=0; j<cols; j++)
 420                                                         {
 421                                                                 TDSCOLUMN* col = sock->current_results->columns[j];
 422                                                                 name[j] = col->column_name;
 423
 424                                                                 int ctype;
 425                                                                 int srclen;
 426                                                                 unsigned char* src;
 427                                                                 CONV_RESULT dres;
 428                                                                 ctype = tds_get_conversion_type(col->column_type, col->column_size);
 429                                                                 src = &(sock->current_results->current_row[col->column_offset]);
 430                                                                 srclen = col->column_cur_size;
 431                                                                 tds_convert(sock->tds_ctx, ctype, (TDS_CHAR *) src, srclen, SYBCHAR, &dres);
 432                                                                 data[j] = (char*)dres.ib;
 433                                                         }
 434                                                         ResultReady(res, cols, data, name);
 435                                                 }
 436                                         }
 437                                         break;
 438
 439                                 default:
 440                                         break;
 441                         }
 442                 }
 443                 results.push_back(res);
 444                 SendNotify();
 445                 return SQLerror();
 446         }
 447
 448         static int HandleMessage(const TDSCONTEXT * pContext, TDSSOCKET * pTdsSocket, TDSMESSAGE * pMessage)
 449         {
 450                 SQLConn* sc = (SQLConn*)pContext->parent;
 451                 sc->Instance->Logs->Log("m_mssql", DEBUG, "Message for DB with id: %s -> %s", sc->host.id.c_str(), pMessage->message);
 452                 return 0;
 453         }
 454
 455         static int HandleError(const TDSCONTEXT * pContext, TDSSOCKET * pTdsSocket, TDSMESSAGE * pMessage)
 456         {
 457                 SQLConn* sc = (SQLConn*)pContext->parent;
 458                 sc->Instance->Logs->Log("m_mssql", DEFAULT, "Error for DB with id: %s -> %s", sc->host.id.c_str(), pMessage->message);
 459                 return 0;
 460         }
 461
 462         void ResultReady(MsSQLResult *res, int cols, char **data, char **colnames)
 463         {
 464                 res->AddRow(cols, data, colnames);
 465         }
 466
 467         void AffectedReady(MsSQLResult *res)
 468         {
 469                 res->UpdateAffectedCount();
 470         }
 471
 472         int OpenDB()
 473         {
 474                 CloseDB();
 475
 476                 TDSCONTEXT* cont;
 477                 cont = tds_alloc_context(this);
 478                 cont->msg_handler = HandleMessage;
 479                 cont->err_handler = HandleError;
 480
 481                 login = tds_alloc_login();
 482                 tds_set_library(login,"TDS-Library");
 483                 tds_set_host(login, "");
 484                 tds_set_server(login, host.host.c_str());
 485                 tds_set_server_addr(login, host.host.c_str());
 486                 tds_set_user(login, host.user.c_str());
 487                 tds_set_passwd(login, host.pass.c_str());
 488                 tds_set_port(login, host.port);
 489                 tds_set_packet(login, 512);
 490
 491                 sock = tds_alloc_socket(cont, 512);
 492                 conn = tds_read_config_info(NULL, login, cont->locale);
 493                 return tds_connect(sock, conn);
 494         }
 495
 496         void CloseDB()
 497         {
 498                 if (login)
 499                         tds_free_login(login);
 500                 if (sock)
 501                         tds_free_socket(sock);
 502                 if (conn)
 503                         tds_free_connection(conn);
 504                 login = NULL;
 505                 sock = NULL;
 506                 conn = NULL;
 507         }
 508
 509         SQLhost GetConfHost()
 510         {
 511                 return host;
 512         }
 513
 514         void SendResults()
 515         {
 516                 while (results.size())
 517                 {
 518                         MsSQLResult* res = results[0];
 519                         if (res->GetDest())
 520                         {
 521                                 res->Send();
 522                         }
 523                         else
 524                         {
 525                                 /* If the client module is unloaded partway through a query then the provider will set
 526                                  * the pointer to NULL. We cannot just cancel the query as the result will still come
 527                                  * through at some point...and it could get messy if we play with invalid pointers...
 528                                  */
 529                                 delete res;
 530                         }
 531                         results.pop_front();
 532                 }
 533         }
 534
 535         void ClearResults()
 536         {
 537                 while (results.size())
 538                 {
 539                         MsSQLResult* res = results[0];
 540                         delete res;
 541                         results.pop_front();
 542                 }
 543         }
 544
 545         void SendNotify()
 546         {
 547                 int QueueFD;
 548                 if ((QueueFD = socket(AF_FAMILY, SOCK_STREAM, 0)) == -1)
 549                 {
 550                         /* crap, we're out of sockets... */
 551                         return;
 552                 }
 553
 554                 insp_sockaddr addr;
 555
 556 #ifdef IPV6
 557                 insp_aton("::1", &addr.sin6_addr);
 558                 addr.sin6_family = AF_FAMILY;
 559                 addr.sin6_port = htons(resultnotify->GetPort());
 560 #else
 561                 insp_inaddr ia;
 562                 insp_aton("127.0.0.1", &ia);
 563                 addr.sin_family = AF_FAMILY;
 564                 addr.sin_addr = ia;
 565                 addr.sin_port = htons(resultnotify->GetPort());
 566 #endif
 567
 568                 if (connect(QueueFD, (sockaddr*)&addr,sizeof(addr)) == -1)
 569                 {
 570                         /* wtf, we cant connect to it, but we just created it! */
 571                         return;
 572                 }
 573         }
 574
 575 };
 576
 577
 578 class ModuleMsSQL : public Module
 579 {
 580   private:
 581         ConnMap connections;
 582         unsigned long currid;
 583
 584   public:
 585         ModuleMsSQL(InspIRCd* Me)
 586         : Module::Module(Me), currid(0)
 587         {
 588                 ServerInstance->Modules->UseInterface("SQLutils");
 589
 590                 if (!ServerInstance->Modules->PublishFeature("SQL", this))
 591                 {
 592                         throw ModuleException("m_mssql: Unable to publish feature 'SQL'");
 593                 }
 594
 595                 resultnotify = new ResultNotifier(ServerInstance, this);
 596
 597                 ReadConf();
 598
 599                 ServerInstance->Modules->PublishInterface("SQL", this);
 600                 Implementation eventlist[] = { I_OnRequest, I_OnRehash };
 601                 ServerInstance->Modules->Attach(eventlist, this, 2);
 602         }
 603
 604         virtual ~ModuleMsSQL()
 605         {
 606                 ClearQueue();
 607                 ClearAllConnections();
 608                 resultnotify->SetFd(-1);
 609                 resultnotify->state = I_ERROR;
 610                 resultnotify->OnError(I_ERR_SOCKET);
 611                 resultnotify->ClosePending = true;
 612                 delete resultnotify;
 613                 ServerInstance->Modules->UnpublishInterface("SQL", this);
 614                 ServerInstance->Modules->UnpublishFeature("SQL");
 615                 ServerInstance->Modules->DoneWithInterface("SQLutils");
 616         }
 617
 618
 619         void SendQueue()
 620         {
 621                 for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
 622                 {
 623                         iter->second->SendResults();
 624                 }
 625         }
 626
 627         void ClearQueue()
 628         {
 629                 for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
 630                 {
 631                         iter->second->ClearResults();
 632                 }
 633         }
 634
 635         bool HasHost(const SQLhost &host)
 636         {
 637                 for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
 638                 {
 639                         if (host == iter->second->GetConfHost())
 640                                 return true;
 641                 }
 642                 return false;
 643         }
 644
 645         bool HostInConf(const SQLhost &h)
 646         {
 647                 ConfigReader conf(ServerInstance);
 648                 for(int i = 0; i < conf.Enumerate("database"); i++)
 649                 {
 650                         SQLhost host;
 651                         host.id         = conf.ReadValue("database", "id", i);
 652                         host.host       = conf.ReadValue("database", "hostname", i);
 653                         host.port       = conf.ReadInteger("database", "port", "1433", i, true);
 654                         host.name       = conf.ReadValue("database", "name", i);
 655                         host.user       = conf.ReadValue("database", "username", i);
 656                         host.pass       = conf.ReadValue("database", "password", i);
 657                         if (h == host)
 658                                 return true;
 659                 }
 660                 return false;
 661         }
 662
 663         void ReadConf()
 664         {
 665                 ClearOldConnections();
 666
 667                 ConfigReader conf(ServerInstance);
 668                 for(int i = 0; i < conf.Enumerate("database"); i++)
 669                 {
 670                         SQLhost host;
 671
 672                         host.id         = conf.ReadValue("database", "id", i);
 673                         host.host       = conf.ReadValue("database", "hostname", i);
 674                         host.port       = conf.ReadInteger("database", "port", "1433", i, true);
 675                         host.name       = conf.ReadValue("database", "name", i);
 676                         host.user       = conf.ReadValue("database", "username", i);
 677                         host.pass       = conf.ReadValue("database", "password", i);
 678
 679                         if (HasHost(host))
 680                                 continue;
 681
 682                         this->AddConn(host);
 683                 }
 684         }
 685
 686         void AddConn(const SQLhost& hi)
 687         {
 688                 if (HasHost(hi))
 689                 {
 690                         ServerInstance->Logs->Log("m_mssql",DEFAULT, "WARNING: A MsSQL connection with id: %s already exists. Aborting database open attempt.", hi.id.c_str());
 691                         return;
 692                 }
 693
 694                 SQLConn* newconn;
 695
 696                 newconn = new SQLConn(ServerInstance, this, hi);
 697
 698                 connections.insert(std::make_pair(hi.id, newconn));
 699         }
 700
 701         void ClearOldConnections()
 702         {
 703                 ConnMap::iterator iter,safei;
 704                 for (iter = connections.begin(); iter != connections.end(); iter++)
 705                 {
 706                         if (!HostInConf(iter->second->GetConfHost()))
 707                         {
 708                                 delete iter->second;
 709                                 safei = iter;
 710                                 --iter;
 711                                 connections.erase(safei);
 712                         }
 713                 }
 714         }
 715
 716         void ClearAllConnections()
 717         {
 718                 ConnMap::iterator i;
 719                 while ((i = connections.begin()) != connections.end())
 720                 {
 721                         connections.erase(i);
 722                         delete i->second;
 723                 }
 724         }
 725
 726         virtual void OnRehash(User* user, const std::string &parameter)
 727         {
 728                 ReadConf();
 729         }
 730
 731         virtual const char* OnRequest(Request* request)
 732         {
 733                 if(strcmp(SQLREQID, request->GetId()) == 0)
 734                 {
 735                         SQLrequest* req = (SQLrequest*)request;
 736                         ConnMap::iterator iter;
 737                         if((iter = connections.find(req->dbid)) != connections.end())
 738                         {
 739                                 req->id = NewID();
 740                                 req->error = iter->second->Query(*req);
 741                                 return SQLSUCCESS;
 742                         }
 743                         else
 744                         {
 745                                 req->error.Id(BAD_DBID);
 746                                 return NULL;
 747                         }
 748                 }
 749                 return NULL;
 750         }
 751
 752         unsigned long NewID()
 753         {
 754                 if (currid+1 == 0)
 755                         currid++;
 756
 757                 return ++currid;
 758         }
 759
 760         virtual Version GetVersion()
 761         {
 762                 return Version(1,0,0,0,VF_VENDOR|VF_SERVICEPROVIDER,API_VERSION);
 763         }
 764
 765 };
 766
 767 void ResultNotifier::Dispatch()
 768 {
 769         ((ModuleMsSQL*)mod)->SendQueue();
 770 }
 771
 772 MODULE_INIT(ModuleMsSQL)