X-Git-Url: https://git.netwichtig.de/gitweb/?a=blobdiff_plain;f=src%2Fmodules%2Fextra%2Fm_pgsql.cpp;h=1790fdfef228e14ae11e21c6cc62cd5f58743317;hb=ac7defcd3e52695dcf5e5150e9fe3e1624205e64;hp=14e32ac36d14ea1a589432e55f9dda611c69424d;hpb=a09109f61286bcd50ec5b8aaf08b98dd9a3985c3;p=user%2Fhenk%2Fcode%2Finspircd.git diff --git a/src/modules/extra/m_pgsql.cpp b/src/modules/extra/m_pgsql.cpp index 14e32ac36..ab6908d17 100644 --- a/src/modules/extra/m_pgsql.cpp +++ b/src/modules/extra/m_pgsql.cpp @@ -1,679 +1,623 @@ -/* +------------------------------------+ - * | Inspire Internet Relay Chat Daemon | - * +------------------------------------+ +/* + * InspIRCd -- Internet Relay Chat Daemon * - * InspIRCd is copyright (C) 2002-2004 ChatSpike-Dev. - * E-mail: - * - * - * - * - * Written by Craig Edwards, Craig McLure, and others. - * This program is free but copyrighted software; see - * the file COPYING for details. + * Copyright (C) 2009-2010 Daniel De Graaf + * Copyright (C) 2006-2007, 2009 Dennis Friis + * Copyright (C) 2006-2007, 2009 Craig Edwards + * Copyright (C) 2008 Robin Burchell + * Copyright (C) 2008 Thomas Stagner + * Copyright (C) 2006 Oliver Lupton * - * --------------------------------------------------- + * This file is part of InspIRCd. InspIRCd is free software: you can + * redistribute it and/or modify it under the terms of the GNU General Public + * License as published by the Free Software Foundation, version 2. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more + * details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . */ -#include -#include -#include -#include -#include -#include "users.h" -#include "channels.h" -#include "modules.h" -#include "helperfuncs.h" #include "inspircd.h" -#include "configreader.h" - -#include "m_sqlv2.h" +#include +#include +#include +#include "sql.h" /* $ModDesc: PostgreSQL Service Provider module for all other m_sql* modules, uses v2 of the SQL API */ -/* $CompileFlags: -I`pg_config --includedir` */ -/* $LinkerFlags: -L`pg_config --libdir` -lpq */ - -/* UGH, UGH, UGH, UGH, UGH, UGH - * I'm having trouble seeing how I - * can avoid this. The core-defined - * constructors for InspSocket just - * aren't suitable...and if I'm - * reimplementing them I need this so - * I can access the socket engine :\ +/* $CompileFlags: -Iexec("pg_config --includedir") eval("my $s = `pg_config --version`;$s =~ /^.*?(\d+)\.(\d+)\.(\d+).*?$/;my $v = hex(sprintf("0x%02x%02x%02x", $1, $2, $3));print "-DPGSQL_HAS_ESCAPECONN" if(($v >= 0x080104) || ($v >= 0x07030F && $v < 0x070400) || ($v >= 0x07040D && $v < 0x080000) || ($v >= 0x080008 && $v < 0x080100));") */ +/* $LinkerFlags: -Lexec("pg_config --libdir") -lpq */ + +/* SQLConn rewritten by peavey to + * use EventHandler instead of + * BufferedSocket. This is much neater + * and gives total control of destroy + * and delete of resources. */ -extern InspIRCd* ServerInstance; -InspSocket* socket_ref[MAX_DESCRIPTORS]; /* Forward declare, so we can have the typedef neatly at the top */ class SQLConn; +class ModulePgSQL; typedef std::map ConnMap; /* CREAD, Connecting and wants read event * CWRITE, Connecting and wants write event * WREAD, Connected/Working and wants read event - * WWRITE, Connected/Working and wants write event + * WWRITE, Connected/Working and wants write event + * RREAD, Resetting and wants read event + * RWRITE, Resetting and wants write event */ -enum SQLstatus { CREAD, CWRITE, WREAD, WWRITE }; - -/** QueryQueue, a queue of queries waiting to be executed. - * This maintains two queues internally, one for 'priority' - * queries and one for less important ones. Each queue has - * new queries appended to it and ones to execute are popped - * off the front. This keeps them flowing round nicely and no - * query should ever get 'stuck' for too long. If there are - * queries in the priority queue they will be executed first, - * 'unimportant' queries will only be executed when the - * priority queue is empty. - * - * These are lists of SQLresult so we can, from the moment the - * SQLrequest is recieved, be beginning to construct the result - * object. The copy in the deque can then be submitted in-situ - * and finally deleted from this queue. No copies of the SQLresult :) - * - * Because we work on the SQLresult in-situ, we need a way of accessing the - * result we are currently processing, QueryQueue::front(), but that call - * needs to always return the same element until that element is removed - * from the queue, this is what the 'which' variable is. New queries are - * always added to the back of one of the two queues, but if when front() - * is first called then the priority queue is empty then front() will return - * a query from the normal queue, but if a query is then added to the priority - * queue then front() must continue to return the front of the *normal* queue - * until pop() is called. +enum SQLstatus { CREAD, CWRITE, WREAD, WWRITE, RREAD, RWRITE }; + +class ReconnectTimer : public Timer +{ + private: + ModulePgSQL* mod; + public: + ReconnectTimer(ModulePgSQL* m) : Timer(5, ServerInstance->Time(), false), mod(m) + { + } + virtual void Tick(time_t TIME); +}; + +struct QueueItem +{ + SQLQuery* c; + std::string q; + QueueItem(SQLQuery* C, const std::string& Q) : c(C), q(Q) {} +}; + +/** PgSQLresult is a subclass of the mostly-pure-virtual class SQLresult. + * All SQL providers must create their own subclass and define it's methods using that + * database library's data retriveal functions. The aim is to avoid a slow and inefficient process + * of converting all data to a common format before it reaches the result structure. This way + * data is passes to the module nearly as directly as if it was using the API directly itself. */ -class QueryQueue +class PgSQLresult : public SQLResult { -private: - std::deque priority; /* The priority queue */ - std::deque normal; /* The 'normal' queue */ - enum { PRI, NOR, NON } which; /* Which queue the currently active element is at the front of */ - -public: - QueryQueue() - : which(NON) + PGresult* res; + int currentrow; + int rows; + public: + PgSQLresult(PGresult* result) : res(result), currentrow(0) { - + rows = PQntuples(res); + if (!rows) + rows = atoi(PQcmdTuples(res)); } - - void push(const Query &q, bool pri = false) + + ~PgSQLresult() { - log(DEBUG, "QueryQueue::push_back(): Adding %s query to queue: %s", ((pri) ? "priority" : "non-priority"), q.c_str()); - - if(pri) - priority.push_back(q); - else - normal.push_back(q); + PQclear(res); } - - void pop() + + virtual int Rows() { - if((which == PRI) && priority.size()) - { - priority.pop_front(); - } - else if((which == NOR) && normal.size()) - { - normal.pop_front(); - } - - /* Silently do nothing if there was no element to pop() */ + return rows; } - - SQLresult& front() + + virtual void GetCols(std::vector& result) { - switch(which) + result.resize(PQnfields(res)); + for(unsigned int i=0; i < result.size(); i++) { - case PRI: - return priority.front(); - case NOR: - return normal.front(); - default: - if(priority.size()) - { - which = PRI; - return priority.front(); - } - - if(normal.size()) - { - which = NOR; - return normal.front(); - } - - /* This will probably result in a segfault, - * but the caller should have checked totalsize() - * first so..meh - moron :p - */ - - return priority.front(); + result[i] = PQfname(res, i); } } - - std::pair size() + + virtual SQLEntry GetValue(int row, int column) { - return std::make_pair(priority.size(), normal.size()); + char* v = PQgetvalue(res, row, column); + if (!v || PQgetisnull(res, row, column)) + return SQLEntry(); + + return SQLEntry(std::string(v, PQgetlength(res, row, column))); } - - int totalsize() + + virtual bool GetRow(SQLEntries& result) { - return priority.size() + normal.size(); + if (currentrow >= PQntuples(res)) + return false; + int ncols = PQnfields(res); + + for(int i = 0; i < ncols; i++) + { + result.push_back(GetValue(currentrow, i)); + } + currentrow++; + + return true; } }; /** SQLConn represents one SQL session. - * Each session has its own persistent connection to the database. - * This is a subclass of InspSocket so it can easily recieve read/write events from the core socket - * engine, unlike the original MySQL module this module does not block. Ever. It gets a mild stabbing - * if it dares to. */ - -class SQLConn : public InspSocket +class SQLConn : public SQLProvider, public EventHandler { -private: - Server* Srv; /* Server* for..uhm..something, maybe */ - std::string dbhost; /* Database server hostname */ - unsigned int dbport; /* Database server port */ - std::string dbname; /* Database name */ - std::string dbuser; /* Database username */ - std::string dbpass; /* Database password */ - bool ssl; /* If we should require SSL */ - PGconn* sql; /* PgSQL database connection handle */ - SQLstatus status; /* PgSQL database connection status */ - bool qinprog;/* If there is currently a query in progress */ - QueryQueue queue; /* Queue of queries waiting to be executed on this connection */ - Query query; /* The currently active query on this connection */ - -public: - - /* This class should only ever be created inside this module, using this constructor, so we don't have to worry about the default ones */ - - SQLConn(Server* srv, const std::string &h, unsigned int p, const std::string &d, const std::string &u, const std::string &pwd, bool s) - : InspSocket::InspSocket(), Srv(srv), dbhost(h), dbport(p), dbname(d), dbuser(u), dbpass(pwd), ssl(s), sql(NULL), status(CWRITE), qinprog(false) + public: + reference conf; /* The entry */ + std::deque queue; + PGconn* sql; /* PgSQL database connection handle */ + SQLstatus status; /* PgSQL database connection status */ + QueueItem qinprog; /* If there is currently a query in progress */ + + SQLConn(Module* Creator, ConfigTag* tag) + : SQLProvider(Creator, "SQL/" + tag->getString("id")), conf(tag), sql(NULL), status(CWRITE), qinprog(NULL, "") { - 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()); - - /* Some of this could be reviewed, unsure if I need to fill 'host' etc... - * just copied this over from the InspSocket constructor. - */ - strlcpy(this->host, dbhost.c_str(), MAXBUF); - this->port = dbport; - - this->ClosePending = false; - - if(!inet_aton(this->host, &this->addy)) - { - /* Its not an ip, spawn the resolver. - * PgSQL doesn't do nonblocking DNS - * lookups, so we do it for it. - */ - - log(DEBUG,"Attempting to resolve %s", this->host); - - this->dns.SetNS(Srv->GetConfig()->DNSServer); - this->dns.ForwardLookupWithFD(this->host, fd); - - this->state = I_RESOLVING; - socket_ref[this->fd] = this; - - return; - } - else + if (!DoConnect()) { - log(DEBUG,"No need to resolve %s", this->host); - strlcpy(this->IP, this->host, MAXBUF); - - if(!this->DoConnect()) - { - throw ModuleException("Connect failed"); - } + ServerInstance->Logs->Log("m_pgsql",DEFAULT, "WARNING: Could not connect to database " + tag->getString("id")); + DelayReconnect(); } } - - ~SQLConn() + + CullResult cull() { - Close(); + this->SQLProvider::cull(); + ServerInstance->Modules->DelService(*this); + return this->EventHandler::cull(); } - - bool DoResolve() - { - log(DEBUG, "Checking for DNS lookup result"); - - if(this->dns.HasResult()) + + ~SQLConn() + { + SQLerror err(SQL_BAD_DBID); + if (qinprog.c) { - std::string res_ip = dns.GetResultIP(); - - if(res_ip.length()) - { - log(DEBUG, "Got result: %s", res_ip.c_str()); - - strlcpy(this->IP, res_ip.c_str(), MAXBUF); - dbhost = res_ip; - - socket_ref[this->fd] = NULL; - - return this->DoConnect(); - } - else - { - log(DEBUG, "DNS lookup failed, dying horribly"); - Close(); - return false; - } + qinprog.c->OnError(err); + delete qinprog.c; } - else + for(std::deque::iterator i = queue.begin(); i != queue.end(); i++) { - log(DEBUG, "No result for lookup yet!"); - return true; + SQLQuery* q = i->c; + q->OnError(err); + delete q; } } - bool DoConnect() + virtual void HandleEvent(EventType et, int errornum) { - log(DEBUG, "SQLConn::DoConnect()"); - - if(!(sql = PQconnectStart(MkInfoStr().c_str()))) + switch (et) { - log(DEBUG, "Couldn't allocate PGconn structure, aborting: %s", PQerrorMessage(sql)); - Close(); - return false; + case EVENT_READ: + case EVENT_WRITE: + DoEvent(); + break; + + case EVENT_ERROR: + DelayReconnect(); } - + } + + std::string GetDSN() + { + std::ostringstream conninfo("connect_timeout = '5'"); + std::string item; + + if (conf->readString("host", item)) + conninfo << " host = '" << item << "'"; + + if (conf->readString("port", item)) + conninfo << " port = '" << item << "'"; + + if (conf->readString("name", item)) + conninfo << " dbname = '" << item << "'"; + + if (conf->readString("user", item)) + conninfo << " user = '" << item << "'"; + + if (conf->readString("pass", item)) + conninfo << " password = '" << item << "'"; + + if (conf->getBool("ssl")) + conninfo << " sslmode = 'require'"; + else + conninfo << " sslmode = 'disable'"; + + return conninfo.str(); + } + + bool DoConnect() + { + sql = PQconnectStart(GetDSN().c_str()); + if (!sql) + return false; + if(PQstatus(sql) == CONNECTION_BAD) - { - log(DEBUG, "PQconnectStart failed: %s", PQerrorMessage(sql)); - Close(); return false; - } - - ShowStatus(); - + if(PQsetnonblocking(sql, 1) == -1) - { - log(DEBUG, "Couldn't set connection nonblocking: %s", PQerrorMessage(sql)); - Close(); return false; - } - + /* OK, we've initalised the connection, now to get it hooked into the socket engine - * and then start polling it. - */ - - log(DEBUG, "Old DNS socket: %d", this->fd); + * and then start polling it. + */ this->fd = PQsocket(sql); - log(DEBUG, "New SQL socket: %d", this->fd); - + if(this->fd <= -1) + return false; + + if (!ServerInstance->SE->AddFd(this, FD_WANT_NO_WRITE | FD_WANT_NO_READ)) { - log(DEBUG, "PQsocket says we have an invalid FD: %d", this->fd); - Close(); + ServerInstance->Logs->Log("m_pgsql",DEBUG, "BUG: Couldn't add pgsql socket to socket engine"); return false; } - - this->state = I_CONNECTING; - ServerInstance->SE->AddFd(this->fd,false,X_ESTAB_MODULE); - socket_ref[this->fd] = this; - + /* Socket all hooked into the engine, now to tell PgSQL to start connecting */ - return DoPoll(); } - - virtual void Close() - { - log(DEBUG,"SQLConn::Close"); - - if(this->fd > 01) - socket_ref[this->fd] = NULL; - this->fd = -1; - this->state = I_ERROR; - this->OnError(I_ERR_SOCKET); - this->ClosePending = true; - - if(sql) - { - PQfinish(sql); - sql = NULL; - } - - return; - } - + bool DoPoll() { switch(PQconnectPoll(sql)) { case PGRES_POLLING_WRITING: - log(DEBUG, "PGconnectPoll: PGRES_POLLING_WRITING"); - WantWrite(); + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_WRITE | FD_WANT_NO_READ); status = CWRITE; - return DoPoll(); + return true; case PGRES_POLLING_READING: - log(DEBUG, "PGconnectPoll: PGRES_POLLING_READING"); + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); status = CREAD; - break; + return true; case PGRES_POLLING_FAILED: - log(DEBUG, "PGconnectPoll: PGRES_POLLING_FAILED: %s", PQerrorMessage(sql)); return false; case PGRES_POLLING_OK: - log(DEBUG, "PGconnectPoll: PGRES_POLLING_OK"); + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); status = WWRITE; - return DoConnectedPoll() + DoConnectedPoll(); default: - log(DEBUG, "PGconnectPoll: wtf?"); - break; + return true; } - - return true; } - - bool DoConnectedPoll() + + void DoConnectedPoll() { - if(!qinprog && queue.totalsize()) +restart: + while (qinprog.q.empty() && !queue.empty()) { /* There's no query currently in progress, and there's queries in the queue. */ - query = queue.pop_front(); - DoQuery(); + DoQuery(queue.front()); + queue.pop_front(); } - - if(PQconsumeInput(sql)) + + if (PQconsumeInput(sql)) { - log(DEBUG, "PQconsumeInput succeeded"); - - if(PQisBusy(sql)) + if (PQisBusy(sql)) { - log(DEBUG, "Still busy processing command though"); + /* Nothing happens here */ } - else + else if (qinprog.c) { - log(DEBUG, "Looks like we have a result to process!"); - - while(PGresult* result = PQgetResult(sql)) + /* Fetch the result.. */ + PGresult* result = PQgetResult(sql); + + /* PgSQL would allow a query string to be sent which has multiple + * queries in it, this isn't portable across database backends and + * we don't want modules doing it. But just in case we make sure we + * drain any results there are and just use the last one. + * If the module devs are behaving there will only be one result. + */ + while (PGresult* temp = PQgetResult(sql)) + { + PQclear(result); + result = temp; + } + + /* ..and the result */ + PgSQLresult reply(result); + switch(PQresultStatus(result)) { - int cols = PQnfields(result); - - log(DEBUG, "Got result! :D"); - log(DEBUG, "%d rows, %d columns checking now what the column names are", PQntuples(result), cols); - - for(int i = 0; i < cols; i++) + case PGRES_EMPTY_QUERY: + case PGRES_BAD_RESPONSE: + case PGRES_FATAL_ERROR: { - log(DEBUG, "Column name: %s (%d)", PQfname(result, i)); + SQLerror err(SQL_QREPLY_FAIL, PQresultErrorMessage(result)); + qinprog.c->OnError(err); + break; } - - PQclear(result); + default: + /* Other values are not errors */ + qinprog.c->OnResult(reply); } - - qinprog = false; + + delete qinprog.c; + qinprog = QueueItem(NULL, ""); + goto restart; + } + else + { + qinprog.q.clear(); } - - return true; } - - log(DEBUG, "PQconsumeInput failed: %s", PQerrorMessage(sql)); - return false; + else + { + /* I think we'll assume this means the server died...it might not, + * but I think that any error serious enough we actually get here + * deserves to reconnect [/excuse] + * Returning true so the core doesn't try and close the connection. + */ + DelayReconnect(); + } } - - void ShowStatus() + + bool DoResetPoll() { - switch(PQstatus(sql)) + switch(PQresetPoll(sql)) { - case CONNECTION_STARTED: - log(DEBUG, "PQstatus: CONNECTION_STARTED: Waiting for connection to be made."); - break; - - case CONNECTION_MADE: - log(DEBUG, "PQstatus: CONNECTION_MADE: Connection OK; waiting to send."); - break; - - case CONNECTION_AWAITING_RESPONSE: - log(DEBUG, "PQstatus: CONNECTION_AWAITING_RESPONSE: Waiting for a response from the server."); - break; - - case CONNECTION_AUTH_OK: - log(DEBUG, "PQstatus: CONNECTION_AUTH_OK: Received authentication; waiting for backend start-up to finish."); - break; - - case CONNECTION_SSL_STARTUP: - log(DEBUG, "PQstatus: CONNECTION_SSL_STARTUP: Negotiating SSL encryption."); - break; - - case CONNECTION_SETENV: - log(DEBUG, "PQstatus: CONNECTION_SETENV: Negotiating environment-driven parameter settings."); - break; - + case PGRES_POLLING_WRITING: + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_WRITE | FD_WANT_NO_READ); + status = CWRITE; + return DoPoll(); + case PGRES_POLLING_READING: + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); + status = CREAD; + return true; + case PGRES_POLLING_FAILED: + return false; + case PGRES_POLLING_OK: + ServerInstance->SE->ChangeEventMask(this, FD_WANT_POLL_READ | FD_WANT_NO_WRITE); + status = WWRITE; + DoConnectedPoll(); default: - log(DEBUG, "PQstatus: ???"); + return true; } } - - virtual bool OnDataReady() - { - /* Always return true here, false would close the socket - we need to do that ourselves with the pgsql API */ - log(DEBUG, "OnDataReady(): status = %s", StatusStr()); - - return DoEvent(); - } - virtual bool OnWriteReady() - { - /* Always return true here, false would close the socket - we need to do that ourselves with the pgsql API */ - log(DEBUG, "OnWriteReady(): status = %s", StatusStr()); - - return DoEvent(); - } - - virtual bool OnConnected() - { - log(DEBUG, "OnConnected(): status = %s", StatusStr()); - - return DoEvent(); - } - - bool DoEvent() + void DelayReconnect(); + + void DoEvent() { - bool ret; - if((status == CREAD) || (status == CWRITE)) { - ret = DoPoll(); + DoPoll(); } - else + else if((status == RREAD) || (status == RWRITE)) { - ret = DoConnectedPoll(); + DoResetPoll(); } - - switch(PQflush(sql)) + else { - case -1: - log(DEBUG, "Error flushing write queue: %s", PQerrorMessage(sql)); - break; - case 0: - log(DEBUG, "Successfully flushed write queue (or there was nothing to write)"); - break; - case 1: - log(DEBUG, "Not all of the write queue written, triggering write event so we can have another go"); - WantWrite(); - break; + DoConnectedPoll(); } - - return ret; } - - std::string MkInfoStr() - { - /* XXX - This needs nonblocking DNS lookups */ - - std::ostringstream conninfo("connect_timeout = '2'"); - - if(dbhost.length()) - conninfo << " hostaddr = '" << dbhost << "'"; - - if(dbport) - conninfo << " port = '" << dbport << "'"; - - if(dbname.length()) - conninfo << " dbname = '" << dbname << "'"; - - if(dbuser.length()) - conninfo << " user = '" << dbuser << "'"; - - if(dbpass.length()) - conninfo << " password = '" << dbpass << "'"; - - if(ssl) - conninfo << " sslmode = 'require'"; - - return conninfo.str(); - } - - const char* StatusStr() + + void submit(SQLQuery *req, const std::string& q) { - if(status == CREAD) return "CREAD"; - if(status == CWRITE) return "CWRITE"; - if(status == WREAD) return "WREAD"; - if(status == WWRITE) return "WWRITE"; - return "Err...what, erm..BUG!"; + if (qinprog.q.empty()) + { + DoQuery(QueueItem(req,q)); + } + else + { + // wait your turn. + queue.push_back(QueueItem(req,q)); + } } - - SQLerror Query(const Query &query, bool pri) + + void submit(SQLQuery *req, const std::string& q, const ParamL& p) { - queue.push_back(query, pri); - - if((status == WREAD) || (status == WWRITE)) + std::string res; + unsigned int param = 0; + for(std::string::size_type i = 0; i < q.length(); i++) { - if(!qinprog) + if (q[i] != '?') + res.push_back(q[i]); + else { - if(PQsendQuery(sql, query.c_str())) + if (param < p.size()) { - log(DEBUG, "Dispatched query: %s", query.c_str()); - qinprog = true; - return SQLerror(); + std::string parm = p[param++]; + char buffer[MAXBUF]; +#ifdef PGSQL_HAS_ESCAPECONN + int error; + PQescapeStringConn(sql, buffer, parm.c_str(), parm.length(), &error); + if (error) + ServerInstance->Logs->Log("m_pgsql", DEBUG, "BUG: Apparently PQescapeStringConn() failed"); +#else + PQescapeString (buffer, parm.c_str(), parm.length()); +#endif + res.append(buffer); } - else + } + } + submit(req, res); + } + + void submit(SQLQuery *req, const std::string& q, const ParamM& p) + { + std::string res; + for(std::string::size_type i = 0; i < q.length(); i++) + { + if (q[i] != '$') + res.push_back(q[i]); + else + { + std::string field; + i++; + while (i < q.length() && isalnum(q[i])) + field.push_back(q[i++]); + i--; + + ParamM::const_iterator it = p.find(field); + if (it != p.end()) { - log(DEBUG, "Failed to dispatch query: %s", PQerrorMessage(sql)); - return SQLerror(QSEND_FAIL, PQerrorMessage(sql)); + std::string parm = it->second; + char buffer[MAXBUF]; +#ifdef PGSQL_HAS_ESCAPECONN + int error; + PQescapeStringConn(sql, buffer, parm.c_str(), parm.length(), &error); + if (error) + ServerInstance->Logs->Log("m_pgsql", DEBUG, "BUG: Apparently PQescapeStringConn() failed"); +#else + PQescapeString (buffer, parm.c_str(), parm.length()); +#endif + res.append(buffer); } } } + submit(req, res); + } + + void DoQuery(const QueueItem& req) + { + if (status != WREAD && status != WWRITE) + { + // whoops, not connected... + SQLerror err(SQL_BAD_CONN); + req.c->OnError(err); + delete req.c; + return; + } + + if(PQsendQuery(sql, req.q.c_str())) + { + qinprog = req; + } + else + { + SQLerror err(SQL_QSEND_FAIL, PQerrorMessage(sql)); + req.c->OnError(err); + delete req.c; + } + } + + void Close() + { + ServerInstance->SE->DelFd(this); - log(DEBUG, "Can't query until connection is complete"); - return SQLerror(BAD_CONN, "Can't query until connection is complete"); + if(sql) + { + PQfinish(sql); + sql = NULL; + } } }; class ModulePgSQL : public Module { -private: - Server* Srv; + public: ConnMap connections; + ReconnectTimer* retimer; -public: - ModulePgSQL(Server* Me) - : Module::Module(Me), Srv(Me) + ModulePgSQL() { - log(DEBUG, "%s 'SQL' feature", Srv->PublishFeature("SQL", this) ? "Published" : "Couldn't publish"); - log(DEBUG, "%s 'PgSQL' feature", Srv->PublishFeature("PgSQL", this) ? "Published" : "Couldn't publish"); - - OnRehash(""); } - void Implements(char* List) + void init() { - List[I_OnRequest] = List[I_OnRehash] = List[I_OnUserRegister] = List[I_OnCheckReady] = List[I_OnUserDisconnect] = 1; + ReadConf(); + + Implementation eventlist[] = { I_OnUnloadModule, I_OnRehash }; + ServerInstance->Modules->Attach(eventlist, this, 2); } - virtual void OnRehash(const std::string ¶meter) + virtual ~ModulePgSQL() { - ConfigReader conf; - - /* Delete all the SQLConn objects in the connection lists, - * this will call their destructors where they can handle - * closing connections and such. - */ - for(ConnMap::iterator iter = connections.begin(); iter != connections.end(); iter++) - { - DELETE(iter->second); - } - - /* Empty out our list of connections */ - connections.clear(); + if (retimer) + ServerInstance->Timers->DelTimer(retimer); + ClearAllConnections(); + } - for(int i = 0; i < conf.Enumerate("database"); i++) - { - std::string id; - SQLConn* newconn; - - id = conf.ReadValue("database", "id", i); - newconn = new SQLConn(Srv, conf.ReadValue("database", "hostname", i), - conf.ReadInteger("database", "port", i, true), - conf.ReadValue("database", "name", i), - conf.ReadValue("database", "username", i), - conf.ReadValue("database", "password", i), - conf.ReadFlag("database", "ssl", i)); - - connections.insert(std::make_pair(id, newconn)); - } + virtual void OnRehash(User* user) + { + ReadConf(); } - - virtual char* OnRequest(Request* request) + + void ReadConf() { - if(strcmp(SQLREQID, request->GetData()) == 0) + ConnMap conns; + ConfigTagList tags = ServerInstance->Config->ConfTags("database"); + for(ConfigIter i = tags.first; i != tags.second; i++) { - SQLrequest* req = (SQLrequest*)request; - ConnMap::iterator iter; - - log(DEBUG, "Got query: '%s' on id '%s'", req->query.c_str(), req->dbid.c_str()); - - if((iter = connections.find(req->dbid)) != connections.end()) + if (i->second->getString("module", "pgsql") != "pgsql") + continue; + std::string id = i->second->getString("id"); + ConnMap::iterator curr = connections.find(id); + if (curr == connections.end()) { - /* Execute query */ - req->error = iter->second->Query(Query(req->query, req->GetSource(), this), req->pri); - - return SQLSUCCESS; + SQLConn* conn = new SQLConn(this, i->second); + conns.insert(std::make_pair(id, conn)); + ServerInstance->Modules->AddService(*conn); } else { - req->error.Id(BAD_DBID); - return NULL; + conns.insert(*curr); + connections.erase(curr); } } - - log(DEBUG, "Got unsupported API version string: %s", request->GetData()); - - return NULL; + ClearAllConnections(); + conns.swap(connections); } - - virtual Version GetVersion() - { - return Version(1, 0, 0, 0, VF_VENDOR|VF_SERVICEPROVIDER); - } - - virtual ~ModulePgSQL() - { - } -}; -class ModulePgSQLFactory : public ModuleFactory -{ - public: - ModulePgSQLFactory() + void ClearAllConnections() { + for(ConnMap::iterator i = connections.begin(); i != connections.end(); i++) + { + i->second->cull(); + delete i->second; + } + connections.clear(); } - - ~ModulePgSQLFactory() + + void OnUnloadModule(Module* mod) { + SQLerror err(SQL_BAD_DBID); + for(ConnMap::iterator i = connections.begin(); i != connections.end(); i++) + { + SQLConn* conn = i->second; + if (conn->qinprog.c && conn->qinprog.c->creator == mod) + { + conn->qinprog.c->OnError(err); + delete conn->qinprog.c; + conn->qinprog.c = NULL; + } + std::deque::iterator j = conn->queue.begin(); + while (j != conn->queue.end()) + { + SQLQuery* q = j->c; + if (q->creator == mod) + { + q->OnError(err); + delete q; + j = conn->queue.erase(j); + } + else + j++; + } + } } - - virtual Module * CreateModule(Server* Me) + + Version GetVersion() { - return new ModulePgSQL(Me); + return Version("PostgreSQL Service Provider module for all other m_sql* modules, uses v2 of the SQL API", VF_VENDOR); } }; +void ReconnectTimer::Tick(time_t time) +{ + mod->retimer = NULL; + mod->ReadConf(); +} -extern "C" void * init_module( void ) +void SQLConn::DelayReconnect() { - return new ModulePgSQLFactory; + ModulePgSQL* mod = (ModulePgSQL*)(Module*)creator; + ConnMap::iterator it = mod->connections.find(conf->getString("id")); + if (it != mod->connections.end()) + { + mod->connections.erase(it); + ServerInstance->GlobalCulls.AddItem((EventHandler*)this); + if (!mod->retimer) + { + mod->retimer = new ReconnectTimer(mod); + ServerInstance->Timers->AddTimer(mod->retimer); + } + } } + +MODULE_INIT(ModulePgSQL)