src/modules/extra/m_pgsql.cpp

   1 /*       +------------------------------------+
   2  *       | Inspire Internet Relay Chat Daemon |
   3  *       +------------------------------------+
   4  *
   5  *  InspIRCd: (C) 2002-2007 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 <cstdlib>
  15 #include <sstream>
  16 #include <string>
  17 #include <deque>
  18 #include <map>
  19 #include <libpq-fe.h>
  20
  21 #include "users.h"
  22 #include "channels.h"
  23 #include "modules.h"
  24
  25 #include "inspircd.h"
  26 #include "configreader.h"
  27
  28 #include "m_sqlv2.h"
  29
  30 /* $ModDesc: PostgreSQL Service Provider module for all other m_sql* modules, uses v2 of the SQL API */
  31 /* $CompileFlags: -I`pg_config --includedir` `perl extra/pgsql_config.pl` */
  32 /* $LinkerFlags: -L`pg_config --libdir` -lpq */
  33 /* $ModDep: m_sqlv2.h */
  34
  35 /* UGH, UGH, UGH, UGH, UGH, UGH
  36  * I'm having trouble seeing how I
  37  * can avoid this. The core-defined
  38  * constructors for InspSocket just
  39  * aren't suitable...and if I'm
  40  * reimplementing them I need this so
  41  * I can access the socket engine :\
  42  */
  43
  44 /* Forward declare, so we can have the typedef neatly at the top */
  45 class SQLConn;
  46
  47 typedef std::map<std::string, SQLConn*> ConnMap;
  48
  49 /* CREAD,       Connecting and wants read event
  50  * CWRITE,      Connecting and wants write event
  51  * WREAD,       Connected/Working and wants read event
  52  * WWRITE,      Connected/Working and wants write event
  53  * RREAD,       Resetting and wants read event
  54  * RWRITE,      Resetting and wants write event
  55  */
  56 enum SQLstatus { CREAD, CWRITE, WREAD, WWRITE, RREAD, RWRITE };
  57
  58 /** SQLhost, simple structure to store information about a SQL-connection-to-be
  59  * We use this struct simply to make it neater passing around host information
  60  * when we're creating connections and resolving hosts.
  61  * Rather than giving SQLresolver a parameter for every field here so it can in
  62  * turn call SQLConn's constructor with them all, both can simply use a SQLhost.
  63  */
  64 class SQLhost
  65 {
  66  public:
  67         std::string     id;     /* Database handle id */
  68         std::string     host;   /* Database server hostname */
  69         unsigned int    port;   /* Database server port */
  70         std::string     name;   /* Database name */
  71         std::string     user;   /* Database username */
  72         std::string     pass;   /* Database password */
  73         bool            ssl;    /* If we should require SSL */
  74
  75         SQLhost()
  76         {
  77         }
  78
  79         SQLhost(const std::string& i, const std::string& h, unsigned int p, const std::string& n, const std::string& u, const std::string& pa, bool s)
  80         : id(i), host(h), port(p), name(n), user(u), pass(pa), ssl(s)
  81         {
  82         }
  83 };
  84
  85 bool operator== (const SQLhost& l, const SQLhost& r)
  86 {
  87         return (l.id == r.id && l.host == r.host && l.port == r.port && l.name == r.name && l.user == l.user && l.pass == r.pass && l.ssl == r.ssl);
  88 }
  89
  90 /** Used to resolve sql server hostnames
  91  */
  92 class SQLresolver : public Resolver
  93 {
  94  private:
  95         SQLhost host;
  96         SQLhost confhost;
  97         Module* mod;
  98  public:
  99         SQLresolver(Module* m, InspIRCd* Instance, const SQLhost& hi, const SQLhost& ci)
 100         : Resolver(Instance, hi.host, DNS_QUERY_FORWARD, (Module*)m), host(hi), confhost(ci), mod(m)
 101         {
 102         }
 103
 104         virtual void OnLookupComplete(const std::string &result);
 105
 106         virtual void OnError(ResolverError e, const std::string &errormessage)
 107         {
 108                 ServerInstance->Log(DEBUG, "DNS lookup failed (%s), dying horribly", errormessage.c_str());
 109         }
 110 };
 111
 112 /** QueryQueue, a queue of queries waiting to be executed.
 113  * This maintains two queues internally, one for 'priority'
 114  * queries and one for less important ones. Each queue has
 115  * new queries appended to it and ones to execute are popped
 116  * off the front. This keeps them flowing round nicely and no
 117  * query should ever get 'stuck' for too long. If there are
 118  * queries in the priority queue they will be executed first,
 119  * 'unimportant' queries will only be executed when the
 120  * priority queue is empty.
 121  *
 122  * We store lists of SQLrequest's here, by value as we want to avoid storing
 123  * any data allocated inside the client module (in case that module is unloaded
 124  * while the query is in progress).
 125  *
 126  * Because we want to work on the current SQLrequest in-situ, we need a way
 127  * of accessing the request we are currently processing, QueryQueue::front(),
 128  * but that call needs to always return the same request until that request
 129  * is removed from the queue, this is what the 'which' variable is. New queries are
 130  * always added to the back of one of the two queues, but if when front()
 131  * is first called then the priority queue is empty then front() will return
 132  * a query from the normal queue, but if a query is then added to the priority
 133  * queue then front() must continue to return the front of the *normal* queue
 134  * until pop() is called.
 135  */
 136
 137 class QueryQueue : public classbase
 138 {
 139 private:
 140         typedef std::deque<SQLrequest> ReqDeque;
 141
 142         ReqDeque priority;      /* The priority queue */
 143         ReqDeque normal;        /* The 'normal' queue */
 144         enum { PRI, NOR, NON } which;   /* Which queue the currently active element is at the front of */
 145
 146 public:
 147         QueryQueue()
 148         : which(NON)
 149         {
 150         }
 151
 152         void push(const SQLrequest &q)
 153         {
 154                 //ServerInstance->Log(DEBUG, "QueryQueue::push(): Adding %s query to queue: %s", ((q.pri) ? "priority" : "non-priority"), q.query.q.c_str());
 155
 156                 if(q.pri)
 157                         priority.push_back(q);
 158                 else
 159                         normal.push_back(q);
 160         }
 161
 162         void pop()
 163         {
 164                 if((which == PRI) && priority.size())
 165                 {
 166                         priority.pop_front();
 167                 }
 168                 else if((which == NOR) && normal.size())
 169                 {
 170                         normal.pop_front();
 171                 }
 172
 173                 /* Reset this */
 174                 which = NON;
 175
 176                 /* Silently do nothing if there was no element to pop() */
 177         }
 178
 179         SQLrequest& front()
 180         {
 181                 switch(which)
 182                 {
 183                         case PRI:
 184                                 return priority.front();
 185                         case NOR:
 186                                 return normal.front();
 187                         default:
 188                                 if(priority.size())
 189                                 {
 190                                         which = PRI;
 191                                         return priority.front();
 192                                 }
 193
 194                                 if(normal.size())
 195                                 {
 196                                         which = NOR;
 197                                         return normal.front();
 198                                 }
 199
 200                                 /* This will probably result in a segfault,
 201                                  * but the caller should have checked totalsize()
 202                                  * first so..meh - moron :p
 203                                  */
 204
 205                                 return priority.front();
 206                 }
 207         }
 208
 209         std::pair<int, int> size()
 210         {
 211                 return std::make_pair(priority.size(), normal.size());
 212         }
 213
 214         int totalsize()
 215         {
 216                 return priority.size() + normal.size();
 217         }
 218
 219         void PurgeModule(Module* mod)
 220         {
 221                 DoPurgeModule(mod, priority);
 222                 DoPurgeModule(mod, normal);
 223         }
 224
 225 private:
 226         void DoPurgeModule(Module* mod, ReqDeque& q)
 227         {
 228                 for(ReqDeque::iterator iter = q.begin(); iter != q.end(); iter++)
 229                 {
 230                         if(iter->GetSource() == mod)
 231                         {
 232                                 if(iter->id == front().id)
 233                                 {
 234                                         /* It's the currently active query.. :x */
 235                                         iter->SetSource(NULL);
 236                                 }
 237                                 else
 238                                 {
 239                                         /* It hasn't been executed yet..just remove it */
 240                                         iter = q.erase(iter);
 241                                 }
 242                         }
 243                 }
 244         }
 245 };
 246
 247 /** PgSQLresult is a subclass of the mostly-pure-virtual class SQLresult.
 248  * All SQL providers must create their own subclass and define it's methods using that
 249  * database library's data retriveal functions. The aim is to avoid a slow and inefficient process
 250  * of converting all data to a common format before it reaches the result structure. This way
 251  * data is passes to the module nearly as directly as if it was using the API directly itself.
 252  */
 253
 254 class PgSQLresult : public SQLresult
 255 {
 256         PGresult* res;
 257         int currentrow;
 258         int rows;
 259         int cols;
 260
 261         SQLfieldList* fieldlist;
 262         SQLfieldMap* fieldmap;
 263 public:
 264         PgSQLresult(Module* self, Module* to, unsigned long id, PGresult* result)
 265         : SQLresult(self, to, id), res(result), currentrow(0), fieldlist(NULL), fieldmap(NULL)
 266         {
 267                 rows = PQntuples(res);
 268                 cols = PQnfields(res);
 269
 270                 //ServerInstance->Log(DEBUG, "Created new PgSQL result; %d rows, %d columns, %s affected", rows, cols, PQcmdTuples(res));
 271         }
 272
 273         ~PgSQLresult()
 274         {
 275                 /* If we allocated these, free them... */
 276                 if(fieldlist)
 277                         DELETE(fieldlist);
 278
 279                 if(fieldmap)
 280                         DELETE(fieldmap);
 281
 282                 PQclear(res);
 283         }
 284
 285         virtual int Rows()
 286         {
 287                 if(!cols && !rows)
 288                 {
 289                         return atoi(PQcmdTuples(res));
 290                 }
 291                 else
 292                 {
 293                         return rows;
 294                 }
 295         }
 296
 297         virtual int Cols()
 298         {
 299                 return PQnfields(res);
 300         }
 301
 302         virtual std::string ColName(int column)
 303         {
 304                 char* name = PQfname(res, column);
 305
 306                 return (name) ? name : "";
 307         }
 308
 309         virtual int ColNum(const std::string &column)
 310         {
 311                 int n = PQfnumber(res, column.c_str());
 312
 313                 if(n == -1)
 314                 {
 315                         throw SQLbadColName();
 316                 }
 317                 else
 318                 {
 319                         return n;
 320                 }
 321         }
 322
 323         virtual SQLfield GetValue(int row, int column)
 324         {
 325                 char* v = PQgetvalue(res, row, column);
 326
 327                 if(v)
 328                 {
 329                         return SQLfield(std::string(v, PQgetlength(res, row, column)), PQgetisnull(res, row, column));
 330                 }
 331                 else
 332                 {
 333                         //ServerInstance->Log(DEBUG, "PQgetvalue returned a null pointer..nobody wants to tell us what this means");
 334                         throw SQLbadColName();
 335                 }
 336         }
 337
 338         virtual SQLfieldList& GetRow()
 339         {
 340                 /* In an effort to reduce overhead we don't actually allocate the list
 341                  * until the first time it's needed...so...
 342                  */
 343                 if(fieldlist)
 344                 {
 345                         fieldlist->clear();
 346                 }
 347                 else
 348                 {
 349                         fieldlist = new SQLfieldList;
 350                 }
 351
 352                 if(currentrow < PQntuples(res))
 353                 {
 354                         int cols = PQnfields(res);
 355
 356                         for(int i = 0; i < cols; i++)
 357                         {
 358                                 fieldlist->push_back(GetValue(currentrow, i));
 359                         }
 360
 361                         currentrow++;
 362                 }
 363
 364                 return *fieldlist;
 365         }
 366
 367         virtual SQLfieldMap& GetRowMap()
 368         {
 369                 /* In an effort to reduce overhead we don't actually allocate the map
 370                  * until the first time it's needed...so...
 371                  */
 372                 if(fieldmap)
 373                 {
 374                         fieldmap->clear();
 375                 }
 376                 else
 377                 {
 378                         fieldmap = new SQLfieldMap;
 379                 }
 380
 381                 if(currentrow < PQntuples(res))
 382                 {
 383                         int cols = PQnfields(res);
 384
 385                         for(int i = 0; i < cols; i++)
 386                         {
 387                                 fieldmap->insert(std::make_pair(ColName(i), GetValue(currentrow, i)));
 388                         }
 389
 390                         currentrow++;
 391                 }
 392
 393                 return *fieldmap;
 394         }
 395
 396         virtual SQLfieldList* GetRowPtr()
 397         {
 398                 SQLfieldList* fl = new SQLfieldList;
 399
 400                 if(currentrow < PQntuples(res))
 401                 {
 402                         int cols = PQnfields(res);
 403
 404                         for(int i = 0; i < cols; i++)
 405                         {
 406                                 fl->push_back(GetValue(currentrow, i));
 407                         }
 408
 409                         currentrow++;
 410                 }
 411
 412                 return fl;
 413         }
 414
 415         virtual SQLfieldMap* GetRowMapPtr()
 416         {
 417                 SQLfieldMap* fm = new SQLfieldMap;
 418
 419                 if(currentrow < PQntuples(res))
 420                 {
 421                         int cols = PQnfields(res);
 422
 423                         for(int i = 0; i < cols; i++)
 424                         {
 425                                 fm->insert(std::make_pair(ColName(i), GetValue(currentrow, i)));
 426                         }
 427
 428                         currentrow++;
 429                 }
 430
 431                 return fm;
 432         }
 433
 434         virtual void Free(SQLfieldMap* fm)
 435         {
 436                 DELETE(fm);
 437         }
 438
 439         virtual void Free(SQLfieldList* fl)
 440         {
 441                 DELETE(fl);
 442         }
 443 };
 444
 445 /** SQLConn represents one SQL session.
 446  * Each session has its own persistent connection to the database.
 447  * This is a subclass of InspSocket so it can easily recieve read/write events from the core socket
 448  * engine, unlike the original MySQL module this module does not block. Ever. It gets a mild stabbing
 449  * if it dares to.
 450  */
 451
 452 class SQLConn : public InspSocket
 453 {
 454 private:
 455         Module*                 us;                     /* Pointer to the SQL provider itself */
 456         std::string     dbhost;         /* Database server hostname */
 457         unsigned int    dbport;         /* Database server port */
 458         std::string     dbname;         /* Database name */
 459         std::string     dbuser;         /* Database username */
 460         std::string     dbpass;         /* Database password */
 461         bool                    ssl;            /* If we should require SSL */
 462         PGconn*                 sql;            /* PgSQL database connection handle */
 463         SQLstatus               status;         /* PgSQL database connection status */
 464         bool                    qinprog;        /* If there is currently a query in progress */
 465         QueryQueue              queue;          /* Queue of queries waiting to be executed on this connection */
 466         time_t                  idle;           /* Time we last heard from the database */
 467         SQLhost                 confhost;       /* A copy of the config <database> entry for conf checks */
 468 public:
 469
 470         /* This class should only ever be created inside this module, using this constructor, so we don't have to worry about the default ones */
 471
 472         SQLConn(InspIRCd* SI, Module* self, const SQLhost& hostinfo, const SQLhost& confinfo);
 473
 474         ~SQLConn();
 475
 476         bool DoConnect();
 477
 478         virtual void Close();
 479
 480         bool DoPoll();
 481
 482         bool DoConnectedPoll();
 483
 484         bool DoResetPoll();
 485
 486         void ShowStatus();
 487
 488         virtual bool OnDataReady();
 489
 490         virtual bool OnWriteReady();
 491
 492         virtual bool OnConnected();
 493
 494         bool DoEvent();
 495
 496         bool Reconnect();
 497
 498         std::string MkInfoStr();
 499
 500         const char* StatusStr();
 501
 502         SQLerror DoQuery(SQLrequest &req);
 503
 504         SQLerror Query(const SQLrequest &req);
 505
 506         void OnUnloadModule(Module* mod);
 507
 508         const SQLhost GetConfHost();
 509 };
 510
 511 SQLConn::SQLConn(InspIRCd* SI, Module* self, const SQLhost& hi, const SQLhost& ci)
 512 : InspSocket::InspSocket(SI), us(self), dbhost(hi.host), dbport(hi.port), dbname(hi.name), dbuser(hi.user), dbpass(hi.pass), ssl(hi.ssl), sql(NULL), status(CWRITE), qinprog(false)
 513 {
 514         //ServerInstance->Log(DEBUG, "Creating new PgSQL connection to database %s on %s:%u (%s/%s)", dbname.c_str(), dbhost.c_str(), dbport, dbuser.c_str(), dbpass.c_str());
 515
 516         /* Some of this could be reviewed, unsure if I need to fill 'host' etc...
 517          * just copied this over from the InspSocket constructor.
 518          */
 519         confhost = ci;
 520         strlcpy(this->host, dbhost.c_str(), MAXBUF);
 521         strlcpy(this->IP, dbhost.c_str(), MAXBUF);
 522         this->port = dbport;
 523         idle = this->Instance->Time();
 524
 525         this->ClosePending = false;
 526
 527         Instance->Log(DEBUG,"No need to resolve %s", this->host);
 528
 529         if(!this->DoConnect())
 530         {
 531                 throw ModuleException("Connect failed");
 532         }
 533 }
 534
 535 SQLConn::~SQLConn()
 536 {
 537         Close();
 538 }
 539
 540 bool SQLConn::DoConnect()
 541 {
 542         //ServerInstance->Log(DEBUG, "SQLConn::DoConnect()");
 543
 544         if(!(sql = PQconnectStart(MkInfoStr().c_str())))
 545         {
 546                 Instance->Log(DEBUG, "Couldn't allocate PGconn structure, aborting: %s", PQerrorMessage(sql));
 547                 Close();
 548                 return false;
 549         }
 550
 551         if(PQstatus(sql) == CONNECTION_BAD)
 552         {
 553                 Instance->Log(DEBUG, "PQconnectStart failed: %s", PQerrorMessage(sql));
 554                 Close();
 555                 return false;
 556         }
 557
 558         ShowStatus();
 559
 560         if(PQsetnonblocking(sql, 1) == -1)
 561         {
 562                 Instance->Log(DEBUG, "Couldn't set connection nonblocking: %s", PQerrorMessage(sql));
 563                 Close();
 564                 return false;
 565         }
 566
 567         /* OK, we've initalised the connection, now to get it hooked into the socket engine
 568          * and then start polling it.
 569          */
 570
 571         //ServerInstance->Log(DEBUG, "Old DNS socket: %d", this->fd);
 572         this->fd = PQsocket(sql);
 573         Instance->Log(DEBUG, "New SQL socket: %d", this->fd);
 574
 575         if(this->fd <= -1)
 576         {
 577                 Instance->Log(DEBUG, "PQsocket says we have an invalid FD: %d", this->fd);
 578                 Close();
 579                 return false;
 580         }
 581
 582         this->state = I_CONNECTING;
 583         if (!this->Instance->SE->AddFd(this))
 584         {
 585                 Instance->Log(DEBUG, "A PQsocket cant be added to the socket engine!");
 586                 Close();
 587                 return false;
 588         }
 589
 590         /* Socket all hooked into the engine, now to tell PgSQL to start connecting */
 591
 592         return DoPoll();
 593 }
 594
 595 void SQLConn::Close()
 596 {
 597         Instance->Log(DEBUG,"SQLConn::Close");
 598
 599         if (!this->Instance->SE->DelFd(this))
 600         {
 601                 Instance->Log(DEBUG, "PQsocket cant be removed from the socket engine!");
 602         }
 603         this->fd = -1;
 604         this->state = I_ERROR;
 605         this->OnError(I_ERR_SOCKET);
 606         this->ClosePending = true;
 607
 608         if(sql)
 609         {
 610                 PQfinish(sql);
 611                 sql = NULL;
 612         }
 613 }
 614
 615 bool SQLConn::DoPoll()
 616 {
 617         switch(PQconnectPoll(sql))
 618         {
 619                 case PGRES_POLLING_WRITING:
 620                         //ServerInstance->Log(DEBUG, "PGconnectPoll: PGRES_POLLING_WRITING");
 621                         WantWrite();
 622                         status = CWRITE;
 623                         return DoPoll();
 624                 case PGRES_POLLING_READING:
 625                         //ServerInstance->Log(DEBUG, "PGconnectPoll: PGRES_POLLING_READING");
 626                         status = CREAD;
 627                         return true;
 628                 case PGRES_POLLING_FAILED:
 629                         //ServerInstance->Log(DEBUG, "PGconnectPoll: PGRES_POLLING_FAILED: %s", PQerrorMessage(sql));
 630                         return false;
 631                 case PGRES_POLLING_OK:
 632                         //ServerInstance->Log(DEBUG, "PGconnectPoll: PGRES_POLLING_OK");
 633                         status = WWRITE;
 634                         return DoConnectedPoll();
 635                 default:
 636                         //ServerInstance->Log(DEBUG, "PGconnectPoll: wtf?");
 637                         return true;
 638         }
 639 }
 640
 641 bool SQLConn::DoConnectedPoll()
 642 {
 643         if(!qinprog && queue.totalsize())
 644         {
 645                 /* There's no query currently in progress, and there's queries in the queue. */
 646                 SQLrequest& query = queue.front();
 647                 DoQuery(query);
 648         }
 649
 650         if(PQconsumeInput(sql))
 651         {
 652                 Instance->Log(DEBUG, "PQconsumeInput succeeded");
 653
 654                 /* We just read stuff from the server, that counts as it being alive
 655                  * so update the idle-since time :p
 656                  */
 657                 idle = this->Instance->Time();
 658
 659                 if(PQisBusy(sql))
 660                 {
 661                         //ServerInstance->Log(DEBUG, "Still busy processing command though");
 662                 }
 663                 else if(qinprog)
 664                 {
 665                         //ServerInstance->Log(DEBUG, "Looks like we have a result to process!");
 666
 667                         /* Grab the request we're processing */
 668                         SQLrequest& query = queue.front();
 669
 670                         Instance->Log(DEBUG, "ID is %lu", query.id);
 671
 672                         /* Get a pointer to the module we're about to return the result to */
 673                         Module* to = query.GetSource();
 674
 675                         /* Fetch the result.. */
 676                         PGresult* result = PQgetResult(sql);
 677
 678                         /* PgSQL would allow a query string to be sent which has multiple
 679                          * queries in it, this isn't portable across database backends and
 680                          * we don't want modules doing it. But just in case we make sure we
 681                          * drain any results there are and just use the last one.
 682                          * If the module devs are behaving there will only be one result.
 683                          */
 684                         while (PGresult* temp = PQgetResult(sql))
 685                         {
 686                                 PQclear(result);
 687                                 result = temp;
 688                         }
 689
 690                         if(to)
 691                         {
 692                                 /* ..and the result */
 693                                 PgSQLresult reply(us, to, query.id, result);
 694
 695                                 /* Fix by brain, make sure the original query gets sent back in the reply */
 696                                 reply.query = query.query.q;
 697
 698                                 Instance->Log(DEBUG, "Got result, status code: %s; error message: %s", PQresStatus(PQresultStatus(result)), PQresultErrorMessage(result));
 699
 700                                 switch(PQresultStatus(result))
 701                                 {
 702                                         case PGRES_EMPTY_QUERY:
 703                                         case PGRES_BAD_RESPONSE:
 704                                         case PGRES_FATAL_ERROR:
 705                                                 reply.error.Id(QREPLY_FAIL);
 706                                                 reply.error.Str(PQresultErrorMessage(result));
 707                                         default:;
 708                                                 /* No action, other values are not errors */
 709                                 }
 710
 711                                 reply.Send();
 712
 713                                 /* PgSQLresult's destructor will free the PGresult */
 714                         }
 715                         else
 716                         {
 717                                 /* If the client module is unloaded partway through a query then the provider will set
 718                                  * the pointer to NULL. We cannot just cancel the query as the result will still come
 719                                  * through at some point...and it could get messy if we play with invalid pointers...
 720                                  */
 721                                 Instance->Log(DEBUG, "Looks like we're handling a zombie query from a module which unloaded before it got a result..fun. ID: %lu", query.id);
 722                                 PQclear(result);
 723                         }
 724
 725                         qinprog = false;
 726                         queue.pop();
 727                         DoConnectedPoll();
 728                 }
 729                 else
 730                 {
 731                         Instance->Log(DEBUG, "Eh!? We just got a read event, and connection isn't busy..but no result :(");
 732                 }
 733
 734                 return true;
 735         }
 736         else
 737         {
 738                 /* I think we'll assume this means the server died...it might not,
 739                  * but I think that any error serious enough we actually get here
 740                  * deserves to reconnect [/excuse]
 741                  * Returning true so the core doesn't try and close the connection.
 742                  */
 743                 Instance->Log(DEBUG, "PQconsumeInput failed: %s", PQerrorMessage(sql));
 744                 Reconnect();
 745                 return true;
 746         }
 747 }
 748
 749 bool SQLConn::DoResetPoll()
 750 {
 751         switch(PQresetPoll(sql))
 752         {
 753                 case PGRES_POLLING_WRITING:
 754                         //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_WRITING");
 755                         WantWrite();
 756                         status = CWRITE;
 757                         return DoPoll();
 758                 case PGRES_POLLING_READING:
 759                         //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_READING");
 760                         status = CREAD;
 761                         return true;
 762                 case PGRES_POLLING_FAILED:
 763                         //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_FAILED: %s", PQerrorMessage(sql));
 764                         return false;
 765                 case PGRES_POLLING_OK:
 766                         //ServerInstance->Log(DEBUG, "PGresetPoll: PGRES_POLLING_OK");
 767                         status = WWRITE;
 768                         return DoConnectedPoll();
 769                 default:
 770                         //ServerInstance->Log(DEBUG, "PGresetPoll: wtf?");
 771                         return true;
 772         }
 773 }
 774
 775 void SQLConn::ShowStatus()
 776 {
 777         switch(PQstatus(sql))
 778         {
 779                 case CONNECTION_STARTED:
 780                         Instance->Log(DEBUG, "PQstatus: CONNECTION_STARTED: Waiting for connection to be made.");
 781                         break;
 782
 783                 case CONNECTION_MADE:
 784                         Instance->Log(DEBUG, "PQstatus: CONNECTION_MADE: Connection OK; waiting to send.");
 785                         break;
 786
 787                 case CONNECTION_AWAITING_RESPONSE:
 788                         Instance->Log(DEBUG, "PQstatus: CONNECTION_AWAITING_RESPONSE: Waiting for a response from the server.");
 789                         break;
 790
 791                 case CONNECTION_AUTH_OK:
 792                         Instance->Log(DEBUG, "PQstatus: CONNECTION_AUTH_OK: Received authentication; waiting for backend start-up to finish.");
 793                         break;
 794
 795                 case CONNECTION_SSL_STARTUP:
 796                         Instance->Log(DEBUG, "PQstatus: CONNECTION_SSL_STARTUP: Negotiating SSL encryption.");
 797                         break;
 798
 799                 case CONNECTION_SETENV:
 800                         Instance->Log(DEBUG, "PQstatus: CONNECTION_SETENV: Negotiating environment-driven parameter settings.");
 801                         break;
 802
 803                 default:
 804                         Instance->Log(DEBUG, "PQstatus: ???");
 805         }
 806 }
 807
 808 bool SQLConn::OnDataReady()
 809 {
 810         /* Always return true here, false would close the socket - we need to do that ourselves with the pgsql API */
 811         Instance->Log(DEBUG, "OnDataReady(): status = %s", StatusStr());
 812
 813         return DoEvent();
 814 }
 815
 816 bool SQLConn::OnWriteReady()
 817 {
 818         /* Always return true here, false would close the socket - we need to do that ourselves with the pgsql API */
 819         Instance->Log(DEBUG, "OnWriteReady(): status = %s", StatusStr());
 820
 821         return DoEvent();
 822 }
 823
 824 bool SQLConn::OnConnected()
 825 {
 826         Instance->Log(DEBUG, "OnConnected(): status = %s", StatusStr());
 827
 828         return DoEvent();
 829 }
 830
 831 bool SQLConn::Reconnect()
 832 {
 833         Instance->Log(DEBUG, "Initiating reconnect");
 834
 835         if(PQresetStart(sql))
 836         {
 837                 /* Successfully initiatied database reconnect,
 838                  * set flags so PQresetPoll() will be called appropriately
 839                  */
 840                 status = RWRITE;
 841                 qinprog = false;
 842                 return true;
 843         }
 844         else
 845         {
 846                 Instance->Log(DEBUG, "Failed to initiate reconnect...fun");
 847                 return false;
 848         }
 849 }
 850
 851 bool SQLConn::DoEvent()
 852 {
 853         bool ret;
 854
 855         if((status == CREAD) || (status == CWRITE))
 856         {
 857                 ret = DoPoll();
 858         }
 859         else if((status == RREAD) || (status == RWRITE))
 860         {
 861                 ret = DoResetPoll();
 862         }
 863         else
 864         {
 865                 ret = DoConnectedPoll();
 866         }
 867
 868         switch(PQflush(sql))
 869         {
 870                 case -1:
 871                         Instance->Log(DEBUG, "Error flushing write queue: %s", PQerrorMessage(sql));
 872                         break;
 873                 case 0:
 874                         Instance->Log(DEBUG, "Successfully flushed write queue (or there was nothing to write)");
 875                         break;
 876                 case 1:
 877                         Instance->Log(DEBUG, "Not all of the write queue written, triggering write event so we can have another go");
 878                         WantWrite();
 879                         break;
 880         }
 881
 882         return ret;
 883 }
 884
 885 std::string SQLConn::MkInfoStr()
 886 {
 887         std::ostringstream conninfo("connect_timeout = '2'");
 888
 889         if(dbhost.length())
 890                 conninfo << " hostaddr = '" << dbhost << "'";
 891
 892         if(dbport)
 893                 conninfo << " port = '" << dbport << "'";
 894
 895         if(dbname.length())
 896                 conninfo << " dbname = '" << dbname << "'";
 897
 898         if(dbuser.length())
 899                 conninfo << " user = '" << dbuser << "'";
 900
 901         if(dbpass.length())
 902                 conninfo << " password = '" << dbpass << "'";
 903
 904         if(ssl)
 905                 conninfo << " sslmode = 'require'";
 906
 907         return conninfo.str();
 908 }
 909
 910 const char* SQLConn::StatusStr()
 911 {
 912         if(status == CREAD) return "CREAD";
 913         if(status == CWRITE) return "CWRITE";
 914         if(status == WREAD) return "WREAD";
 915         if(status == WWRITE) return "WWRITE";
 916         return "Err...what, erm..BUG!";
 917 }
 918
 919 SQLerror SQLConn::DoQuery(SQLrequest &req)
 920 {
 921         if((status == WREAD) || (status == WWRITE))
 922         {
 923                 if(!qinprog)
 924                 {
 925                         /* Parse the command string and dispatch it */
 926
 927                         /* Pointer to the buffer we screw around with substitution in */
 928                         char* query;
 929                         /* Pointer to the current end of query, where we append new stuff */
 930                         char* queryend;
 931                         /* Total length of the unescaped parameters */
 932                         unsigned int paramlen;
 933
 934                         paramlen = 0;
 935
 936                         for(ParamL::iterator i = req.query.p.begin(); i != req.query.p.end(); i++)
 937                         {
 938                                 paramlen += i->size();
 939                         }
 940
 941                         /* To avoid a lot of allocations, allocate enough memory for the biggest the escaped query could possibly be.
 942                          * sizeofquery + (totalparamlength*2) + 1
 943                          *
 944                          * The +1 is for null-terminating the string for PQsendQuery()
 945                          */
 946
 947                         query = new char[req.query.q.length() + (paramlen*2) + 1];
 948                         queryend = query;
 949
 950                         /* Okay, now we have a buffer large enough we need to start copying the query into it and escaping and substituting
 951                          * the parameters into it...
 952                          */
 953
 954                         for(unsigned int i = 0; i < req.query.q.length(); i++)
 955                         {
 956                                 if(req.query.q[i] == '?')
 957                                 {
 958                                         /* We found a place to substitute..what fun.
 959                                          * Use the PgSQL calls to escape and write the
 960                                          * escaped string onto the end of our query buffer,
 961                                          * then we "just" need to make sure queryend is
 962                                          * pointing at the right place.
 963                                          */
 964
 965                                         if(req.query.p.size())
 966                                         {
 967                                                 int error = 0;
 968                                                 size_t len = 0;
 969
 970 #ifdef PGSQL_HAS_ESCAPECONN
 971                                                 len = PQescapeStringConn(sql, queryend, req.query.p.front().c_str(), req.query.p.front().length(), &error);
 972 #else
 973                                                 len = PQescapeString         (queryend, req.query.p.front().c_str(), req.query.p.front().length());
 974 #endif
 975                                                 if(error)
 976                                                 {
 977                                                         Instance->Log(DEBUG, "Apparently PQescapeStringConn() failed somehow...don't know how or what to do...");
 978                                                 }
 979
 980                                                 Instance->Log(DEBUG, "Appended %d bytes of escaped string onto the query", len);
 981
 982                                                 /* Incremenet queryend to the end of the newly escaped parameter */
 983                                                 queryend += len;
 984
 985                                                 /* Remove the parameter we just substituted in */
 986                                                 req.query.p.pop_front();
 987                                         }
 988                                         else
 989                                         {
 990                                                 Instance->Log(DEBUG, "Found a substitution location but no parameter to substitute :|");
 991                                                 break;
 992                                         }
 993                                 }
 994                                 else
 995                                 {
 996                                         *queryend = req.query.q[i];
 997                                         queryend++;
 998                                 }
 999                         }
1000
1001                         /* Null-terminate the query */
1002                         *queryend = 0;
1003
1004                         Instance->Log(DEBUG, "Attempting to dispatch query: %s", query);
1005
1006                         req.query.q = query;
1007
1008                         if(PQsendQuery(sql, query))
1009                         {
1010                                 Instance->Log(DEBUG, "Dispatched query successfully");
1011                                 qinprog = true;
1012                                 delete[] query;
1013                                 return SQLerror();
1014                         }
1015                         else
1016                         {
1017                                 Instance->Log(DEBUG, "Failed to dispatch query: %s", PQerrorMessage(sql));
1018                                 delete[] query;
1019                                 return SQLerror(QSEND_FAIL, PQerrorMessage(sql));
1020                         }
1021                 }
1022         }
1023
1024         return SQLerror(BAD_CONN, "Can't query until connection is complete");
1025 }
1026
1027 SQLerror SQLConn::Query(const SQLrequest &req)
1028 {
1029         queue.push(req);
1030
1031         if(!qinprog && queue.totalsize())
1032         {
1033                 /* There's no query currently in progress, and there's queries in the queue. */
1034                 SQLrequest& query = queue.front();
1035                 return DoQuery(query);
1036         }
1037         else
1038         {
1039                 return SQLerror();
1040         }
1041 }
1042
1043 void SQLConn::OnUnloadModule(Module* mod)
1044 {
1045         queue.PurgeModule(mod);
1046 }
1047
1048 const SQLhost SQLConn::GetConfHost()
1049 {
1050         return confhost;
1051 }
1052
1053 class ModulePgSQL : public Module
1054 {
1055 private:
1056
1057         ConnMap connections;
1058         unsigned long currid;
1059         char* sqlsuccess;
1060
1061 public:
1062         ModulePgSQL(InspIRCd* Me)
1063         : Module::Module(Me), currid(0)
1064         {
1065                 ServerInstance->UseInterface("SQLutils");
1066
1067                 sqlsuccess = new char[strlen(SQLSUCCESS)+1];
1068
1069                 strlcpy(sqlsuccess, SQLSUCCESS, strlen(SQLSUCCESS)+1);
1070
1071                 if (!ServerInstance->PublishFeature("SQL", this))
1072                 {
1073                         throw ModuleException("m_pgsql: Unable to publish feature 'SQL'");
1074                 }
1075
1076                 ReadConf();
1077
1078                 ServerInstance->PublishInterface("SQL", this);
1079         }
1080
1081         virtual ~ModulePgSQL()
1082         {
1083                 ClearAllConnections();
1084                 DELETE(sqlsuccess);
1085                 ServerInstance->UnpublishInterface("SQL", this);
1086                 ServerInstance->UnpublishFeature("SQL");
1087                 ServerInstance->DoneWithInterface("SQLutils");
1088         }
1089
1090         void Implements(char* List)
1091         {
1092                 List[I_OnUnloadModule] = List[I_OnRequest] = List[I_OnRehash] = List[I_OnUserRegister] = List[I_OnCheckReady] = List[I_OnUserDisconnect] = 1;
1093         }
1094
1095         virtual void OnRehash(const std::string &parameter)
1096         {
1097                 ReadConf();
1098         }
1099
1100         bool HasHost(const SQLhost &host)
1101         {
1102                 for (ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
1103                 {
1104                         if (host == iter->second->GetConfHost())
1105                                 return true;
1106                 }
1107                 return false;
1108         }
1109
1110         bool HostInConf(const SQLhost &h)
1111         {
1112                 ConfigReader conf(ServerInstance);
1113                 for(int i = 0; i < conf.Enumerate("database"); i++)
1114                 {
1115                         SQLhost host;
1116                         host.id         = conf.ReadValue("database", "id", i);
1117                         host.host       = conf.ReadValue("database", "hostname", i);
1118                         host.port       = conf.ReadInteger("database", "port", i, true);
1119                         host.name       = conf.ReadValue("database", "name", i);
1120                         host.user       = conf.ReadValue("database", "username", i);
1121                         host.pass       = conf.ReadValue("database", "password", i);
1122                         host.ssl        = conf.ReadFlag("database", "ssl", i);
1123                         if (h == host)
1124                                 return true;
1125                 }
1126                 return false;
1127         }
1128
1129         void ReadConf()
1130         {
1131                 ConfigReader conf(ServerInstance);
1132
1133                 for(int i = 0; i < conf.Enumerate("database"); i++)
1134                 {
1135                         SQLhost host;
1136                         int ipvalid;
1137                         insp_inaddr blargle;
1138
1139                         host.id         = conf.ReadValue("database", "id", i);
1140                         host.host       = conf.ReadValue("database", "hostname", i);
1141                         host.port       = conf.ReadInteger("database", "port", i, true);
1142                         host.name       = conf.ReadValue("database", "name", i);
1143                         host.user       = conf.ReadValue("database", "username", i);
1144                         host.pass       = conf.ReadValue("database", "password", i);
1145                         host.ssl        = conf.ReadFlag("database", "ssl", i);
1146
1147                         if (HasHost(host))
1148                                 continue;
1149
1150                         ipvalid = insp_aton(host.host.c_str(), &blargle);
1151
1152                         if(ipvalid > 0)
1153                         {
1154                                 /* The conversion succeeded, we were given an IP and we can give it straight to SQLConn */
1155                                 this->AddConn(host, host);
1156                         }
1157                         else if(ipvalid == 0)
1158                         {
1159                                 /* Conversion failed, assume it's a host */
1160                                 SQLresolver* resolver;
1161
1162                                 try
1163                                 {
1164                                         resolver = new SQLresolver(this, ServerInstance, host, host);
1165
1166                                         ServerInstance->AddResolver(resolver);
1167                                 }
1168                                 catch(...)
1169                                 {
1170                                         /* THE WORLD IS COMING TO AN END! */
1171                                         ServerInstance->Log(DEBUG, "Couldn't make a SQLresolver..this connection is gonna diiiiiie...actually we just won't create it");
1172                                 }
1173                         }
1174                         else
1175                         {
1176                                 /* Invalid address family, die horribly. */
1177                                 ServerInstance->Log(DEBUG, "insp_aton failed returning -1, oh noes.");
1178                         }
1179                 }
1180                 ClearOldConnections();
1181         }
1182
1183         void ClearOldConnections()
1184         {
1185                 ConnMap::iterator iter,safei;
1186                 for (iter = connections.begin(); iter != connections.end(); iter++)
1187                 {
1188                         if (!HostInConf(iter->second->GetConfHost()))
1189                         {
1190                                 DELETE(iter->second);
1191                                 safei = iter;
1192                                 --iter;
1193                                 connections.erase(safei);
1194                         }
1195                 }
1196         }
1197
1198         void ClearAllConnections()
1199         {
1200                 ConnMap::iterator iter;
1201                 while ((iter = connections.begin()) != connections.end())
1202                 {
1203                         connections.erase(iter);
1204                         DELETE(iter->second);
1205                 }
1206         }
1207
1208         void AddConn(const SQLhost& hi, const SQLhost& ci)
1209         {
1210                 if (HasHost(ci))
1211                 {
1212                         ServerInstance->Log(DEFAULT, "WARNING: A pgsql connection with id: %s already exists, possibly due to DNS delay. Aborting connection attempt.", hi.id.c_str());
1213                         return;
1214                 }
1215
1216                 SQLConn* newconn;
1217
1218                 /* The conversion succeeded, we were given an IP and we can give it straight to SQLConn */
1219                 newconn = new SQLConn(ServerInstance, this, hi, ci);
1220
1221                 connections.insert(std::make_pair(hi.id, newconn));
1222         }
1223
1224         virtual char* OnRequest(Request* request)
1225         {
1226                 if(strcmp(SQLREQID, request->GetId()) == 0)
1227                 {
1228                         SQLrequest* req = (SQLrequest*)request;
1229                         ConnMap::iterator iter;
1230
1231                         ServerInstance->Log(DEBUG, "Got query: '%s' with %d replacement parameters on id '%s'", req->query.q.c_str(), req->query.p.size(), req->dbid.c_str());
1232
1233                         if((iter = connections.find(req->dbid)) != connections.end())
1234                         {
1235                                 /* Execute query */
1236                                 req->id = NewID();
1237                                 req->error = iter->second->Query(*req);
1238
1239                                 return (req->error.Id() == NO_ERROR) ? sqlsuccess : NULL;
1240                         }
1241                         else
1242                         {
1243                                 req->error.Id(BAD_DBID);
1244                                 return NULL;
1245                         }
1246                 }
1247
1248                 ServerInstance->Log(DEBUG, "Got unsupported API version string: %s", request->GetId());
1249
1250                 return NULL;
1251         }
1252
1253         virtual void OnUnloadModule(Module* mod, const std::string&     name)
1254         {
1255                 /* When a module unloads we have to check all the pending queries for all our connections
1256                  * and set the Module* specifying where the query came from to NULL. If the query has already
1257                  * been dispatched then when it is processed it will be dropped if the pointer is NULL.
1258                  *
1259                  * If the queries we find are not already being executed then we can simply remove them immediately.
1260                  */
1261                 for(ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++)
1262                 {
1263                         iter->second->OnUnloadModule(mod);
1264                 }
1265         }
1266
1267         unsigned long NewID()
1268         {
1269                 if (currid+1 == 0)
1270                         currid++;
1271
1272                 return ++currid;
1273         }
1274
1275         virtual Version GetVersion()
1276         {
1277                 return Version(1, 1, 0, 0, VF_VENDOR|VF_SERVICEPROVIDER, API_VERSION);
1278         }
1279 };
1280
1281 /* move this here to use AddConn, rather that than having the whole
1282  * module above SQLConn, since this is buggin me right now :/
1283  */
1284 void SQLresolver::OnLookupComplete(const std::string &result)
1285 {
1286         host.host = result;
1287         ((ModulePgSQL*)mod)->AddConn(host, confhost);
1288         ((ModulePgSQL*)mod)->ClearOldConnections();
1289 }
1290
1291 class ModulePgSQLFactory : public ModuleFactory
1292 {
1293  public:
1294         ModulePgSQLFactory()
1295         {
1296         }
1297
1298         ~ModulePgSQLFactory()
1299         {
1300         }
1301
1302         virtual Module * CreateModule(InspIRCd* Me)
1303         {
1304                 return new ModulePgSQL(Me);
1305         }
1306 };
1307
1308
1309 extern "C" void * init_module( void )
1310 {
1311 //      PQregisterThreadLock(pgthreadlock_t(1));
1312         return new ModulePgSQLFactory;
1313 }